S3Corp. Tech Blog

1. If Your Change is Small Enough, There’s No Need to Test

A common piece of advice you may hear is that small changes don’t require testing. This advice is flawed and can lead to bigger problems down the line. Many developers, especially those who are pressed for time, think that minor tweaks won’t impact the functionality of the software, so they skip the testing phase. However, even small changes can introduce bugs or unintended consequences.

Charles Kong, a Google developer, highlights the importance of testing in all circumstances, no matter how minor the change. He stresses that writing tests for every piece of code, no matter how trivial, is a good practice. While it may seem like an additional task, it’s actually faster and more efficient than troubleshooting an issue that could have been prevented with a simple test. A minor typo or oversight, for example, can lead to unexpected issues that may not be apparent right away. Tests help to catch these mistakes early and ensure that all parts of the software function as expected.

Thus, testing is a fundamental aspect of development that should never be skipped. Even if you are confident that a small change won’t cause any problems, it’s better to take the extra few minutes to ensure the code behaves as intended.

2. You Don’t Need to Comment on Well-Written Code

There’s a widespread misconception that if the code is clean and well-written, no comments are necessary. The belief is that a good developer should write code that is so clear that it explains itself. While writing readable code is important, the lack of comments can still cause issues. Code comments are not just for explaining complex logic; they provide context, intent, and future guidance, all of which are invaluable for future developers or even yourself when revisiting the code after some time.

Trung Le, a developer at Jawbone, has shared his experience with this issue. He points out that many developers, particularly those new to a codebase, struggle to understand the intent behind the code if no comments are provided. The code might be syntactically correct, but without comments, it can be difficult to grasp why certain decisions were made or how the code interacts with other parts of the system.

Code comments help maintain readability, especially in larger projects or teams. Developers may have different styles and approaches, and without comments, it can be hard to understand each other’s work. Proper comments can prevent confusion and ensure that the project continues to run smoothly, even if the original developer is no longer involved. Therefore, always comment on your code, even if you believe it’s self-explanatory. It will save time and prevent unnecessary headaches in the future.

3. Avoid Offshoring at Any Cost

Offshoring has become a common practice in the software development industry, yet it often gets a bad reputation. Many believe that offshoring leads to lower-quality work, poor communication, and unreliable results. While these concerns can sometimes be valid, they do not apply universally. There’s an argument that this view is an overgeneralization. It emphasizes that there are skilled developers in every country, and the key is to find the right talent, regardless of location.

For example, Vietnam has emerged as a strong player in the software outsourcing market. The country has a large pool of educated and talented software developers who can deliver high-quality work. Like any country, there are varying levels of expertise, but dismissing an entire region based on hearsay can limit your access to capable professionals. The ability to find skilled developers depends on proper vetting, communication, and setting clear expectations.

The quality of the development process does not necessarily depend on the location of the developers, but rather on their skills, experience, and the structure of the collaboration. Instead of avoiding offshoring altogether, businesses should focus on finding reliable partners and building strong communication channels. When done correctly, offshoring can provide cost-effective solutions without compromising the quality of the final product.

4. Build on Opinions or Assumptions, Not Measurable Results

One of the most damaging pieces of advice in software development is to base decisions solely on opinions or assumptions, rather than on data. In the world of software development, particularly product development, decisions should always be grounded in measurable results. Ludo Antonov, Technical Lead for Pinterest’s Growth Team, explains that relying on assumptions rather than testing results can lead to wasted time and resources.

At Pinterest, the team adopts a data-driven approach to product development. Ideas are tested with real user data and metrics before being fully implemented. This helps ensure that decisions are not made based on gut feelings but on actual evidence. Testing features, collecting feedback, and analyzing data before making further changes helps teams make informed decisions that will positively impact the product.

This method not only avoids wasting resources but also leads to more effective features and improvements. By focusing on measurable results rather than assumptions, development teams can create products that better meet user needs and drive meaningful growth. Ignoring data in favor of assumptions can result in decisions that don’t have the desired impact, ultimately slowing down development and hindering progress.

5. Don’t Touch ‘That’ Part of the Code

When you inherit a codebase, you may encounter areas marked off as “untouchable.” These parts of the code are often considered sacred because they’re believed to be too critical or too fragile to modify. However, this advice can be detrimental. Adnan Ali, the lead software architect at Financeit, recalls a piece of advice he once received: “Don’t touch that part of the code. Nobody touches that part of the code!” This kind of thinking can stifle innovation and improvement.

Instead of avoiding certain parts of the code, a good developer should embrace the challenge of understanding and improving it. Ali decided to dive into the supposedly untouchable code, and after analyzing it, he was able to optimize it, leading to a 20% performance improvement. This example illustrates the importance of exploring and understanding every part of the codebase, no matter how intimidating it may seem.

Being afraid to touch certain parts of the code can limit the potential for improvement. A good developer isn’t afraid to tackle complex or delicate sections of a project. By studying and understanding the code, you can make necessary changes that improve performance, fix bugs, or add new features. Avoiding parts of the code out of fear only hinders progress and reduces the potential for innovation.

6. Don’t Worry About Planning

One of the most misleading pieces of advice a developer can receive is to skip the planning phase and just start writing code. This advice encourages developers to dive straight into coding without first defining the project’s goals, scope, and priorities. While coding is a crucial part of development, planning is essential to ensure that the project moves in the right direction.

Before starting any project, it’s important to map out the features and functionality you want to build. Prioritizing features helps focus on what’s most important and prevents feature bloat. Planning also helps allocate resources efficiently and set realistic timelines for delivery. Without a solid plan, a project can quickly become disorganized, leading to wasted time and money.

It’s not necessary to plan every detail in advance, but having a clear roadmap is vital for success. By identifying core features and setting achievable milestones, you ensure that the project stays on track and that the final product meets user needs. Rushing into development without planning can lead to poor outcomes and unnecessary setbacks.

Conclusion

Software development is a complex process, and navigating through the multitude of advice available can be overwhelming. While it’s important to be open to feedback, it’s equally crucial to critically evaluate the advice you receive. The six pieces of advice discussed here—avoiding testing for small changes, skipping comments, disregarding offshoring, making decisions based on assumptions, avoiding parts of the code, and neglecting planning—are all examples of guidance that can hinder a development project’s success. Instead, embrace testing, commenting, data-driven decisions, and proper planning to ensure the quality and success of your software development projects.