The hottest Development Practices Substack posts right now

Software development has different styles that often lead to similar outcomes, guided by underlying trends called attractors. These attractors influence how teams change over time, pulling them towards certain approaches.
It’s not just about adding more value in software projects. Instead, the focus should be on removing waste and improving efficiency in how teams work together.
The environment where a team operates, whether it's a productive forest or a limiting desert, greatly affects their potential for growth. The forest offers more opportunities for improvement than the desert.

Using composition is often better than inheritance because it allows for more flexible and maintainable code. You can mix and match simpler components to create complex systems.
With composition, you can easily swap out parts of your code at runtime, making it better for projects that change frequently. It's all about keeping things modular and manageable.
Though inheritance can be useful for stable hierarchies, focusing on composition is generally a safer bet, especially when you expect to make a lot of changes to your code.

Measuring lines of code in functions can be more complicated than expected. It's helpful to keep track of this while working on software projects.
Looking for patterns in software, like Pareto distributions, can provide valuable insights. It's good practice to analyze your own code for these patterns.
Documenting your findings is important. Sharing your experiences can help others who are trying to understand their software better.

Testing software too late can lead to more expensive and difficult fixes. It's better to catch bugs earlier in the development process.
Many teams rely too much on manual testing, which can slow things down. A mix of automated and manual testing can improve quality and efficiency.
Ignoring non-functional requirements like security and performance can make software unsatisfactory, even if it meets basic needs. It's important to include these factors in testing plans.

Application security has evolved rapidly with the changing landscape of development practices like shorter cycles and SaaS distribution methods.
Security organizations will face a pivotal moment in adopting new application security methods to stay effective.
In the past, application security was less competitive due to slower development cycles which allowed for comprehensive security checks and reviews.

Get a weekly roundup of the best Substack posts, by hacker news affinity:

Efficiency, effectiveness, and safety are crucial metrics for software delivery success
Consider implementing a 4-day work week to boost developer productivity and reduce burnout
Sharing opinions in team discussions can enhance decision-making and career growth in software engineering

Your code is read many times; writing clean code saves effort in the long run.
Spaghetti code leads to hidden bugs and is hard to change, making development expensive.
Writing clean code takes effort but helps you learn new skills, makes your code readable, and boosts your marketability.

Microsoft created the Secure Supply Chain Consumption Framework (S2C2F) to help organizations manage their use of open-source software securely. Its goal is to improve safety when using external code libraries.
The framework has three main goals: to ensure good governance of open-source software, to quickly fix known security issues, and to avoid using harmful software packages. These goals guide the practices that organizations should adopt.
S2C2F also emphasizes the need for continuous learning and improvement in security practices. Organizations are encouraged to regularly assess their security measures and adapt to new threats as they arise.