Owl's late night translation: six inefficient traps developers step on most often

Efficient time management is the ability of most successful software engineers. It can help you make rapid progress in your career, instead of working crazy overtime at the end of each agile iteration.

Every enterprise is trying to reduce costs and improve efficiency through automated assembly lines, upgraded IDE and DevOps. And by avoiding the following six inefficiency traps, you can be one step ahead and harvest an efficient day.

1. Over-exploitation

Have you ever complicated your requirements, consider what weird scenarios may appear. For example, can the designed API be seamlessly connected to other platforms? Or can the control panel automatically send reports?

Control these ideas and don't over-design! You should not spend a lot of time on some features that are too advanced. Moreover, more code means that more bugs and unnecessary scripts will be added to the already bloated program, resulting in reduced code readability and scalability.

To avoid this, always ask yourself whether this code is addressing the current needs. You only need to consider the use cases and boundary scenarios, and don't spend a lot of time on a feature that will not be used in the short term.

If you are not sure whether to add a new feature to solve a potential extreme scenario, bring it up and discuss it with you at the next agile meeting. This can help you save a lot of time and promote teamwork.

2. Write the same script again and again

As an engineer, you should follow the DRY-Don't Repeat Yourself principle as much as possible to improve efficiency. There are two ways to implement this principle: reduce redundant code or streamline the development process.

Code redundancy

Building a service or virtual environment often means writing the same script and executing it repeatedly. If you need to build a four-layer hierarchical architecture service and adapt it to development, testing, pre-release and production environments, the code and execution steps required for them are basically similar. In addition, the reliance on basic services is becoming increasingly complex. The above-mentioned work is not only repetitive and tedious, but manual execution may also lead to malfunctions and malfunctions.

The low-code platform provides tools out of the box, including reusable components and a graphical interface drag-and-drop generator. Of course, you can't find a perfectly adapted solution for every scene, but it can complete the most basic repetitive work. Automated pipeline can help you build, copy and deploy code to many environments.

Repeat process

List all the steps in the development process in detail and think about whether you can take out a few steps and automate them.

In addition, pay extra attention to steps that are executed more than twice. If you can trigger an automated process with one click when you need to do these tasks, you will greatly improve your efficiency.

Before you start automation, you also need to evaluate the cost-effectiveness of automation. It is recommended to ask yourself: Does automation really save time than manual operation? Do I frequently do this operation in the next few weeks?

If the answer is yes, start writing automated scripts. It can greatly reduce wasted time (and headaches).

Build a system from 0

If a developer needs to write customized code for the JDBC database link every time he builds a Web service, he will never be able to complete the development of the project.

Developing maintainable and safe software is our highest priority. However, this does not mean to build a system from zero. We don't need to reinvent the wheel and develop some functions that have already been implemented.

What the company needs is efficient work, and the time it takes to build a system from zero is unnecessary in most cases. So use the ready-made two-party package or framework and do some customized processing to meet the needs of customers.

You can also check the company's code warehouse. If there are some functions and the types you need to implement, you can investigate whether you can get the data you want through a method call.

However, when dealing with some sensitive data such as financial or health data, it is necessary to build a function from 0 to ensure security (after all, you don't know whether the introduced framework has security problems). However, in most scenarios, threaded frameworks, open source libraries, or paid plug-ins are sufficient.

Bad test case

When selecting technology between automated and manual testing, a delicate balance must be paid attention to. Therefore, let us understand how to use it to develop an effective testing strategy.

It is easy to write a small manual test to ensure that the new features you add are working properly. But as you scale, it takes more time to run these manual tests, especially when you are trying to find the nasty bug that keeps breaking your code.

If your application or website has many components, the likelihood of running certain tests correctly will increase. Automated testing and even a system that runs tests more efficiently can help avoid this situation.

You may need to spend a while to set up automated tests. However, once they are written, they can be reused and triggered regardless of any code changes. Therefore, you don't have to manually retest previous functions because new functions have been added.

On the contrary, choosing the right task to automate is equally important. Unfortunately, this is one of the most common mistakes in QA automated testing. It's easy to fall into the trap of over-automation and end up copying tests script by script. This is a major waste of time, because figuring out why these complex automations fail is still a manual operation-this is exactly what you want to avoid.

Don't let it become more complicated than it expects. Instead, focus on simple test cases and ignore low-frequency or complex tasks with many dependencies. Optimizing and planning your test strategy before you start writing any unit test cases will help save a lot of time.

5. Incorrect code optimization

This is a fairly common waste of time, and it is often difficult to detect from the beginning. You spend a lot of time optimizing code for low-priority and possibly unnecessary use cases.

Your only concern should be to get the function to work properly, and then consider optimization. However, don't set unrealistic optimization goals. Optimization decisions are usually customized for different scenarios.

If performance optimization only takes a few minutes, then do it. However, in most business scenarios, fur-level optimization is usually not important to the project. Is optimization a good thing? Yes. However, if you need to spend several hours to get a 1% performance improvement, it is best to discuss with the user first.

For example, suppose you are developing a web page for an internal team. If the website loads successfully within 1 second, you don’t actually need to optimize to load the website within 0.5 seconds, because this will not significantly improve business operations. However, if it is an e-commerce store, it would be a strong demand to let it load in one second instead of two.

The best way to solve this waste of time is to get feedback from users on a regular basis. Optimize based on their specific use cases instead of building your own use cases.

6. Invalid communication

Ineffective communication is the direct and sometimes indirect cause of wasted time in software development.

Software development consists of many steps-each team member is committed to different product functions, then handed over to the QA team for testing, and finally become the user's product.

Communication is crucial, especially during the development and testing phases. Suppose that the developer misunderstood the commercial use of the requirement. The resulting errors will make the solution too complicated, leading to errors in the technical solution and increasing the chance of anomalies or rework.

Since communication is the most artificially involved aspect of software development, this waste of time cannot be completely eliminated. However, with proper project management tools and collaboration environment, it can be reduced completely.

On a personal level, always consider the overall situation when meeting or developing features. Learn to listen and collaborate effectively. Develop the habit of writing down the content of the meeting discussion or sending a summary to align the expectations of both parties.

Otherwise, communicate as soon as possible. Don't guess the requirements, and if possible, do a demo before you formally invest in the entire project.

Summarize

The key to this article is to develop the habit of avoiding these time-wasting behaviors. Short-term productivity "hints and tricks" can only take you so far. But good coding practices and self-awareness will help you increase efficiency. Pay attention to where your time is spent, try to reduce it, and you can become a successful software engineer!