In the era of large models, is the job of programmers still "writing programs"?

From data to large model application, on November 25th, Hangzhou Yuanchuang Conference was held to share development tips.

In the past, the responsibilities of a programmer were very clear. You had to master the basic principles of computers and software, master at least one programming language, understand several popular frameworks, write and debug code, and ensure that the application runs normally. Become a qualified programmer.

However, a truly professional "programmer" is not limited to this.

Due to the long-term maintenance nature and inherent complexity of software, writing software that is efficient, high-quality, and easy to maintain over the long term is very challenging. Therefore, for a "software engineer", it is particularly important to have professional abilities such as writing high-cohesion, low-coupling code and mastering evolutionary design.

Frankly, many programmers today may not be able to reach the level required to become a "professional" programmer. However, since the demand for talents in the software industry is very large, it does not care too much about whether they are very professional.

The advent of the era of large-scale models may fundamentally change the status quo. Programmers can easily master different front-end frameworks (based on TypeScript), understand machine learning algorithms, cloud native infrastructure, and learn various components in just a few months through large model tools on the market and the use of frames. Experience with languages, frameworks, and infrastructure doesn't seem to be that important anymore. Full stack, once a very distant goal, has become very achievable today.

With the advent of the era of large models, programmers' work efficiency has also been substantially improved. Take FuncGPT (Hui Function) launched by Feisuan SoFlu software robot, which focuses on generating AI functions in Java, as an example. It supports the creation of all types of functions. Use natural language to describe Java function requirements and generate high-quality, highly readable, ready-to-use Java function code in real time. The generated code can be directly copied to IDEA, or imported into the Java fully automatic development tool function library with one click to meet programmers' different usage scenarios.

The arrival of code generators like FuncGPT (FuncGPT) frees programmers from the daily simple and repetitive "writing code". It used to take 80% of the coding time and left it to AI tools to complete, freeing themselves to be able to Focus more on 20% of the work, think about issues such as demand analysis and technical design from a higher perspective, change from "programmer" to "architect", from "writing code" to "designing programs", and completely release The innovative potential of every developer.

So in the era of big models, what is the real ability of a "software engineer"?

Requirements analysis ability

Needs analysis has always been an extremely important issue. Requirements analysis requires a very structured approach from clarifying business goals, to designing demand solutions, to clarifying business rules. Among them, the definition of goals and specific businesses cannot be solved by current AI, and they are also the value of an excellent product manager. With the emergence of large models, the productivity of software development has increased significantly. The full stack is no longer just a full stack in the technical domain, but a full stack that can be extended forward to the demand and business fields. This also means that if you want to become a good development engineer, here is your chance!

domain model

Domain model is a very critical but most easily ignored aspect in the field of software development. The domain model reflects the key concepts in a field and the relationships between them. It is our simplification and mental mapping of the real world. In fact, it is also a direct response to Brooks's discussion of the essential complexity of software development. Without a good domain model, software development is bound to be chaotic. In the era of large models, software development is bound to accelerate, so humans and AI need to collaborate effectively. In this case, leveraging domain models will become an important factor in improving efficiency.

Modularity, interfaces and contracts

For large-scale programs, we often choose to divide and conquer complex problems. The decomposed small problems have the characteristics of high cohesion and low coupling, and the boundaries between them are clarified and solved one by one. Through modularization, we can reuse previously completed work, improve efficiency, and avoid duplication of work. In the era of artificial intelligence, modularization has become more important, which is also the significance of the emergence of code generation tools such as FuncGPT (Hui Function). Of course, if we want AI to better help us with modularization, we still need the guidance and collaboration of human engineers.

Evolutionary design, the problem remains unchanged, the method deserves to be rethought

Changeability is a fundamental characteristic of software, and the ability to continuously evolve, just like evolution in nature, is essential.

Automated Testing : The importance of automated testing will not diminish as it is a way of ensuring the contract.

Test-driven development : The classic test-driven development approach may have some variations. One possible direction of change is for humans to use testing to express contracts, and for artificial intelligence to be responsible for implementing them.

Pair Programming : If you have previously embraced the idea of pair programming and are familiar with the techniques of pair programming, you will be more at home now that you have a "knowledgeable" programming partner.

Continuous integration : The importance of continuous integration is becoming increasingly important.

Clean code: entry-level practice for software development - clean code, because the emergence of AI code tools may no longer be necessary, because current technology can already meet this need well. Or take the "List sorting function" generated by FuncgptGPT (Hui function) as an example:

// 类名：ListSorter
// 函数名：sortList
// 函数功能：对List进行排序
// POM依赖包：
// <dependency>
//     <groupId>org.apache.commons</groupId>
//     <artifactId>commons-lang3</artifactId>
//     <version>3.12.0</version>
// </dependency>

import org.apache.commons.lang3.StringUtils;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;

public class ListSorter {
    /**
     * 对List进行排序
     * @param list List对象
     * @param columns 排序字段名，以/分隔
     * @param order 排序类别，asc顺序，desc倒序
     * @return 排序后的List对象
     */
    public static List<Map<String, Object>> sortList(List<Map<String, Object>> list, String columns, String order) {
        String[] columnArray = columns.split("/");
        for (String column : columnArray) {
            if (StringUtils.isNotBlank(column)) {
                Comparator<Map<String, Object>> comparator = (o1, o2) -> {
                    Object value1 = o1.get(column);
                    Object value2 = o2.get(column);
                    if (value1 instanceof Comparable && value2 instanceof Comparable) {
                        int compareResult = ((Comparable) value1).compareTo(value2);
                        return order.equalsIgnoreCase("asc") ? compareResult : -compareResult;
                    }
                    return 0;
                };
                Collections.sort(list, comparator);
            }
        }
        return list;
    }
}

// 函数示例
// 对List进行排序示例
// 入参：list，List对象
//       columns，排序字段名，以/分隔
//       order，排序类别，asc顺序，desc倒序
// 出参：sortedList，排序后的List对象
// 调用示例：
// List<Map<String, Object>> list = new ArrayList<>();
// Map<String, Object> map1 = new HashMap<>();
// map1.put("name", "John");
// map1.put("age", 25);
// Map<String, Object> map2 = new HashMap<>();
// map2.put("name", "Alice");
// map2.put("age", 30);
// list.add(map1);
// list.add(map2);
// String columns = "name/age";
// String order = "asc";
// List<Map<String, Object>> sortedList = ListSorter.sortList(list, columns, order);
// System.out.println(sortedList);
// 输出结果：例如，按照name字段升序排序，age字段升序排序，排序后的List为：[{name=Alice, age=30}, {name=John, age=25}]
// 则输出结果为：[{name=Alice, age=30}, {name=John, age=25}]

Analyzing the cleanliness of the code, it is not difficult to find:

1. The comments of the code are very complete, and each step is explained in detail, which helps readers understand the function and implementation of the code.

2. The indentation and layout of the code are very standardized and easy to read.

3. The classes and interfaces used are all Java standard libraries, which ensures the stability and maintainability of the code.

4. The Apache Commons Lang library is used, which makes the code more efficient and concise.

5. The function of the code is very clear. It can sort a List and supports multiple sorting fields and different sorting methods.

6. Use static methods, which makes the code more flexible and reusable.

7. Lambda expressions are used, which makes the code more concise and easy to understand.

8. For incomparable objects, the code returns 0, which will not affect the sorting results and also avoids NullPointerException.

If you want to unlock more complex function requirements, follow the public account [SoFlu Software Robot] to download and use FuncGPT (Smart Function) for free.

In the era of large models, is the job of programmers still "writing programs"?

Supongo que te gusta