A good engineer should learn to improve himself at work

introduction

The ancients said: "Living to be old, learning to be old." The Internet is one of the most difficult industries. High salary means that "working overtime" is "commonplace" for engineers. At the same time, Internet technology is changing with each passing day, and many engineers are tired. To cope with it, cry out. As a result, there has been a widespread misunderstanding for a long time: 35 years old is the end of a programmer's career.

How to accumulate technology and build personal core competitiveness in busy work is a question that many engineers are thinking about. This article is a summary of my own, trying to answer from three aspects:

• 1. The principle of learning

• 2. Growth will inevitably be accompanied by confusion

• 3. Becoming an excellent architect is the phased goal of most junior and intermediate engineers.

Note: The original text comes from the Meituan technical team "How do engineers improve themselves at work?" Now I am refactoring this article based on my 8 years of Android development experience. I hope to provide you with reference and reference.

1. How to learn

In busy work, perseverance, continuous learning and progress is a difficult thing, requiring strong perseverance and firm determination. If the method is improper, it will get twice the result with half the effort. Fortunately, our ancients and current philosophers have summarized a lot of excellent learning methodologies. Here are some important principles. Following these methods will be of great benefit to everyone's work and study.

1. Perseverance

It is reported that the amount of knowledge in the past few decades has exceeded the total amount of knowledge in the previous thousands of years. The computer field is definitely one of the fastest updated fields of contemporary knowledge. Therefore, engineers must accept the reality that the profound knowledge system they now master will soon be eliminated. If you want to continue to be an excellent architect in the computer field, you must keep learning and master the latest technology. In short, it is impossible to learn.

The so-called "frozen three feet is not a day's cold, water droplets and rocks, not a day's work", the road to the architect is long and arduous. If you give up easily, all your efforts will be in vain. If you want to be an excellent architect, you have to persevere!

Although knowledge is updated quickly, the basic theory changes very slowly. This is the relationship between "Dao" and "Xiang". Even though there are all phenomena in the world, Tao is invariably changeable. For those very basic theoretical knowledge, we need to review it frequently, that is, "learning and learning from time to time".

2. Pay attention to practice

The ancients said: "It is always shallow on paper, and you must do it yourself." There is the so-called 721 model in the field of learning: 70% of personal growth comes from job practice, 20% comes from learning from others, and 10% comes from training. Although this theory is controversial, it is generally good for engineers to rank the importance according to the way of practice, learning and training. Therefore, attach importance to practice and grow in practice is the most important learning principle.

Taking learning to drive a car as an example, it is hard to imagine anyone who can learn to drive a car only through book knowledge or watching instructional videos.

Paying attention to practice, making full use of perceptual cognitive potential, and tempering yourself in projects is the correct way to learn. In practice, deliberate practice on certain key movements will also achieve twice the result with half the effort.

3. Attach importance to communication

Newton said: "If I see farther than others, it is because I stand on the shoulders of giants." We need to learn from others. Learning from teachers, leaders, colleagues, subordinates and even opponents is an important means of rapid growth.

Learning from teachers and leaders is already part of people's daily habits. But learning from colleagues and even opponents is also important, because these people are more similar to ourselves. So observe more, take the best and discard the shortcomings. For the little brothers and subordinates of the team, we must also "not ashamed to ask."

4. Summary and output

Engineers will master a lot of details in practice, but even if they master all the details, but do not have a deep summary and thinking, they will fall into the situation of "learning without thinking, then failing". The "quantitative change" of growth comes from the gradual and in-depth control of details, while the real "qualitative change" comes from a deeper understanding of "Tao".

Exporting experience and accepting others' tests is a high-level summary. This kind of output not only helps others, but also benefits oneself. There are many ways to summarize, including organizing sharing, writing technical articles, and so on. Of course, "three times in Japan" is also a good way to summarize. In short, sum up a lot, share a lot, and be great!

Answering other people's questions is also an important means of personal growth. Sometimes, I don't understand a certain problem, but when I explain it to others, it suddenly becomes clear. Therefore, "teaching people tirelessly" benefits others and benefits oneself.

Second, the inevitable confusion of growth

