Starting My Journey in Software Architecture: Lessons from the Expert .NET Mentorship

What is Software Architecture?

Building a system for a client involves the entire composition, integration, and interaction of components within the system. Every system has an architecture—some are good, and some are not so good. The choice of architecture can have significant consequences, such as:

- Difficulty in understanding

- Difficulty in making modifications

- Slower delivery

- More defects

Good Architecture:

- Easy to understand

- Easier maintenance

There are established norms that govern best practices in architecture.

Requirements Identification

The system's functions are defined through a set of requirements. These requirements can be divided into two types: functional and non-functional.

Functional Requirements:

- Defines a necessary function within the system

- The function is related to input, behaviour, and output

- Typically lacks a detailed description of the expected behaviour of the system's functions

Considerations:

- What if the internet is unstable? How do we handle timeouts?

- What if the database is down?

- What if the user inputs the wrong postal code?

Non-Functional Requirements:

- Explicitly requested by the stakeholder

- Scalability

- Security

- Accessibility

Non-functional requirements can influence the technologies that will be used in the project.

It's crucial that both developers and business analysts speak the same language—this is known as a ubiquitous language, which helps reduce communication gaps.

Software Architecture vs. Waterfall

Upfront Architecture:

- Defines the entire architecture before starting the project

- Programming is seen only as the implementation of ideas into code

Waterfall Model:

Originating in the 1970s, this model defines a sequence of phases for software development, where each phase depends on the previous one:

1. Requirements Definition

2. Design

3. Implementation

4. Verification

5. Maintenance

The challenge with this model isn’t the activities themselves but the rigid focus on planning, including creating schedules and delivery budgets. It struggles to adapt to the dynamic nature of software creation, where requirements can change rapidly. This is why the Waterfall model often doesn't meet modern needs.

Emergent Architecture

Starting development early allows for faster feedback and improves software quality. Often, the initial architecture is similar to that of an existing project. It must be adaptable to frequent changes and accelerated value delivery.

This process involves the incremental construction of software. After the project begins, it undergoes several iterations that include phases like design, implementation, and testing. Aligned with agile methodologies, each sprint delivers a functional and testable piece of software. The process repeats until all requirements are met. The most common phases are:

1. Analysis

2. Design

3. Implementation

4. Testing

When the project kicks off, only a few requirements are initially specified and refined as the project progresses. Each sprint defines new requirements, and a functional delivery is made at the end. During the evaluation of the delivery and requirements, refactoring may be necessary. These periods usually last about two weeks.

The Role of a Software Architect

A software architect is responsible for aligning functional requirements with system specifications. They interact with stakeholders, project managers, and business analysts, and they coordinate software analysts. Typically, they propose solutions rather than impose decisions.

Key Responsibilities:

- Requirements identification

- Dividing the system into components

- Identifying and analyzing technologies

- Cost-benefit analysis

- Proposing scenarios beneficial to the project

- Formulating specifications

How the architect communicates what needs to be done to the development team can vary—class diagrams, sequence diagrams, documentation, wikis, etc.

Debunking the Myth About Software Architects

A common myth in the industry is that architects don’t write code. They shouldn’t be placed on a pedestal above developers. Architects are the natural evolution of programmers—they’re developers with more experience and training.

---

This article is the first in a series on software architecture, where I’ll delve deeper into each of these topics. I’d love to connect with professionals and enthusiasts in the field. Feel free to add me here on LinkedIn, or send me an email at [email protected] . Let’s share insights and grow together!

#SoftwareArchitecture #TechLeadership #Agile #SoftwareDevelopment #Mentorship #Coding #SoftwareEngineer #CareerGrowth #ConnectWithMe