Software Design

Software design is the process of conceptualizing the software requirements into software implementation. This is the initial phase within the software development life cycle shifting the concentration from the problem to the solution.

When conceptualizing the software, the design process establishes a plan that takes the user requirements as challenges and works to identify optimum solutions. The plan should determine the best possible design for implementing the intended solution.

 Software Architecture 

The software architecture of a system depicts the system’s organization or structure, and provides an explanation of how it behaves. A system represents the collection of components that accomplish a specific function or set of functions. In other words, the software architecture process provides a sturdy foundation on which software can be built.

A series of architecture decisions and trade-offs impact quality, performance, maintainability, and overall success of the system. Failing to consider common problems and long-term consequences can put your system at risk.

There are multiple high-level architecture patterns and principles commonly used in modern systems. These are often referred to as architectural styles. The architecture of a software system is rarely limited to a single architectural style. Instead, a combination of styles often make up the complete system.

And then, what is the difference between Software Design and Software Architecture?

Software design provides everything that software developers need to know to produce consistent software that implements the required functionality. This includes specifications of services, components, integrations, data models and algorithms.

Software architecture places big-picture constraints on the design to ensure that it aligns with the business and technology strategy of an organization. This includes considerations such as compliance, technology standards and operational efficiency. Architecture is intended to prevent designs from repeating known mistakes or being inconsistent with the rest of the organization.

How are they related?

Software architecture exposes the structure of a system while hiding the implementation details. Architecture also focuses on how the elements and components within a system interact with one other. Software design delves deeper into the implementation details of the system. Design concerns include the selection of data structures and algorithms, or the implementation details of individual components.

Architecture and design concerns often overlap. Rather than use hard and fast rules to distinguish between architecture and design, it makes sense to combine them. In some cases, decisions are clearly more architectural in nature. In other cases, decisions focus heavily on design and how it helps to realize that architecture.

To learn it in a more practical way:

Software Design is a plan that gives enough detail for developers to implement consistent software.

Software Architecture is a plan that constrains software design to avoid known mistakes and achieve an organization’s business and technology strategy.

The level of software design is: implementation

The level of software architecture is: structure

Software architecture is the process of creating a high level structure for any software project. This should be based around the requirements of what we want the system to do, resulting in the guidelines meant to be used in the actual development process.

During our years of experience with our software architecture consulting service, we have witnessed how people underestimate the importance of Software Architecture. Some don’t even know what it is or how it can benefit them to clearly define their software architecture requirements before developing new software.

Let’s say a developer is like a builder. Can a builder start constructing without an architect? Well, in theory this is possible but in the long run the house or building will not have a proper foundation to support an earthquake or any other structural change if expansion is required. Solid foundations for the software project will warrant that the project will be scalable and powerful.

So, in order to understand the key forces that are framing architectural decisions at the moment that will have an effect in future decisions for scalable projects, we need to talk about user demand, business demand, the concept of support to work with different work styles and workflows, and most importantly the improvement of adaptability of software design. Here are some key concepts to understand the different approaches of software architecture:

• Service Oriented Architecture (SOA) or user empowerment: Is driven by vendors, products and technologies. It always represents a business activity with a specific outcome and a given aim. Since it is intended for the end user, it has to be intuitive and has to be concerned with correct behavior, good performance and flexibility. Making it easy for the customer to interact with the application instead of misleading with poor user experience like many do. Understanding of scenarios and the process of making them as simple as possible will deliver an excellent user experience.
• Market Maturity: Take advantage of available technology when designing a new software solution since these languages and frameworks are already proven solutions to common problems. By doing this, we can focus our time and effort in what is really important, building the value added functionality to your software project.
• FURPS: This acronym stands for Functionality, Usability (UX), Reliability, Performance and Supportability.  More specifically, when talking about FURPS, we should think about capability, reusability, security, performance, etc. All of these are important aspects to take into consideration when thinking about software architecture. Since the technology world is constantly evolving, it is important to keep an eye on new trends, composition models, increase in network bandwidth, hardware performance, cloud-based computing and any other operation you can automate within the software.

The current philosophy on software architecture is evolution and unfortunately, information is sometimes limited at the beginning of the project. Therefore, the software design will need to be adjusted as more information becomes available and the software solution is tested in a production-like environment.

Here are some questions to keep in mind when thinking about software architecture:

• What are the fundamental components of software architecture that could create a great impact if you get them wrong?
• Which components of the software architecture are most likely to change, or its final decision can be postponed until later on in the project with a minimal or no impact?
• What are your main theories and how will you validate them?
• What events or situations may force you to adjust your software architecture?

To wrap it up, it is important to start with a basic software architecture to get a general understanding of then gradually refine your initial design as you obtain more information. It is important to probe all major stakeholders that will use the software solution in order to make sure requirements are aligned with user needs and prevent any major potential problems from arising in the future.