Life is a marathon, and there will inevitably be a lot of confusion during the long journey. Confusion is like a shackle, which makes us falter, and confusion is like a deadlock, which makes us stand still.

Next, I will summarize some typical confusions I encountered and saw in my work. These confusions have troubled the author for a long time, or troubled colleagues and friends around me. When these confusions are relieved, everyone feels like being released again, providing full positive energy for the next stage of the journey.

Life is like a journey. You don't need to care about the destination. What you care about should be the scenery along the way and the mood of seeing the scenery. A good attitude is the best companion for a technical journey. I hope that through this puzzle-solving journey, everyone will have a happy mood to experience the long learning journey.

1. Is learning endless?

A cruel reality must be admitted: human life is limited, but knowledge is unlimited. It is an impossible task to learn infinite knowledge with a limited life. Thinking of this, some engineers can't help but feel pessimistic. If the method is right and diligent enough, sadness is unnecessary.

Although, the overall human knowledge system has been expanding. But for many important engineering subdivisions, the basic theory is not advanced. In many important fields of computer, engineers have the ability to grasp the core key points in a limited time.

Technical learning is a competition. Although learning is endless, surpassing most opponents is a victory. Therefore, with the correct learning method, long-term investment will form the core competitiveness.

2. There is no absolutely brilliant technology, only real masters

Engineers who are committed to achieving technological achievements dream of becoming technical masters one day. But the standards of technical masters are very controversial. This is a misunderstanding with a long history: the mastery of a certain technology is used as the criterion for judging technical masters. I often encounter situations like this: Some engineers call themselves masters because they have mastered certain technologies, such as a certain level of performance tuning, or mastered a lot of third-party libraries.

There are several reasons for this misunderstanding:
First of all, if you have too many skills, the more you master, the better. People who master many skills are naturally not novices. But it is not necessarily a master.
Secondly, before the advent of the Internet era, information acquisition was very expensive. This leads to the mastery of a skill that can give individuals or even the entire company an advantageous position. In the Internet age, the emergence of various frameworks and the popularity of open source have rapidly eliminated or reduced the value of many skills, and at the same time lowered the learning threshold for many technologies. Therefore, at present, mastering a certain skill knowledge can only be a short-term goal. People who are complacent with certain skills need to remember: Pride makes people regress.

3. Can you grow without doing projects?

Learning in projects is one of the fastest ways to grow , and many engineers enjoy this process very much. But if you work on projects throughout the year, you may be in an outsourcing company. For a product company, if it is doing projects from the beginning to the end of the year, or it is in the initial entrepreneurial stage, or it has done a large number of failed projects, in short, it is not a particularly ideal state. Normally, there will be some non-project time between projects. During this time, some students will be confused and grow slowly.

Is the more projects the better? The answer is obviously no. Repeated projects will not bring new growth to engineers. Constantly working on projects, and thus lack of time to learn new knowledge, will lead to "doing but not learning is dying". What really makes an engineer outstanding is the depth of the project, not the constant work on the project . Therefore, in the gap between projects, engineers should cherish the rare opportunity to breathe, think deeply, deepen and refine the project.

How to improve the depth of the project? Generally speaking, any project has a goal, and when the project is completed, the goal is basically achieved. But are the customers really satisfied? Has the system's availability, reliability, scalability, and maintainability been achieved to its extreme? The answer to these questions is always negative. Therefore, any valuable project can be digging deep. Digging deep into the project and thinking deeply can also exercise the creativity of the engineer. A person who expects to continue working on projects is like a person who is dedicated to training more Maxima, who cannot invent a car. Exercising creativity is not something that can be done overnight, it takes a long time to think. In short, engineers should always feel that time is not enough, after all, time is the most precious resource.

4. Are the responsibilities really small?

In many cases, the number of systems and team size that an engineer is responsible for is positively related to its "state of the world". However, the status of the arena is not necessarily related to technological growth. The key to improving technical capabilities is the depth of the project and the degree of pickiness of the customer. The more projects, the less time invested in a single project, and it is easy to fall into superficiality. What needs to be avoided in particular is the situation of "being in their position and not seeking their own politics". The larger the team, the more energy needs to be invested in management. Forcibly being responsible for a large team on the premise that management skills are immature and technical vision is not high enough may cause the individual to be overwhelmed and the team to achieve nothing. In the end, "one general is incompetent, and the three armies are exhausted." The effect may be counterproductive.

