Skip to main content

Non-Functional Requirements in Architecture

 

Introduction

The architecture of software systems is primarily shaped by functional requirements, quality attributes (also known as non-functional requirements), and constraints.

Software architects make critical design decisions to decompose a system based on these requirements. While functional requirements define what the system does, non-functional requirements (NFRs) dictate how well the system performs. Many of these decisions focus on achieving quality attributes while considering external constraints such as time, cost, and existing technology limitations.

Tactics and Their Role in Architecture

Tactics are specific design decisions that help achieve a quality attribute (Bass et al., 2003). These decisions influence both the structure and behavior of a system but usually have a smaller impact compared to architectural patterns. While patterns define high-level structures and interactions, tactics provide low-level solutions to enhance quality attributes. In some cases, a tactic may be a subset of a larger architectural pattern.

Architectural Methods for Handling Quality Attributes

Several architectural methodologies provide structured approaches to achieving NFRs:

  • Viewpoints and Perspectives – A method used to systematically address different architectural concerns.

  • Microsoft Software Architecture Method – A set of industry best practices to ensure software reliability and maintainability.

  • Process of Software Architecting (PSA) – An iterative method focusing on balancing functional and non-functional aspects.

  • ACDM (Architectural Conceptual Design Model) – A methodology for high-level system design.

  • RUP (Rational Unified Process) – A disciplined approach to software development with a focus on iterative design.

  • ADD (Attribute-Driven Design) – A methodology specifically focused on achieving quality attributes through structured decision-making.

Among these, ADD (Attribute-Driven Design) is particularly significant as it explicitly prioritizes non-functional requirements in architectural decisions.

Quality Attributes and Their Standards

Non-functional requirements are categorized under different standards, including ISO/IEC 25010:2011, CISQ, and FURPS.

ISO/IEC 25010:2011 (Current Standard)

This standard replaces ISO/IEC 9126 and provides a comprehensive model for assessing software quality:

Quality in Use:

  • Effectiveness

  • Efficiency

  • Satisfaction

  • Freedom from Risk

  • Context Coverage

Product Quality:

  • Functional Suitability

  • Reliability

  • Performance Efficiency

  • Usability

  • Security

  • Compatibility

  • Maintainability

  • Portability

Each of these attributes has further subcategories to define specific evaluation criteria.

CISQ (Consortium for IT Software Quality)

CISQ focuses on software quality at the code level to ensure robustness and maintainability:

  • Reliability – Ensuring system availability and fault tolerance.

  • Performance/Efficiency – Optimizing system responsiveness.

  • Security – Protecting against vulnerabilities and threats.

  • Maintainability – Ensuring ease of future modifications and bug fixes.

FURPS Model

FURPS is a widely used model introduced by HP to classify software requirements:

  • Functionality – The system’s ability to meet business requirements.

  • Usability – The ease with which users can interact with the system.

  • Reliability – The system’s ability to perform consistently under different conditions.

  • Performance – The efficiency of execution in terms of speed and resource usage.

  • Supportability – The ease of maintaining and extending the system.

Conclusion

Non-functional requirements play a crucial role in shaping software architecture. Effective architectural methodologies, such as ADD, help ensure that quality attributes are met alongside functional requirements. Standards like ISO/IEC 25010, CISQ, and FURPS provide structured frameworks to assess and enhance software quality. By strategically implementing tactics and patterns, architects can build systems that are not only functionally rich but also robust, scalable, and maintainable.

Interesting resources

1. How do architecture patterns and tactics interact? A model and annotation

http://www.cs.rug.nl/paris/papers/JSS10b.pdf

2. ADD 3.0: Rethinking Drivers and Decisions in the Design Process

https://resources.sei.cmu.edu/asset_files/Presentation/2015_017_101_438648.pdf

3. Decision Model for Software Architectural Tactics Selection Based on Quality Attributes Requirements

https://www.researchgate.net/publication/283953802_Decision_Model_for_Software_Architectural_Tactics_Selection_Based_on_Quality_Attributes_Requirements

