A primer for emerging software architects

I have been working with software architecture in different forms since 2005, and I often find myself mentoring new and aspiring architects. One thing that keeps coming up is the importance of grasping the foundational principles of software architecture and applying these principles. This article is for those who are just starting their journey into this exciting field. We'll explore software architecture principles, why they're important, and how they apply in an Agile environment.

Understanding software architecture

The discipline of software architecture lies at the heart of developing complex software systems. It involves the high-level structuring of software systems through a set of design decisions, often documented as architectural patterns, that address critical system concerns such as scalability, resilience, and maintainability. Each architectural decision influences how components in a software system interact and behave as a whole.

When we talk about software architecture, there are several key aspects to consider:

• Reliability: We aim to build systems that are capable of handling faults and errors without breaking down. These systems should provide consistent performance and deliver the expected output despite any challenges.
• Effectiveness: Our systems should meet the needs of users and fulfil all business requirements. This requires us to thoroughly understand those needs and translate them into our architectural design.
• Maintainability: Lastly, our systems should be easy to manage and adapt. This includes scaling them up or down as needed, and adding new features without causing disruption.

Applying software architecture principles in Scrum

Now, let's bring our attention to the Agile environment. Scrum emphasizes the incremental and iterative development of software, which naturally poses a few challenges for us as architects. How can we incorporate a comprehensive architecture in an environment where the development is done in short sprints, features evolve over time, and change is not only expected but also welcomed?

Here's where evolutionary architecture shines. Coined by Rebecca Parsons, Neal Ford, and Patrick Kua, evolutionary architecture focuses on creating architectures that can evolve with changing requirements and technologies. It emphasizes principles like last responsible moment.

In a Scrum environment, we can use architectural spikes: short, time-boxed investigations, to help inform our decisions about the system's structure. We consider different solutions and choose the one that best fits the current needs of the system, while keeping future changes in mind.

Sources to deepen your understanding

To master software architecture, it's crucial to familiarize yourself with reputable sources that provide a comprehensive view of the discipline. Here are a few of my recommendations:

• Books: Three must-reads are Software Architecture in Practice by Len Bass, Paul Clements, and Rick Kazman, Clean Architecture: A Craftsman's Guide to Software Structure and Design by Robert C. Martin, and Building Evolutionary Architectures by Rebecca Parsons, Neal Ford and Patrick Kua.
• Online courses: For interactive learning, consider courses like Software Architecture & Design on Udacity, or Software Architecture on Coursera.
• Academic papers and journals: Keep yourself updated with the latest research and developments by reading papers and journals like IEEE Software or Journal of Systems and Software.
• Blogs and forums: Industry veterans often share their knowledge through blog posts or discussions on forums like StackExchange or the Software Engineering subreddit.

For Agile architecture, I highly recommend the Agile Architecture: Strategies for Scaling Agile Development article by Scott Ambler, and the Disciplined Agile Delivery book series by Scott Ambler and Mark Lines.

Wrapping up

As budding software architects, always remember that architecture is not a one-time decision. It's an ongoing commitment to ensure that the system's design can respond to change. In a Scrum environment, be prepared to revisit your architectural decisions at the end of each sprint, or even during. Embrace the mindset of 'inspect and adapt'.

And lastly, a good architect isn't just someone who answers questions, but one who knows what questions to ask. Keep asking, keep learning.