10 qualities of a star software engineer

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 software business.

The quality of code has become a necessity and a competitive advantage. Because many companies compete around software, software engineers are becoming more and more important. But how do you find that cream programmer? As a star developer, you need to have the following 10 traits.

1. Love Programming

2. Get things Done

3. Continuous refactoring of code

4. Use design mode

5. Writing Tests

6. Use existing code

7. Focus on Usability

8. Writing maintainable Code

9. Can be programmed in any language

10. Knowledge of basic computer science

1. Love Programming

Programming is a labor that is willingly done to satisfy interest (programming is a labor of love). Like any other profession, it is only true passion that can accomplish truly great things. There is a misconception that writing code is mechanized and purely scientific. In fact, the best software engineers are craftsmen who can incorporate energy, ingenuity and creativity into each line of code. Great engineers know when to carve out the code to perfection and know when to assemble large systems like puzzles. Programmers who love programming get content from building software, just as a composer is ecstatic after completing a symphony. It was the excitement and the sense of accomplishment that created the star engineer who liked programming.

2. Get things Done

There are a lot of technicians who talk about software without writing code (deeds type). And great software engineers are really coding, and that's one of their most important qualities. They are the ones who actually do things. Smart people know that the best way to solve problems is to confront problems rather than spend 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 approach to software development-agile practice-is focused on that. The idea is to break down complex projects into short iterations, with each iteration focusing on only a small percentage of incremental functions. Because the encoding for each iteration takes only a few weeks, the functionality is easy to manage and simple.

3. Continuous refactoring of code

The code is much like carving. As artists continue to refine their work, software engineers will continue to refine their code in the best possible way to achieve their goals. The principle of reshaping the code is called Refactoring, and the original idea behind the refactoring is to improve the code without changing its functionality, to move the part of the code to ensure that the system is not rotten, and to make sure that the system is done based on the current requirements. Continuous refactoring allows developers to address another well-known issue-"Black Box Legacy Code" (a problem that no one wants to touch).

Decades of software development culture requires that we should not change the normal work of things. 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 owner of the code, not its slaves. Refactoring creates a continuous "dialogue" between engineers and code, and brings ownership, certainty, confidence, and stability to the system.

Never be a slave to old code. If the code is written by someone else, you may be able to evade responsibility easily. But most of the time, those codes are written by themselves, to be picked up and put down, when the old code is buried, bury it!

4. Use 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. Patterns are everywhere in our world, both in nature and in human behavior. Software engineering is naturally no exception. Patterns are the recurring scenarios and mechanisms of cross-language cross-system. A good engineer can often identify and exploit patterns, rather than being subject to patterns. Engineers should not (force) allow the system to adapt to a pattern and find the time to use the pattern in the system (proper usage mode). When using the model to ensure correctness, we should use the wisdom crystallization of predecessors, using the method that can properly solve the specific engineering problems in the past. But remember: patterns are not a panacea; do not use design patterns in order to use design patterns.

5. Writing Tests

There was a time when software engineers thought the tests were not worth doing. However, if you do not test, how can you ensure that the code will work properly? "Unit Testing" in agile practice has gained general recognition because it focuses on writing tests to reflect the effectiveness of the code. As the system grows, the test increases. Experienced engineers know and understand the value of testing because the purpose of testing is to create a functioning system. A good engineer will usually make sure that a bug that has occurred once does not appear a second time. But good engineers also know that you shouldn't waste time writing trivial or redundant tests, but focus on testing the core parts of each component.

6. Use existing code

"Reinventing the Wheel" has been one of the big problems in the software industry. From inventing a new language to writing a function library, ignoring and rewriting the strange drivers that already exist and working, has resulted in a lot of failure cases for software development. A star engineer will focus on three basic types of reuse: first, the reuse of internal infrastructure, the corresponding code is written by himself or his colleagues, and second, using third-party libraries, such as the JDK. Finally, consider the use of services provided by some large network service providers, such as Amazon. In short, the right use of the existing code, so that software engineers can really focus on the most important thing-the application itself.

7. Focus on Usability

Good engineers are usually focused on the user. Whether the user is a business or an individual, whether for a consumer-based software company or investment bank, the need to focus on usability. How do users interact with the system? Does the system provide a simple, straightforward, and smooth operating experience? There is a saying, because a software engineer is a technician, he/she and "how the user interacts with the system" is not associated, this statement is seriously wrong. What does a good engineer work hard for? Not just make the system simple and easy to use. They think of users all the while and don't try to invent things that are puzzling, that only geeks can understand and appreciate.

Sometimes, some software engineers are too involved, but forget the program/software written for others to use, not to do their own "artwork." Therefore, in the software development process, has been to put the "user" in the heart.

8. Writing maintainable Code

Another small secret of the software development community is that it takes as much time to write good code and bad code. A trained engineer who will consider maintainability and code evolution starting with the first line of code. There's no reason to write "ugly" code, pages-long functions, or weird variable names. Good engineers write code that follows a naming convention, and code writing is compact, simple, and not overly ostentatious. Each line of code should be properly displayed for its original purpose. Don't forget to name the rules when you make reasonable comments about the code (blocks) that are inconvenient to understand. Clearly defined function names and variable names can make the code clear.

Some programmers have this mindset when coding: to modify or refine a piece of code or a statement in a few moments. But who knows this "after a while" unexpectedly is "one day", "a Week", "one months" or "one year", even later did not have the opportunity to change back. So try not to compromise and write temporary code. Otherwise, it will not only save development time, but can also hinder the entire process. Of course, it is not conducive to the work of subsequent maintenance personnel.

9. Can be programmed in any language

A good software engineer may have a particularly favorite programming language, but will never be obsessed with it. There are a lot of good programming languages now, that is, if you only use one of these languages, it means that you lack diversity. You can write any modern software in Java, C #, or C + +, and you can write the background of any web site in PHP, Perl, or Ruby. In short, the language used in programming is far less important than the corresponding library of languages. Good engineers recognize this and are willing to learn new languages, new libraries, and new ways to build systems.

10. Know basic knowledge of computer science

Finally, but certainly not the least important trait of a good engineer is: 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 do not know the difference between the list and the array, how do you build a large software? These are what every developer in software development should know. Algorithms are equally important, ranging from binary lookups to various sorts, to graphics traversal, a star engineer must know and digest these basic things internally. Because these basics are essential to your choice in building any modern software.

As a Star software engineer is not accidental, this so-called opportunity is for the preparation of programmers, want to become a good programmer, want to become a star programmer, you can start from now, from writing high-quality code, more secure applications to start

10 qualities of a star software engineer