4. Modeling Architectural Non Functional Requirements: From Use Case to Control Case

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.460.7189&rep=rep1&type=pdf

5. Rigorous Component-Based System Design Using the BIP Framework

http://www-verimag.imag.fr/~sifakis/RecentPublications/2011/ieee-software.pdf

6. Proposed Framework for Handling Architectural NFR’s within Scrum Methodology

http://worldcomp-proceedings.com/proc/p2015/SER3465.pdf

7. https://it-cisq.org/standards/code-quality-standards/

8. https://www.iso.org/obp/ui/#iso:std:iso-iec:25010:ed-1:v1:en

9. https://www.ibm.com/developerworks/rational/library/4706.html#N100A7

10. http://www.users.abo.fi/lpetre/SA11/SALecture2.pdf

11. https://resources.sei.cmu.edu/asset_files/TechnicalReport/2007_005_001_14858.pdf

12. https://resources.sei.cmu.edu/asset_files/TechnicalReport/2009_005_001_15101.pdf

Comments

Post a Comment

Popular posts from this blog

Example 1: ArchiMate relationship in PlantUML code to demonstrate 15 relationship types

 Following section presents 15 types of relationships in ArchiMate and PlantUML to generate the diagram. Since this code is generated by GEN-AI it may require precision on aspects other than PlantUML syntax: Diagram Plant UML Code:  @startuml '!includeurl https://raw.githubusercontent.com/plantuml-stdlib/Archimate-PlantUML/master/Archimate.puml ' Another way of including Archimate Library (above is commented for following) !include <archimate/Archimate> !theme archimate-standard from https://raw.githubusercontent.com/plantuml-stdlib/Archimate-PlantUML/master/themes title ArchiMate Relationships Overview <style> element{     HorizontalAlignment: left;     MinimumWidth : 180;     Padding: 25; } </style> left to right direction rectangle Other {     Business_Role(Role_SeniorManager, "Senior Manager")     Business_Role(Role_Manager, "Manager") } rectangle Dynamic {     Business_Event(Event_CustomerReques...
Post a Comment
Read more

Examples 7: ArchiMate flow relationship between elements in layers

Diagram Code @startuml !include < archimate / Archimate > < style > element {     HorizontalAlignment : left ;     MinimumWidth : 180 ;     Padding : 20 ; } note {     BackgroundColor : #FFFFCC ;     RoundCorner : 5 ;     MaximumWidth : 250 ; } </ style > title "ArchiMate 3.2 Valid Flow Relationships" left to right direction ' Business Layer Flow Relationships rectangle "Business Layer Flows" {     Business_Process ( bp1 , "Order Process" )     Business_Process ( bp2 , "Payment Process" )     Rel_Flow ( bp1 , bp2 , "Order data" )     note on link         Flow between Business Processes     end note         Business_Function ( bf1 , "Sales Function" )     Business_Function ( bf2 , "Delivery Function" )     Rel_Flow ( bf1 , bf2 , "Sales information" )     note on link     ...
Post a Comment
Read more

SmartSimpleTextGenerator: A Smarter Way to Generate Text

  Introduction In the world of text generation, simple n-gram models can produce decent results, but they often lack context-awareness and coherence. To address these limitations, I have developed SmartSimpleTextGenerator , an improved version of my previous project, ImprovedSimpleTextGenerator . This new version enhances the text generation process by integrating Part-of-Speech (POS) tagging , n-gram models , and a back-off strategy , making the generated text more meaningful and contextually relevant. Key Features of SmartSimpleTextGenerator ✅ N-Gram Model with POS Tagging – Uses trigrams (default n=3) and applies POS tagging for better word prediction. ✅ Back-off Strategy – If a trigram sequence is unavailable, it falls back to bigrams and unigrams to ensure smooth text generation. ✅ Sentence Tokenization & Structure Preservation – Tokenizes input text properly while maintaining sentence integrity. ✅ Randomized Word Selection – Generates diverse outputs rather ...
Post a Comment
Read more