Effective time management is a skill that most successful software engineers possess. It will help you make rapid progress in your career without having to work long hours at the end of the sprint.
Every organization is trying to reduce waste and increase productivity through automated pipelines, enhanced IDEs, and DevOps. By avoiding these 6 major time wastes, one step ahead and make your day more efficient
1. Add too many features
By considering all "hypotheses", how many times have you made the story requirements too complicated? What if the API you are developing can be designed to integrate seamlessly into other platforms? What if your dashboard can send automatic reports?
Resist the urge. Don't overdesign it. You should not spend a lot of time on features that are too advanced in the future. Moreover, more code means more errors and unnecessary scripts will increase the bloat of the application. Understanding your code and adding new features will also be more complicated.
To avoid this, keep asking yourself if your code is solving specific story requirements. Make sure you think carefully about use cases and edge cases, but don’t spend weeks researching features that could have been delivered faster.
If you are confused about adding features that may solve extreme use cases, please raise them in the next sprint meeting. You will save a lot of time, and you will establish your team spirit.
2. Write the same script again and again
As a software engineer, you should follow the DRY (Don't Repeat Yourself) principle to improve work efficiency. This can be done in two ways: eliminate redundancies in the code or simplify the development process.
Let's see how to deal with these two situations.
Code Redundancy
Setting up a server or even a virtual environment involves writing the same scripts and operations multiple times. You will use almost the same steps and code to build a 4-tier development architecture with development, testing, stage, and production environments. Most importantly, managing infrastructure dependencies has become more and more complex. Not only is it repetitive and tedious, but manual operation also makes you vulnerable to human error.
The low-code platform has this out-of-the-box functionality, with reusable abstract-based components and a visual drag-and-drop interface. Of course, you will not find a one-click solution for every scenario, but you will have the most basic and repeatable solution. Automated pipelines will help you build, copy, and extend code for as many environments as you need.
Process redundancy
Clearly outline the number of steps you perform in the development process and consider how to reduce them. Automation is your friend.
In addition, please be aware that you end up performing the process more than twice. You can benefit from an automatic sequence that is triggered every time you want to perform the task.
However, before proceeding with automation, always pay attention to the time trade-off. Some questions to ask yourself before automating anything include: Compared to performing tasks, would I save more time if I automate them? At least for the next few weeks, will I do this regularly?
If the answer is yes, please execute it automatically. Reduce time wastage (and headaches).
3. Build the system from scratch
If developers must customize the JDBC database connection every time they build a Web application, it will take a long time to complete a single project.
Developing maintainable and safe software should be your top priority. However, this does not mean building the system from scratch. You don't need to reinvent the wheel and rebuild functions that already exist.
Companies need to work efficiently, and the time you spend building a system from scratch is redundant in most cases. So, instead, build pre-built functions by using frameworks and customize them according to customer needs.
In addition, check the pre-existing company code database. If the existing functions of the tool overlap with the functions assigned to you, it is best to check whether the function call can provide you with the data you need, or whether it can be integrated.
However, when dealing with confidential data such as financial or health records, it makes sense to build features from scratch to enhance security. But in most cases, frameworks, well-known open source libraries or paid plugins can do this perfectly.
4. Bad testing strategy
When choosing between automated and manual testing, you must pay attention to a delicate balance. Therefore, let us understand how you, as a software engineer, can 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 when 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 that you will run a particular test without error also increases. Automated testing and even a system that runs tests more efficiently can help avoid this situation.
You need to spend more time setting up automated tests. However, once they are written, as long as you make any code changes, they can be reused and triggered. Therefore, you don't have to manually retest previous features because new features 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 eventually copy the tests script by script. This is a major time waste, because figuring out why your complex automation doesn't work is still a very manual task-which is exactly what you want to avoid.
Don't let it become more complicated than it must be. Instead, focus on simple test cases and ignore infrequent or complex tasks with many dependencies. You will save a lot of time by optimizing and planning your test strategy before you start writing any unit test cases.
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 use cases that are not prioritized or may not even be needed.
Your only focus should be to make the function work before you think about optimization. However, don't set unrealistic benchmarks. Optimization decisions are usually based on cases.
If performance optimization only takes a few minutes, then do it. However, in most business scenarios, byte-level optimization is usually not important to the project. Is it good? Yes. However, if you need to spend several hours to achieve a 1% performance increase, it is best to discuss with stakeholders first.
For example, suppose you are developing a web page for an internal team. If the website loads successfully in 1 second, you don’t actually need to load the website in 0.5 seconds. This will not significantly improve business operations. However, if it is an e-commerce store, having it load in one second instead of two will be a feature requirement.
The best way to solve this waste of time is to get feedback from users on a regular basis. You should optimize based on their extreme use cases, not build your own use cases.
6. Invalid communication
Ineffective communication is the direct and sometimes indirect cause of a lot of time wasted in software development, some of which have been mentioned in this list.
Software development has many active parts-each team member works on different product functions, then becomes the input of the QA team, and finally becomes the end user's product.
Communication is crucial, especially during the development and transition phases. Suppose the developer misunderstood the business requirements of the story. This communication gap can make the solution too complex, lead to technical errors and increase the chance of errors or rework.
Since communication is the most user-friendly aspect of software development, this waste of time cannot be completely eliminated. However, with the proper project management tools and collaboration environment, it can certainly be reduced. Tools such as Trello or Microsoft Teams can help reduce friction.
On a personal level, when meeting or developing features, always consider the big picture. Learn to listen and collaborate effectively. Develop the habit of writing down the content of the meeting discussion or sending a summary to clarify the expectations of both parties.
In addition, communication should be done sooner rather than later. Don't assume requirements, and if possible, show a small demonstration before working on the entire project.
发表评论 取消回复