To all Android engineers: The trouble of not having technical depth

Preface

Recently, a reader went for an interview for an Android development position. This reader was a graduate of a prestigious company (one of the BAT companies) and was a senior Android engineer with ten years of software development experience, but the company rejected him on the grounds that he did not have the technical depth.

Yesterday morning, I also discovered this problem when I was doing a mock interview with him. Because from his resume, I saw that he had worked in two well-known Internet companies, and the interviewer would unconsciously raise his expectations of him. Although he has rich project experience, after real communication, I found that although he worked in a well-known company, he did not master the "core technology", and his advantage suddenly became a disadvantage.

As you get older, your original advantages are slowly turning into your disadvantages.

For experienced or soon-to-be experienced Android engineers

When we were junior engineers, what we wanted most was to have rich project experience so that we could fill our pale and dry resumes with dazzling and fullness. However, as time went by, the projects on our resumes became quite "full", but our behavior of only looking at the "appearance" created another dilemma for us: we looked very experienced, but in fact, we had never done anything difficult. We may have only used 1 year of work experience 9 times after working for 10 years.

Just like this reader who went to the interview, you can see his brilliant project experience from his resume, but you will find that there is no depth in his resume. Although some of his resumes are written very technically, they are really just at the level of using APIs; some of his solutions to problems are very skillful, but not systematic.

It’s a pity that I didn’t take a few more steps to research and expand.

So how to change it?

The other party was also asking me this question, and very urgently, so urgently that he hoped that I would explain it clearly today so that he could go deeper into the interview tomorrow.

I was very helpless and directly explained that this is probably impossible. If it is possible, others can also quickly master the core technology and become very in-depth. But in the long run, I think it is possible, for example, give yourself half a year to learn, expand and practice a technical framework in a previous project. *** You can use the resources of your current company, such as the project team working on this framework, build a good relationship with them, learn from them, and discuss with them every problem you encounter.

But there is absolutely no other way to improve to a deep level by just looking at it or preparing for it temporarily. If you can do it, you must be a very deep master in some aspect, so you can ignore what I say.

No depth of reason

There are two main reasons why we don't have technical depth: the first is avoiding problems, and the second is lack of interest.

When we encounter a problem at work, the best choice is often to avoid it, whether from a design or technical perspective, or to find other alternatives, such as using someone else's open source library or reinventing the wheel. There is nothing wrong with this, but if we want to make further improvements or have more technical depth, we must understand the problem, or at least understand how others can solve the problem.

Second, regarding interest, many people do not go a few more steps to go deeper. A very important point is that they have no interest and are not curious at all. If we encounter some very interesting solutions, frameworks or some weird problems, but we do not want to "provoke" them at all, and we are afraid to avoid them, then naturally, we also lose the opportunity to make breakthroughs and go deeper on these points.

How to improve your technical depth?

1. Advanced Java language and Android related technical core

Android applications are developed in Java, and the SDK is also written in Java, so we have to learn Java. In addition, although the Kotlin language has been officially promoted by Android, Kotlin is also compiled into Java before running. For Android, as long as the SDK is not rewritten in Kotlin, Java needs to be learned. Moreover, the background server program of Android apk is most likely built in Java, so learning Java is also inevitable. So what in Java do we Android programmers need to learn? Since Android programmers are used to CV code blocks, the slightly more difficult Java basics related to Android are almost a threshold, such as generics, multithreading, reflection, JVM, Java IO, annotations, serialization, etc., are all CV objects, and programmers do not understand the principles.

2. App development framework knowledge system (APP is also an object)

This knowledge is the most used one nowadays. We call it Android 2013~2016 technology. However, even with such technology, Android developers are often familiar with but unfamiliar with this frequently "used" code because they are used to copying codes from the Internet: familiar in that they deal with it almost every day and copy these codes every day; unfamiliar in that although they deal with these codes every day, they have not studied the principles of these codes in depth and the deep connotations of the codes. Therefore, we need to analyze these knowledge points from a new perspective, study them in depth, learn the source code, imitate the source code, and then hook the source code, so that we can say that we understand this knowledge. These are the foundations of Android development and senior engineers.

3. Comprehensive performance tuning of Android App