From the perspective of technology development, technology managers should pay attention to the number of active projects that they can control, and work to improve the influence and technical depth of active projects. The number of team members should be compatible with individual management ability, planning ability and demand control ability. A job is done by multiple people, and everyone's growth is limited. Everyone does simple and repetitive work, which is not good for technological growth. Team management and project management need to be done step by step, and avoid “fighting and facilitating growth”.

5. Are engineers inherently bad at communication?

In actual work, the problems caused by communication are endless. Many engineers are relatively introverted and are always labeled as "bad communication." In fact, communication skills are one of the most important abilities of engineers. Good communication is the basis for efficient work and learning, and it can also be mastered through learning.

• Learn to ask the right questions

It is normal to encounter problems in the usual development work or study, but when you encounter problems, do not ask other people casually or immediately, and learn to solve the problem independently. First use the search engine to search, most of the problems can actually be found on the search engine, so as not to waste everyone's time. In addition, the problem represents an opportunity to break through yourself. Give yourself a certain amount of time to work hard to solve it, every time Fear is a step backward, and every breakthrough is an accumulation. In the case of trying to solve the problem but to no avail, consider seeking help from others, but the way of asking questions must be particular, because incorrect questions waste time for you and the helper, and cannot solve existing problems efficiently. . You can often see some questions like this in the community or technical group:

Have you (someone) used xxx?
What should I do if the xxxx operation throws a problem?
xxx Do xxx operation, why can't it work? Does anyone know?
At this time, [Black Face+Hello Sign.jpg].

Here you can read the book "The Art of Questioning", which is a book that teaches you how to improve communication efficiency and increase your own influence through skillful questioning.

Some open source projects on Github will have an Issue Template. The main purpose is to allow the questioner to describe the problem more carefully, so that the maintainer can more easily understand and provide help.

6. Is efficiency important?

I often see that some students give their performance scores of 100 points-full marks, because the past period of time is too hard, but the final performance is mediocre. Heaven rewards hard work, but Heaven rewards cleverness. Engineers have all learned data structure, and the time complexity gap of different algorithms can hardly be compensated by longer working hours. In order to improve the efficiency of work and study, we need to pay attention to the following points:

• Mainly focus on efficiency improvement. In many cases, compared with the benefits brought by the efficiency improvement, the results of the extended time are often not worth mentioning.

• There must be clear results-oriented thinking. Credit and hard work are not the same thing.

• Do the right thing, not just do it right. This is a topic that is constantly being brought up, but mistakes happen every day. In order to complete a large project within the specified time, there are always trade-offs. If you don't have a focus, you can get half the effort with even effort. It is even more tragic and sorrowful if "the South goes by the other side".

3. Architect ability model

We have already talked about the principles and some confusions, so how should engineers improve themselves?

Becoming an excellent architect is the phased goal of most junior and intermediate engineers. Excellent architects often have five core abilities: programming ability, performance optimization ability, architecture ability, project management ability and planning ability.

The relationship between these abilities is roughly as shown in the figure below. Programming ability is the most basic ability. Even business programming skills cannot be mastered, and it is difficult to achieve performance optimization capabilities and business architecture capabilities. Only after possessing certain performance optimization capabilities and business architecture capabilities can they perform well in terms of project management capabilities. Team management ability is the highest ability, and it is more dependent on project management ability.

to sum up

Architect is the ultimate dream of programmers. Why can't many programmers be architects?
1. A good and healthy career plan is very important, but most people ignore it.
2. Learning habits are very important. Perseverance is the right answer.
3. Programming thinking has not been able to elevate to a higher level. It is limited to coding and business, and has not considered the selection and expansion.
4. There is no good architect to guide and train around. The circle you are in has a huge impact on the growth of programmers.

