Three things to make you an efficient programmer

This article is an article about programming development published by a very experienced senior programmer. He will use his own experience as a programmer to tell us what a programmer with high development efficiency needs to do. thing.

Many of us start programming with a specific purpose in mind. For example, when I started programming, it was to allow me to automatically play the text version of the MUD game while sleeping and at school. I was a 13-year-old kid writing scripts and didn't even know what programming was. I might have an idea, then write the code and test it - all on my own.

It becomes difficult when we develop software for other people because we often lack the same type of motivation and excitement that drives us to pursue our own desires. Instead of having ideas of our own, we spend hours in meetings trying to understand those ideas, and then we spend most of the time modifying other people's code - or submitting our own. This creates a level of disconnect that reduces productivity.

To become a 10x more effective developer, you must learn to excel in this environment and even start your own company to lead the effort.

Anyone can be a 10x more effective developer, at least at some point every day. I believe there are three things that all developers should focus on to improve productivity and teamwork.

Three Things

To become a 10x more effective developer, you need several years of experience, regardless of programming language and toolset. You have to be good at problem solving and writing code; it's a must.

It’s important that you understand that how you write code does not make you a 10x more effective developer, a 10x more effective engineer, a 10x more effective programmer, or whatever other name you want to call it.

You know the 5 W’s: “Who, What, Where, Why, When”. While these all apply to software development, I want to focus on three characteristics that define a 10x more effective developer. These three items separate the average developer from the 10x more efficient developer:

What(What)

Why(Why)

When(When)

Know what to do

In the corporate world, developers often work on projects that they have little interest in and don't understand. This isn't a big issue for most developers, as long as they receive good instructions and the output is clearly defined.

The problem is that developers often don't get enough instructions. Instead, we use something called “agile development.” We receive a note with a few words on it and are expected to know exactly what needs to be done.

Software development is all about communication. Developers need to know what we are doing, what problem we are trying to solve, and what exactly the desired results are. The more we know, the faster we can do it. Most importantly, it's critical to know the purpose of the job and what will make it successful.

Poor developers will spend hours on a project in the wrong direction without asking any questions. They are what I call negative 10x developers because they accomplish nothing and waste all their colleagues' time. Almost everyone has encountered these developers, and working with them can be frustrating. You have to be careful not to fall into their habit!

Some developers work well without a lot of detail. They have a lot of creativity and ask the right questions. These unicorns may be 10x more efficient developers. They know how to solve problems and often elevate the entire team.

The bottom line is that 10x effective developers are really good at quickly identifying what needs to be done and what questions to ask.

Understanding Why

Perhaps the biggest obstacle in software development is understanding why. If you don't understand the problem you're trying to solve, it's difficult to solve it.

Why do I put several terminal scripts together to play MUD games while sleeping and going to school? Of course I want to reach the highest level in the game. I know exactly why and I do everything in my power to achieve my goals.

The same approach applies to any software development project. Understanding the vertical industry they are in and the problem they are trying to solve will make developers more effective. Knowing why and understanding the industry vertical can also help prevent unnecessary work, freeing up time to focus on things that will make the product or feature more valuable to users.

The problem is that knowing why is not enough. To be a true 10x developer, you have to be passionate about the problem and understand it inside and out. I believe that most 10x effective developers are also product people at heart, with a good product vision.

Know what to do when

Time is very important in software development projects. Determining the order in which project tasks should be tackled may seem easy, but it is critical. Could your work help the company acquire a new customer or clear out old technical debt?

As a development team, we must constantly choose what we do and when we do it.

All software development work projects fall into the following three categories:

Things we must do

Things we need to do

Things we want to do Things

We have to complete new features for our customers. We need to fix bugs in software. We want to reduce some technical debt or develop some cool new product features. These all require balancing trade-offs.

We should be working on projects in all three dimensions simultaneously. We can't spend all our time on technical debt, but maybe we should spend a small portion of our time on it.

Developers must also know when to build complex architecture into their code. I'd rather keep the code as simple as possible and I won't add schema until it's time to die without adding schema.

Developers must also know when to avoid chasing fads. They tend to use new tools and techniques, but these things may just slow down a project instead of completing it faster.

10x more effective developers are good at prioritizing and knowing when to invest time into architecture rather than using a spaghetti-like mess of code to achieve something. Remember, your users don’t care how your software works, or how fancy the architecture is. They just want it to solve the problem. 10x Productivity developers understand this.

Master the What, Why, and When to Become a 10x Effective Developer

Now let’s talk about becoming a 10x effective developer Important skills: Master what (What), why (Why) and when (When).

Start with Why

The first step to becoming a 10x more effective developer is to become passionate about the software and problems you want to solve. You need to understand it completely, inside and out. This starts with being passionate about the company you work for and its mission.

Don’t write just one button just because someone else told you to. Try to understand why at a higher level. If you keep focusing on the why, you'll be of greater value to your team and company.

Be a good developer and a good problem solver, not the best programmer

I would describe myself as a hacker developer. I'm the kind of person who can quickly throw together some ugly code and solve almost any problem. My code is rarely beautiful, but it solves a problem. This is the most important.

You don’t have to write perfect code and unit tests to become a 10x more efficient developer. You need to know when to do these things and when not to do them.

A 10x effective developer excels at solving specific problems and meeting business needs through code. The smartest thing you can do is know how far it will go before you hand the project over to someone else (who is better at finalizing some architecture and other details).

When it's in your heart, or not

Knowing when to build a complex architecture rather than cobbling something together requires experience and your Spider-Man senses. You either feel this way or you simply don’t know.

Some of the smartest developers I've ever worked with were terrible at prioritizing pattern and architecture over functionality and scheduling. They always over-implement or refactor over and over again, striving for "perfect code" rather than "shippable code".

10x effective developers must use their experience and instinct to know when to focus on architecture and perfection, and when to just get things done.

Knowing What to Do and What to Ask

A lot of software development comes down to communication skills. Unfortunately, many of the notes and requirements on the projects we have to work on are not very detailed. A 10x effective developer knows how to read these, apply what they know about the "why" of the business, and ask relevant questions.

The best developers know how much time to spend on something before asking for help. They also know what questions to ask to clarify requirements to move the project forward.

Conclusion

I have been writing code for over 15 years. You could say I'm a 10x more efficient developer, or at least I can. I know what I'm good at, and when I do what I'm good at, I can get a lot done very quickly.

If you want to prototype a new product, I'm your guy. If you need help with Angular, React, or some other front-end, I'm definitely not your guy. I would be a negative 10 times more efficient developer on these tasks.

The 10x more efficient developer is not a myth. They do exist. They are most likely a development manager, architect, lead developer, or company founder. If they are not, they should transition. I later became the founder of the company, twice now.

Of course, no one can be a 10x more efficient developer every time of the day. We don’t have the energy or focus to work at this pace every day. We are not robots.

If you understand the “What, Why, When” of software development, you can be a more efficient and better team member – even a daily one 10x more productive developers in a few hours. This makes a big difference.

The above is what he shared, I hope it will be helpful to everyone.

Related recommendations:

Summary of experience in mini program development

Seven things that growing programmers need to do

A brief discussion on the future of PHP programmers