Ten Characteristics of Star software engineers

Today, every company seems to be a technology company. From software startups to speculative investment companies, pharmaceutical giants and media giants, they are increasingly involved in the software business.
Code quality is not only a necessity, but also a competitive advantage. Because many companies compete for software, software engineers, who develop software, are becoming more and more important. But how do you find the programmer with the greatest choice? In this article, we briefly list the 10 characteristics of star developers.

　　1. Love Programming
Programming is a kind of effort (programming is a labor of love) to satisfy your interests ). Like any other profession, only real enthusiasm can accomplish truly great things. There is a misunderstanding that writing code is mechanical and scientific. In fact, the best software engineers are craftsmen who can integrate energy, originality, and creativity into every line of code. Great engineers know when to make code perfect and when to assemble large systems like puzzles. Programmers who love programming get satisfaction from building software, just as a composer is ecstatic after completing a symphony. It is just a sense of attention and achievement that has created a star engineer who loves programming.
　　2. Complete the task
There are many technical staff who only talk about software without writing code (Just Say No type ). Great software engineers are actually coding, which is also one of their most important qualities. They are people who actually do things. Smart people know that the best way to solve the problem is to face the problem, rather than spending weeks designing complex and unnecessary architectures and libraries. A good engineer should ask: What is the simplest way to solve the problem at hand? The latest software development method, agile practices, focuses on that. The idea is to split a complex project into short iterations. Each iteration only focuses on a small part of the incremental functions. Because the encoding for each iteration takes only a few weeks, the function is easy to manage and simple.
　　3. Continuous code refactoring
The encoding is similar to carving. To constantly improve your work like an artist, software engineers must continuously improve their code in the best possible way to achieve their goals. The principle of re-shaping code is called "refactoring". Martin Fowler has a corresponding description in his creative book. The original idea behind refactoring is to improve the code without changing its functions, move and adjust some code to ensure that the system is not corrupt, and ensure that the system is completed based on the current requirements. Continuous refactoring allows developers to solve another famous problem-"Black Box legacy code" (this problem is almost unattended ).
The software development culture that has been around for decades requires us not to change what is working normally. However, over time, the problem was that we became slaves to old code, and old Code became unstable and incompatible. Refactoring can change this situation because we are the master of the code, not its slaves. Refactoring builds continuous "Conversations" between engineers and code, and brings ownership, certainty, self-confidence, and system stability.
Never be a slave to old code. If the code is written by others, you may be able to shirk responsibility easily. But most of the time, the Code is written by myself, and should be worthy of it. When the old code is to be buried, it will be buried!
　　4. Use the design mode
Software engineers around the world have been discussing patterns since the so-called "Gang of Four" (Erich Gamma, Richard Helm, Ralph Johnson, and John vlissides) published their book design patterns. In our world, patterns are everywhere, whether in nature or in human behavior. Software Engineering is no exception. The mode is a recurring cross-language, cross-System Scenario and mechanism. A good engineer can often identify and exploit patterns, rather than being constrained by patterns. Engineers should not (forcibly) adapt the system to a certain pattern, but discover the time to use the pattern in the system (the proper pattern ). When using models to ensure correctness, we should learn from the wisdom of our predecessors and use methods that previously could properly solve specific engineering problems. However, remember that the mode is not a panacea; do not use the design mode to use the design mode.
　　5. Write a test
For some time, software engineers thought the test was not worth doing. However, if you do not perform a test, how can you ensure that the code works properly? In agile practices, unit testing has been widely recognized because it focuses on writing tests to reflect code effectiveness. As the system increases, testing also increases. Experienced engineers know and understand the value of the test, because the purpose of the test is to create a system that can work normally. Good engineers usually make sure that a bug never occurs again. However, good engineers know that they should not waste time writing trivial or redundant tests, but should focus on the core components of each component.
　　6. Make full use of existing code
Re-inventing the wheel has always been one of the major problems in the software industry. From developing a new language to writing a function library, ignoring and rewriting the strange driving forces that already exist and can work has caused a lot of software development failures. A star engineer will focus on three basic types of reuse: first, the reuse of internal infrastructure, corresponding code written by himself or colleagues; second, using third-party function libraries, such as JDK. finally, we will study the use of services provided by some large network service providers, such as Amazon. in short, correct use of existing code enables software engineers to focus on the most important thing-the application itself.
　　7. Focus on Availability
Excellent engineers usually focus on users. Whether the user is an enterprise or an individual, whether it is a consumer-type software company or an investment bank, you need to pay attention to availability. How do users interact with the system? Does the system provide a simple, direct, and stable operation experience? This is a serious mistake because a software engineer is a technician and he/she is not associated with "how the user interacts with the system. Why do excellent engineers work hard? It is not just to make the system simple and easy to use. They will always think of users and will not try to invent things that are confusing and can only be understood and appreciated by geeks.
Sometimes, some software engineers are too invested. Instead, they forget that the programs/software they write are for others' use, not for their own purposes ". Therefore, in the software development process, "users" should always be put in mind.
　　8. Write maintenance code
Another secret in the software development field is that it takes the same amount of time to write good code and bad code. A well-trained engineer will consider maintainability and code evolution from the first line of code. There is no reason to write "ugly" code, several page-long functions, or odd variable names. Writing code by excellent engineers follows naming conventions, and the code is compact, simple, and out-of-the-box. Each line of the Code should properly display its original purpose. Do not forget the naming rules when reasonably commenting on inconvenient code (blocks. Clear function names and variable names allow the code to be unambiguous.
When coding, some programmers will have this mentality: They will modify or improve some code or certain statements later. But who knows that this "one day", "one week", "one month", or "one year" will not even have a chance to modify it later. Therefore, try not to compromise on writing code that is currently usable. Otherwise, it will not only save development time, but also impede the entire process. Of course, it is not conducive to the follow-up maintenance personnel.
　　9. Programming in any language
Good software engineers have their own favorite programming language, but they are never fascinated by it. There are already many excellent programming languages. That is to say, if you only use one of them, it means you lack diversity. You can use Java, C #, or C ++ to write any modern software. You can use PHP, Perl, or Ruby to write the background of any website. In short, the language used for programming is far less important than the corresponding function library. Excellent engineers can recognize this and are willing to learn new languages, new function libraries, and new methods for building systems.
　　10. Be familiar with basic computer science knowledge
Finally, it is definitely not the least important feature of a good engineer: a solid foundation. A good engineer may not have a degree in computer science, but he/she must know the basics-data structures and algorithms. If you do not know the hash table or the differences between the linked list and the array, how do you build a large software ?. This is what every developer who is engaged in software development should know. Algorithms are equally important. From binary searches to sorting, to graph traversal, a star engineer must understand and digest these basic things internally. Because these foundations are essential for your decision-making in building any modern software.
　　Conclusion
The above is a distinction between the many characteristics of great software engineers. The "enthusiasm" discussed is very important. Code reuse, design patterns, basic data structures, and algorithms are all required, while refactoring and unit testing in Agile practices help engineers deal with complex software. In particular, star Engineers believe in conciseness and common sense. It is precisely these beliefs that help them successfully build the seemingly impossible and complex systems that the world needs today.