This is the end of the article, and I hope it will be helpful to the engineers' work and study. What needs to be stated is that the content of the article is all over the place, and the so-called architect ability model is also the author's personal opinion. Everyone is welcome to share their experience in learning and growth in the comments. If you feel that you have gained a little bit, I hope you can get your attention, likes and favorites.

---

Finally, I have compiled a skill tree of Android architects. It is a bit long and can be collected by friends in need. Don't read it if you are not interested.
The picture and text of the following technical knowledge point system. The video learning resources are explained in detail on my GitHub .

Essential Java foundation

Generic

• Act on definition
• Wildcards in nesting
• Generics in Rxjava

annotation

• Custom annotations and meta annotations
• APT, compile-time annotation processor
• Instrumentation
• Reflection, dynamically obtain annotation information at runtime
• Retrofit

Concurrent threads

• Thread sharing and implementation
• CAS principle
• Android AsyncTask principle

Java Virtual Machine

• Dalvik virtual machine
• CG algorithm and mechanism
• Memory allocation strategy

Hook technology, dynamic programming,
dynamic proxy mode,
parent delegation mechanism,
JavaIO system,
IO operation, Dex encryption

Data structure and algorithm

data structure

• Stack and queue
• Array and linked list, customize a dynamic array
• Hash table, and the resolution of Hash conflicts
• Binary tree
• B+ B-tree
• Basic sorting algorithm: focus on fast sorting, merge sorting, heap sorting (big root heap, small root heap)
• Optimization of fast queue
• Binary search and variant binary search
• Huffman tree, red-black tree
• String operation, string search, KMP algorithm
• Graph BFS, DFS, prim, Dijkstra algorithm (high-level skills)
• Classic problem: the processing of massive data (to find the largest 10,000 number TOP K problem among 1 billion numbers)

algorithm

• Divide and conquer algorithm
• Dynamic programming
• how are you
• Branch and bound

Android basics

• Android Activity life cycle
• Application life cycle
• Android Service, IntentService, Service and communication between components
• Activity's onNewIntent
• Fragment lazy loading implementation, parameter transfer and storage
• Detailed ContentProvider instance
• BroadcastReceiver use summary
• Android message mechanism
• Binder mechanism, shared memory implementation principle
• Android event distribution mechanism
• The realization of Android multithreading: Thread, HandlerThread, AsyncTask, IntentService, RxJava
• How ActivityThread works
• Implementation principle of nested sliding
• RecyclerView and ListView (caching principle, difference connection, advantages and disadvantages)
• View drawing principle, custom View, custom ViewGroup
• View、SurfaceView 与 TextureView
• Why the main thread Looper.loop does not cause an infinite loop
• ViewPager's cache implementation
• The difference and connection of requestLayout, invalidate, postInvalidate
• New features of AndroidP
• Android two virtual machines
• ADB commonly used commands
• The difference between the Asset directory and the res directory
• Getting started with Android SQLite

Android development advanced

Android technical difficulties

Draw process AIDL, Binder, multi-process, View, and event distribution, message queues, and so on .

This kind of knowledge must be mastered for those who position themselves as a senior Android engineer. At the same time, he is also a touchstone for distinguishing senior and junior engineers. Among them, binder is one of the most important means of inter-process communication in the Android system. At this stage, The development of an app is inseparable from the use of multiple processes. Processes such as positioning and push are often started in the background to ensure the memory operation of the main process; therefore, it is necessary to use multiple processes reasonably; the drawing of views is The theoretical basis of our custom control, the custom control can only be personalized by mastering how the view is drawn; event distribution has always been one of the difficulties in Android development, and it must be mastered; the handler mechanism is also a difficulty in Android, because The underlying layers including Asynctask, system startup, and Intentservice are all implemented through handlers, so mastering the handler mechanism can not only improve your actual development capabilities, but also allow your system to understand the operation of the entire android system.

Android framework layer source code control

