This feeling is written,
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 to see more important.
3) For homework, try not to ask others immediately. If you can't solve the problem, you can complete you first, then take 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 supplied, do not provide information on your 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 procedures you do now, not to open a new 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, it should try to write a simple and easy-to-read code.
11) The program should try as much as possible, that is, the code itself understands, as if you have the same logic.
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 give debug information 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 allows you to read a full function without scrolling the screen.
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 has a dispute, it must have some shortcomings.
18) For GOTO, many engineers can be used reasonably, not to cause problems. But your program does not necessarily give you the same level, you can't 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 interface to each module. In this way, if the data content has major modifications, only the interface is not changed, it can guarantee that the program should not be complicated.
21) The concurrency control of the data should be taken into account.
22) The concurrent control of the data should be encapsulated instead of exposure to other modules, which can reduce the procedure of the program caused by concurrent causes.
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 a standard ODBC or ADO interface, try not to process according to the interface provided by the actual database DBMS 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, you should try it immediately after using the file immediately after use, so other programs may use the file.
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.
Just write this, huh, it should be more messy, not complete, I hope everyone should not laugh.