We need to work on two levels to improve the performance of an app. The first level: we need to pay attention to making our code high-performance and highly available when writing code. This process is called writing high-performance code. The second level: we use tools to check the problems of the already formed code, and use the problems found to guide us to delete and modify the code. This process is called tuning.

How to write high-performance code? We need to have a deep coding foundation, which is the basis of the code. For example, the data structure can be written into a special structure that suits the current scenario according to the application scenario. For example, Google has developed sparseArray to replace HashMap based on the characteristics of the Android platform. In addition, you need to have your own unique insights into commonly used algorithms. If you practice hundreds of questions on LeetCode, you can almost master the most commonly used algorithms such as sorting, searching, and dynamic programming. Furthermore, if efficient algorithms and memory-saving data structures are combined with excellent design patterns that suit the application scenarios, then these provide the basis for implementing high-performance code.

Another is to tune the written code. The direction of tuning is to use the Profiler tool to test and check where there are operations that consume a lot of performance, and then analyze the problems with the code. The direction of tuning becomes how to tune memory, power consumption, network traffic, and of course, analyze and tune the startup speed, page switching effect and speed, white screen experience at startup, reasons for screen flashing, etc. ***Add a screen adaptation and camera adaptation.

Audio and video/HD pictures/AI/live broadcast/TikTok, etc., which are the technologies that are most closely related to users and our lives, have been looking for the final technology landing platform. In the past, it was the Windows system, but now it is the mobile system. In the mobile system, Android accounts for the vast majority, so Android NDK technology has become a necessary skill for us. To learn NDK well, you need to learn the basics of C/C++, jni, and Linux. In addition, audio and video encoding and decoding technology, streaming media protocols, ffmpeg are all necessary skills for audio and video development, and OpenCV/OpenGl/ are necessary knowledge for image processing. These are practical projects at the principle level.

Due to space constraints, there are still many points that need to be improved, such as hybrid development, small program development, architecture topics, etc., which will not be elaborated here.

At which point should I go deeper?

After working for many years, we must have a certain depth and breadth in technology. Needless to say, you will understand the necessity of breadth. Depth is related to your own interests or the work modules that are close to you. If you go deep into the relevant modules of the company, you can use more resources. Or if it is a module that you are interested in, even if there are no resources, you will find what you need because you are very interested.

We never lack methods.

Leading and being led

The depth of technology is a relationship between leading and being led.

I have a deep understanding of this. When I first started Android development, my job was to maintain the system applications that come with Android. I could solve any problems raised by customers or conduct secondary development. Then I would have some free time, so I found the simplest application (Notepad) in the system applications to practice.

I thought since it was so simple, I would write one myself, and implement a notepad app from scratch. When I started writing, my understanding of Android apps was overturned. I found that I didn't understand the things I thought I understood before. I encountered many problems that I had no idea about. For such a simple app, I had to rely on constantly comparing the original code implementation to find out where my problems were, and then I was convinced of the huge gap between doing and watching.

If you only do things based on other people's work to solve problems, even if you think you have come up with a good idea, like a flash of inspiration, and you have cleverly solved the customer's problem, it is actually just a skill. In terms of how to build the application, architecture, and design the organization, you have not made much real progress.

At this time you are just a follower, and you are led by other people's source code.

Even if you have seen and used many application frameworks, the knowledge gained from them is still shallow, and it only adds some capital for theoretical discussion. You are always a person who is led. The leader sets the framework and a road for you, and then you play tricks on the road he set, but you have a false impression that you are very powerful and skilled.

If you write such a framework yourself, or design an idea, and specify a direction and path, you will find that it is not as simple as you imagined.

Do you want to be a leader or a person who is led?

summary

Lack of technical depth is the norm for most programmers.

This is not a bad or good phenomenon, it is just a reasonable state, because many jobs and projects that many people are engaged in do not require much technical depth. Even if you have depth, you may find that you can't use it. For most people, the rational approach is not to pursue technical depth but to have enough technology.

But it’s different for individuals. You need to be technically competent, but you also need to have a certain depth in certain aspects to highlight your ability to learn, understand and apply, and this ability must be backed by successful cases.

Especially when you become a senior engineer, many companies do not want you to be mediocre and lack depth. Although you may wonder, even if I have depth, you may not be able to use it? However, the demand for people at this level is not as high as that for junior and mid-level developers. It is more rational and safer for companies to choose people with depth, isn't it?