1) Learning should start from the basis, do not try the highest and deep technologies at first.
2) Every time I see a book, don't say this chapter I have learned before, and I have a very good, so I can skip this chapter.
More important.
3) For homework, try not to ask others immediately. If you can't solve the problem, you can first
Complete you will, then refine some special difficulties, ask your master.
3) Don't expect books and hipsters to help you solve all problems, because you don't have all questions to teach you.
4) Ask others, you should understand the problem. For error prompt information, it should be provided, don't press
Information on understanding. Because since you can't do it yourself, you understand that you understand problems.
5) Ask questions, it is best to bring code.
6) Don't say "Compilation, but run ...", because compiling errors and run errors may have no relationships.
In general, compilation is grammar issues, while running is a logic problem.
7) The book is not as good as the program, and should try to write the program as much as possible.
8) Do a thousand programs that are worse than doing the program. Should try to perfect the procedure you do now, not to open a new plan
Plan, and each plan is tiger head snake.
9) To think of you are not a man writing, but write a program with everyone.
10) Although a deep skill showed a deep skill, it is often harmful to cooperation.
Single easy-to-read code.
11) The program should try as much as possible, that is, the code itself reads, it seems that he is a logic
same.
12) Complex code If you don't do your own comment, you should give an appropriate amount of annotations.
13) Note Should be modified accordingly when modifying the code, and cannot mislead others with old comments.
14) The code should try to be reused. The same function should be done by the same function, and the important function should be toned.
Try information in order to debug the problem early.
15) You should try to write a small function, and each function should not exceed 40 rows or less. This is not necessary to scroll the screen.
You can read a full function.
16) For Switch statements, try not to have too much branch, if the branch is too much, you can consider using a jump table.
17) Try to use some controversial statements, such as GOTO and three-mean operators, since it is controversial, it must have certain
Shortcomings.
18) For GOTO, many engineers can be used reasonably, not to cause problems. But your program
It does not necessarily give you the same level, and they can not guarantee reasonable read and modify these related code.
19) When the code is written, there should be a certain format, and the basic requirement is to help understand the code.
20) If the data is common, a package should be provided to manage it, and provide a suitable
The interface gives each module. In this way, if the data content has major modifications, only the interface is constant, it can basically guarantee
The program is not a complicated modification.
21) The concurrency control of the data should be taken into account.
22) The concurrent control of the data should be packaged instead of exposure to other modules, which can reduce
Procedure caused by the cause of the cause.
23) The structure of the data cannot be too complicated. It should be divided into two groups of data as much as possible.
24) The database should be considered for the case where the amount of data is relatively large.
25) The database interface should use standard ODBC or ADO interface, try not to receive according to the actual database DBMS
Halves handle because you may replace DBMS in actual use. 26) Small data can consider files, file paths should have to be designed to be relative paths.
27) In a function, try to turn it out immediately after using the file, so other programs may use the text.
Part.
28) Don't try to read all the files all over the memory, you should handle the big file.
29) Write programs should provide relevant test procedures to provide test methods.
30) Should consider the code, the usage of functions, do not exceed the range of functions that can be used.
-------------------------------------------------- ------------------------------
1. Sound foundation. Data structure, discrete mathematics, compilation principle, these are the foundation of all computer science,
If you don't master them, it is difficult to write high levels. According to my observation, learning computer professional people are more than learning other specialists
People can more written high quality software. The program will write, but it is difficult to improve when you find a certain level.
At the time, you should think about whether it is to go back to learn these most basic theories. Don't go to learn OOP at first,
Even if you are also proficient in OOP, you may have no hand when you encounter some basic algorithms.
2. Rich imagination. Don't stick to fixed thinking, don't think more about problems when you encounter problems.
The plan of the question, try the way others never thought. Rich imagination is based on rich knowledge, except
Outside the computer, more about other disciplines, such as astronomy, physics, mathematics, and more. In addition, more science fiction movies are also
It is a good way.
3. The simplest is the best. This may be a criterion following all science, so complex quality interchange
The principle is just a simple formula that cannot be simple in Einstein: E = MC2. Simple method is easier to be
People understand, easier to implement, and more easily maintained. When you encounter problems, you must give priority to the easiest solution, only simple
The program cannot meet the requirements of the complex solution.
4. Do not drill the horn. When you encounter obstacles, you may wish to stay away from the computer, look at the scenery outside the window, listen
Light music, chat with friends. When I encounter a problem, I will play games, and it is the kind of violent fighting.
Game, when the part of the brain cells responsible for the game, the part of the brain cells responsible for programming
It is a full rest. When I started working, I will find that the problem is now able to solve it.
5. The desire for the answer. The development history of human natural science is a process of eager to get the answer, even
A small part of the answer is also worth we pay. As long as you firmly believe, you must find the answer to the question, you
I will pay for an effort that even if I don't get an answer, you will learn a lot during the process.
6. More than others. Three people must have my teacher, maybe it can be built in a conversation with others.
Illustrated sparks. Many up-to-go, see what others' views on the same issue will give you a lot of inspiration.
7. Good programming style. Pay attention to develop a good habit, the indential arrangement of the code, the naming rule of the variable begins
Finally consistent. Everyone knows how to exclude the error in the code, but often ignore the missed troubleshooting. Comment is
An important part of the order, it can make your code easier to understand, and if the code is clearly expressed
Your thoughts, you don't have to add any comments. If the comments and the code are inconsistent, it is even worse.
8. Toughness and perseverance. This may be the "master" and general programmers the biggest difference. A good programing
IS 99 weat and 1 ffee. Masters are not genius, they are hone in countless daysday night. Success can bring us extremely joy, but the process is incomparably boring. You may wish to do a test, find a 1
The number of prime tables within 0000, copy them all, then check three times, if you can complete this
Work, you can meet this.
#
Reply: Doing programmers, tired?
2004-08-09 3:00 PM
John
* Amaze of knowledge, and you can add your own knowledge and improve your knowledge structure.
* Patience, especially in debugging and learning, there is no smart person in the world. Be developed
Learning and incorporating two things, the development process in these two things is actually relatively simple.
* Always remember: The code is giving people instead of running the machine, the computer is not afraid of being tired when executing the program.
And people are very tired when watching the code.
* Good coding habits, at least guarantees yourself to read the code you wrote before you can read more time
* Try to make your code can be easily understood by others, think about it when you write the code, you will not be held by others after two months.
curse
* Do not tolerate your own repetitive errors and write duplicate code
* Know how to do more important than getting code
* Try not to do something that has already been done
* Learn to respect the achievements of others, unless you have to decide to fully replace the previous system
* Cherish your time and work results, try to make others share your development results
* Avoid assumptions, think more about the possibility of extreme conditions and cause errors, and strive to reduce low-level errors
* Don't believe that at least don't believe in the test results you do for yourself.
* Know your own development ideas and know how to understand and absorb others' thoughts
* Learn to be consistent with others, but you can't give up your development characteristics
* Know the people around you, whether it is developing skills or development experience
* Understand the importance of software structure, analyze the structure of code before analyzing the code
* Summary, regularly summarize the knowledge they have learned, see what you have wasted for a variety of reasons
between
* Society plan, try not to think of the task by extending their work hours
* Learn to properly estimate your ability and working hours
Here, this is what I think some is suitable for my own, not necessarily for everyone:
* Take more magazines, you can see the reference book you have seen before, you are likely to have you before.
Some details
* Don't be too early to do something unrelated to the development, because the golden period of learning is very short
* Learn to analyze the system of others, see the advanced side of the system developed by others. Here, someone else
Thinking, the structure used in realization
* I often feel that I will be eliminated, I often complain myself.
* Know what you lack
* Forced things you don't like to do, such as writing documents
* Come and have the courage to rewrite the system you develop, but when you react, you should take and see the previous work side.
Writing and methods, otherwise it is not necessary
* Simplify the problem rather than complication
* Some issues that will be generated during maintenance is transferred to development or when designing
* Sometimes you may wish to ask yourself: What do I do when I don't do it?
* Adhere to your weekly development plan, don't easily transfer your attention before things
* As much as possible to teach you to others, because you may no longer be responsible for this system one day.
* Doing things must have end, unless there is no reason to leave, do not leave before work
* Don't take the things you do for the company, you should take away the development experience and the understanding of development rather than code
Product
* Take a break at all, give yourself a false, after all, people are not machine