• Android package management mechanism, core PackageManagerService
• Window management, core WindowManagerService
• Android Activity startup and management, core ActivityManagerService
• Root Activity workflow
• Context association class
• Various principles, classic third-party library source code series
• Custom LayoutManager, how to customize LayoutManager in RecyclerView
• VLayout implementation principle, that is, how to customize LayoutManager
• Glide loading principle, caching scheme, LRU algorithm
• The realization and principle of Retrofit
• Use of OKHttp3, Intercept in network requests
• EventBus implementation principle
• The realization principle of ButterKnife
• RxJava implementation principle
• Dagger dependency injection
• Hot repair realization principle, solution
• Componentization principles and solutions

Android process communication and multi-process development

Android multi-process and Application relationship

Classic solution: Multi-process communication solution: Andromeda

• Android animation mechanism
• Android drawing principle
• Android page recovery

Android page recovery uses the following two methods:

• onSaveInstanceState(Bundle outState)
• onRestoreInstanceState (Bundle savedInstanceState)

onSaveInstanceState: This method is triggered when the Activity is easily destroyed by the system. Specifically:

• The user clicks the Home button
• The user clicks the Home button to switch to other applications
• There is a phone call waiting for additional operations

Mixed development and Android WebView application

The knowledge points involved in hybrid development mainly include:

• APP calls WebView to load url
• Master the packaging of WebView, understand all the WebSettings configuration, master WebViewClient, * WebChromeClient
• Master the two-way communication mechanism between WebView and Native, and encapsulate the two-way communication middleware by itself
• For the packaging of WebView, please refer to: GitHub: AgentWeb
• Understanding of the principle of communication middleware: GitHub: webprogress

Gradle, automated build, continuous integration related

Android system

Android Studio compilation process

Compilation tools used:
aapt, aidl, Java Compiler, dex, zipalign

Description of the main steps:

• Pack res resource files through aapt to generate R.java, resources.arsc and res files (binary & non-binary such as res/raw and pic remain the same)
• Process the .aidl file and generate the corresponding Java interface file
• Compile R.java, Java interface files, and Java source files through Java Compiler to generate .class files
• Through the dex command, the .class file and the .class file in the third-party library are processed to generate classes.dex
• Use the apkbuilder tool to package the resources.arsc and res files, assets files and classes.dex generated by aapt together to generate an apk
• Use the Jarsigner tool to debug or release the above apk
• Use the zipalign tool to align the signed apk.

App boot loading process

The sandbox principle of Android virtual machine Android App operation

Android architecture

The three most important categories in the Android source code: ActivityManagerService/PackageManagerService/View. It is recommended that you read this part of the source code during the weekend. Reading the source code can improve our ability to design and structure our own code in the future, and at the same time, we can understand it from the bottom. The operating principle of the entire android system, other things such as the message loop of the main thread, how the main thread interacts with AMS across processes, the working methods of various services in the SystemServer process, and the working principle of AsyncTask. This knowledge must also be mastered as an Android senior development engineer. You can't indulge in the interaction between ui and the four major components all day long. You must consider some issues of Android from a higher perspective.

• MVC pattern
• MVP mode
• MVVM mode
• CLEAN mode
• Component development
• Cross-platform development: Flutter, ReactNative (RN will be yellow in the future, just learn about it)

Mobile development peripheral

Server development related

• SpringBoot technology
• Restful API development
• Network protocol understanding : TCP/IP, HTTP/HTTPS, OSI seven-layer protocol
• Authorization and authentication protocol : OAuth2.0, etc.
• Basic database technology
• Data caching technology v: Memcached, Redis, the principle of Web caching
• Message queue technology
• Monitoring and log analysis technology

Front-end development related

There is a lot of front-end development knowledge, and there are endless frameworks, but the essential things are only the following.

• Core essentials : HTML, CSS, JavaScript
• Getting started : browser compatibility, custom UI and animation
• Intermediate skills : frameworks emerge in endlessly, currently with vue.js and react.js as the core
• Collaborative development skills : package management, modularization, tools using npm, webpack, etc.
• Advanced Skills : Research on the Source Code of Framework Principles

Develop and debug various tools

• Performance analysis tool : Memory Monitor
• Performance tracking and method execution analysis : TraceView
• View analysis : Hierarchy Viewer
• ApkTool -tool for reverse engineering Android Apk files
• Lint- Android lint tool is a static code analysis tool
• Dex2Jar -A tool to use android .dex and java .class files