With Java/C/C++/Machine Learning/Algorithms and Data Structures/Front-End/Android/Python/Programmers must-read books list:
Book list navigation page (click on the right side of the Geek Man Zhan to open a personal blog): Geek Man Zhan ① [Java] The most complete 50+ books on the road to learning from introductory to advanced (collector's edition): ② [Algorithm data structure + acm] 50+ books for sorting out blood from entry to advanced (collector's edition): ③ [Database] 18 technical books that must be read from entry to advanced. ④ [Web front-end] From HTML to JS to AJAX to HTTP, from framework to full stack, help you take fewer detours (collector's edition): ⑤ [python] The most complete book has been organized (from entry to advanced) (collector's edition) :
⑥ [Machine learning] + python finishing technical book (from entry to advanced has been sorted out) (collector's edition):
⑦ [C language] Recommended books take you on the road of Daniel from entry to advanced (collector's edition):
⑧ [Android] Getting started to advanced recommended books sorting pdf book list sorting (collector's edition):⑨ [Architect] The epic must-read list on the road to vomit blood and organize 80+ books in four dimensions series (collector's edition):
⑩ [C++] Hematemesis organizes the recommended book list from entry to advanced 100+ books (collection):
Today's development work requires us to quickly master a programming language. How to quickly master a programming language? Generally speaking, there are two attitudes to deal with this kind of challenge: one is to take a rough look at the grammar, roll up your sleeves and start working, and study while checking Google; the other is to spend a lot of time learning the whole language completely, Have a good idea, and then start doing the actual work. However, both methods have drawbacks.
The problem with the second method is of course obvious, not only is it wasted time, it deviates from the goal, but also the learning efficiency is not high. Because language learning that is not driven by practical problems is usually weak and in-depth. Some people learn to become language experts, but forget that they are here to solve problems. There are also problems with the first way. If you don’t know the temperament of this language, you will piece together the code boldly, and the things you write will definitely not be in the flow. Talking about wearing new shoes and going the old way, and putting old wine in new bottles, those are all minor problems. What's really serious is that such programmers can accumulate a lot of buggy code in a short period of time.
Due to the limited degree of testing in the development stage, these junk codes can often pass through this stage, thus lurking, becoming a cancer of the entire project in the later stage, and repeatedly causing the later maintainers to fall into the Sisyphus predicament.
In fact, language learning has certain rules to follow. For developers who have mastered a language, they can master 50% of the most commonly used languages at the fastest speed within a few days to a week. And to ensure that the road is basically authentic, there is no ills. In fact, I am not afraid of not being able to write programs at all, but I am most afraid of accumulating solutions with little knowledge.
Because you don't know it at all, you will naturally go to the book to study carefully. If you have good learning ability, the quality of the code you write will not be bad. And if you don't know much about it, if you make steel by yourself, what you get out is basically scrap copper and rotten iron. For example, error handling and serialization, many people do not understand the "right way", but rely on their own half-knowledge to create wild ways, which is the most dangerous.
Therefore, even if time is tight, these contents must be fully understood first. After mastering these contents and entering into actual development, even if there is a problem, it will basically not hurt the overall project. The developer himself can be a car, and slowly improve himself in practice.
The following lists a learning outline, mainly for experienced people, not suitable for beginners. This outline can only be used for general vulgar programming language learning. Currently, the top 20 popular programming languages are basically vulgar languages. If you want to learn a non-vulgar language like LISP, or a secondary development language in a software, the advice here may not be appropriate. Again, just for reference.
1. First of all, understand the basic data types, basic syntax and main language structures of the language, the use of main mathematical operators and print functions, to the level of being able to write Tan Haoqiang's programming book after class math problems;
2. Second, master arrays and other sets The use of classes, if you have the basics, you can understand generics. If you can't understand it, it's not a big problem, you can make up later;
3. Simple string processing. The so-called simple is the content below Regex and Parser, what search and replace, truncate the string and the like. However, there is a difficulty at this stage, that is, the problem of character encoding. If you don’t understand it, you can skip it first, otherwise, it’s best to solve the problem at this time to avoid future troubles;
4. The characteristics of basic object-oriented or functional programming are nothing more than inheritance, polymorphism, Lambda functions, etc. , If you have experience, you will understand quickly;
5. Exception, error handling, assertion, logging and debugging support, support for unit testing. You don't have to use TDD, but you should master the basic skills of doing TDD in this language at this time;
6. The organization mechanism of program code and executable code, runtime module loading, symbol search mechanism, this is one of the beginner's Difficult, because most books do not pay much attention to introducing this extremely important content;
7. Basic input and output and file processing, the organization of input and output streams, this is usually a more tedious part, you can learn it in an outline, figure out the concept, and check it when you use it. At this stage, most console applications can be written;
8. How the language calls the callback method and supports the event-driven programming model. In a modern programming environment, this problem is a core issue involving development ideas. Almost every language will use sufficient effort here, such as delegate in .NET, anonymous inner class in Java, closure in Java 7, and tr1 in C++OX. ::function/bind, various. If you can fully understand this problem, not only will the program not be written too out of shape, but also you will have a better understanding of the language's design ideas. Lin Qiqi's Weibo http://t.qq.com/linqiqi259
9. If necessary, you can study regex and XML processing issues at this time, if not necessary, you can skip it;
10. Serialization and deserialization, you can master the default mechanism;
11. If necessary, you can understand Let's take a look at the thread, concurrency and asynchronous calling mechanism, mainly to understand other people's code. If you want to write this kind of code yourself, you must spend time studying it seriously and systematically, and it is strictly forbidden to go into battle with half a bucket of water;
12. Dynamic programming, reflection and meta Data programming, the mutual conversion mechanism between data and programs, and the mechanism of runtime compilation and execution, aspiring developers can put more effort in this area, which can make your understanding of the language to a higher level;
13. If If necessary, you can study the language's support for generics. You don't have to spend too much time, as long as you can use ready-made generic collections and generic functions, you can take time to learn systematically in your spare time. It should be noted that generic technology is the same as multi-threading technology. If it is not used properly, it will become the root of all evil.