SoftwareArchitecture

Extracted and adapted from http://www.bredemeyer.com/pdf_files/ArchitectureDefinition.PDF

http://www.jiludwig.com/reiber/requirements_trace.html

Architecture Views

Conceptual Architecture

The Conceptual Architecture identifies the high-level components of the system, and the relationships among them. Its purpose is to direct attention at an appropriate decomposition of the system without delving into details.

Goals:

identification of components
allocation of responsibilities to components

Logical Architecture

In Logical Architecture, the externally visible properties of the components are made precise and unambiguous through well-defined interfaces and component specifications, and key architectural mechanisms are detailed.

Goals:

design of component interactions, connection mechanisms and protocols (exchanged messages);
interface design and specification; providing contextual information for component users

Execution Architecture

An Execution Architecture is created for distributed or concurrent systems. The process view shows the mapping of components onto the processes of the physical system, with attention being focused on such concerns as throughput and scalability.

assignment of the runtime component instances to processes,threads and address spaces;
how they communicate and coordinate;
how physical resources are allocated to them

UML simple steps

Reference: http://www.sparxsystems.com/resources/tutorial/uml_tutorial2.html

Steps:

Create use cases based on the user goals and how those goals are achieved by interacting with the system
Detail each use case with a best case scenario
With the details of the use cases, begin to construct a domain model (high level business objects), sequence diagrams, collaboration/communication diagrams and user interface models. These describe the 'things' in the new system, the way those things interact and the interface a user will use to execute use case scenarios.
With the domain model start to create a class model.
The class model is a precise specification of the objects in the system, their data or attributes and their behaviour or operations.
A component represents a deployable chunk of software that collects the behaviour and data of one or more classes and exposes a strict interface to other consumers of its services. So from the Class Model a Component Model is built to define the logical packaging of classes.

http://agilemodeling.com/essays/agileArchitecture.htm

http://www.sparxsystems.com.au/resources/uml2_tutorial/

http://agilemodeling.com/artifacts/useCaseDiagram.htm

http://agilemodeling.com/artifacts/crcModel.htm

http://agilemodeling.com/artifacts/robustnessDiagram.htm

Recipe 1 - Unified Process - UML - Use case driven

SSD (System Sequence Diagram) Use cases - Behavioral Requirements

Identify use cases and create use case diagrams
detail textually each use case (create use case detail)
Create class diagram for domain model with only class names based on use case detail
Create sequence/communication diagrams (SSD - 1st should be the System Sequence Diagram) that realizes/illustrates the use case
Refine the classes diagram with the operations and attributes found in the sequence/communication diagram

Use case:
Actors:
Goals:
Main scenario
1. The system ...
2. The user ...

Use case add numbers

@startuml
actor user
boundary system

system -> user : prompts first number
user -> system : inputs the first number
system -> user : prompts for the second number
user -> system : inputs the second number
system -> user : shows the sum of the two numbers
@enduml

   1 '''
   2 Use case: Add numbers
   3 Actors: User
   4 Goals: Add two numbers
   5 Main scenario:
   6 1. The system prompts for the first number
   7 2. The user inputs the first number
   8 3. The system prompts for the second number
   9 4. The user inputs the second number
  10 5. The system shows the sum of the two numbers 
  11 
  12 Extensions:
  13 2.a   The first number is invalid
  14 2.a.1 The system shows the message "Please check the inputed value for the first value"
  15 2.a.2 The use case continues at step 1
  16 
  17 4.a   The second number is invalid
  18 4.a.1 The system shows the message "Please check the inputed value for the second value"
  19 4.a.2 The use case continues at step 3
  20  
  21 Postcondition: two numbers are added
  22 '''
  23 # python useCaseAdd.py
  24 def readNumber(prompt,exceptionMessage):
  25     gotValue=False
  26     value=0
  27     while(gotValue==False):
  28         try:
  29             value = int( input(prompt) )
  30             gotValue=True
  31         except Exception as ex:
  32             print(exceptionMessage)
  33     return value
  34     
  35 first = readNumber('FirstNumber: ','Please check the inputed value for the first value')            
  36 second = readNumber('Second number: ','Please check the inputed value for the second value') 
  37 print('The sum is %d'%(first + second))

Add numbers SSD example

PlantUML online server: http://www.plantuml.com/plantuml/

@startuml
actor user
boundary system
control business

loop while first number is invalid
  system -> user : prompts first number
  user -> system : inputs the first number

  alt success
    system -> user : First number is valid
  else invalid first number
    system -> user : Please check the inputed value for the first value
  end
end

loop while second number is invalid
  system -> user : prompts second number
  user -> system : inputs the second number

  alt success
    system -> user : second number is valid
  else invalid second number
    system -> user : Please check the inputed value for the second value
  end
end
system -> business : add(first,second)
business --> system : sum
system -> user : shows the sum of the two numbers
@enduml

Functional requirements (High level)

Define a high level API, design by contract, interface for the whole system.

Just one service with a lot of methods that help fullfil the use cases.

Developer point of view.

Functional requirement addNumber

In the above diagram the functional requirement FR is the add function that return a sum.

add(first:int,second:int):int

The system must be able to add two numbers and return the sum result.

SSD (System Sequence Diagram) implementation examples

ssdBoundary.py

   1 #!/usr/bin/python3
   2 """
   3 All logic still in boundary/UI
   4 """
   5 class Entity:
   6     """ """
   7     def __init__(self):
   8         pass    
   9     
  10 class Boundary:
  11     """ """
  12     def __init__(self):
  13         pass 
  14     
  15 class Credencial(Entity):
  16     """ """
  17     def __init__(self,utilizador,password):
  18         """ """
  19         self.utilizador = utilizador
  20         self.password = password
  21 
  22 class Menu(Entity):
  23     def __init__(self,nome):
  24         """ """
  25         self.nome=nome
  26         self.opcoes=[]
  27         
  28     def adicionarOpcao(self,opcao):
  29         """ """
  30         self.opcoes.append(opcao)
  31         
  32     def getOpcoes(self):
  33         """ """
  34         return self.opcoes
  35         
  36 class Opcao(Entity):
  37     def __init__(self,nome,callback):
  38         """ """
  39         self.nome=nome
  40         self.callback = callback
  41 
  42 class Cotacao(Entity):
  43     def __init__(self,nome,valor,data):
  44         """ """
  45         self.nome=nome
  46         self.valor=valor
  47         self.data=data
  48     
  49     def __repr__(self):
  50         """ """
  51         return '%s %s %f'%(self.data, self.nome, self.valor)
  52     
  53 class UI(Boundary):
  54     def __init__(self):
  55         """ """
  56         self.menu=Menu('Menu')
  57         self.menu.adicionarOpcao(Opcao('Cotações',self.cotacoes))
  58         self.menu.adicionarOpcao(Opcao('Análises',self.analises))
  59         self.menu.adicionarOpcao(Opcao('Sair',self.sair))
  60         
  61         self.credenciais=[]
  62         self.credenciais.append( Credencial('vitor','12345678') )
  63         self.credenciais.append( Credencial('calvin','wally') )
  64         
  65         self.cotacoes=[]
  66         self.cotacoes.append(Cotacao('YHOO',1,'2016-01-02'))
  67         self.cotacoes.append(Cotacao('CSCO',1,'2016-01-02'))
  68         self.cotacoes.append(Cotacao('YHOO',2,'2016-01-03'))
  69         self.cotacoes.append(Cotacao('CSCO',2,'2016-01-03'))
  70 
  71         
  72     def pedirCredenciais(self):
  73         """ """
  74         print('Insira as suas credenciais')
  75         print('Utilizador:')
  76         utilizador = input()
  77         print('Password:')
  78         password = input()
  79         return Credencial(utilizador,password)
  80     
  81     def validarCredenciais(self,credencial):
  82         """ """
  83         found=False
  84         for c in self.credenciais:
  85             if(credencial.utilizador==c.utilizador and credencial.password==c.password):
  86                 found=True
  87                 
  88         if found:
  89             print('Credenciais válidas')
  90             return True            
  91         else:
  92             print('Credenciais inválidas')
  93             return False
  94             
  95     def mostrarMenu(self):
  96         for opcao in self.menu.getOpcoes():
  97             print(' %s'%(opcao.nome))
  98         opcao=input()
  99         selOpcao=None
 100         for o in self.menu.getOpcoes():
 101             if o.nome==opcao:
 102                 selOpcao=o
 103         return selOpcao
 104     
 105     def cotacoes(self):
 106         print('Menu Cotações')
 107         cots=[]
 108         for c in self.cotacoes:
 109             if c.nome not in cots:
 110                 cots.append(c.nome)
 111                 print(c.nome)
 112         print('Escolha a cotação')
 113         cotacao=input()
 114         #mostrar cotacões para acção escolhida
 115         for c in self.cotacoes:
 116             if c.nome == cotacao:
 117                 print(c)
 118         
 119     def analises(self):
 120         print('Menu Análises')
 121     
 122     def sair(self):
 123         exit(0)
 124     
 125 if __name__=='__main__':
 126     ui = UI()
 127     credencial = ui.pedirCredenciais()
 128     resultado = ui.validarCredenciais(credencial)
 129     
 130     if resultado==True:
 131         opcao = ui.mostrarMenu()
 132         opcao.callback()

ssdControl.py

   1 #!/usr/bin/python3
   2 """
   3 All logic in control/service classes 
   4 """
   5 class Entity:
   6     """ Model """
   7     def __init__(self):
   8         pass    
   9     
  10 class Boundary:
  11     """ View """
  12     def __init__(self):
  13         pass 
  14 
  15 class Control:
  16     """ Business Logic - Controller """
  17     def __init__(self):
  18         pass 
  19     
  20 class Credencial(Entity):
  21     """ """
  22     def __init__(self,utilizador,password):
  23         """ """
  24         self.utilizador = utilizador
  25         self.password = password
  26 
  27 class Menu(Entity):
  28     def __init__(self,nome):
  29         """ """
  30         self.nome=nome
  31         self.opcoes=[]
  32         
  33     def adicionarOpcao(self,opcao):
  34         """ """
  35         self.opcoes.append(opcao)
  36         
  37     def getOpcoes(self):
  38         """ """
  39         return self.opcoes
  40         
  41 class Opcao(Entity):
  42     def __init__(self,nome,callback):
  43         """ """
  44         self.nome=nome
  45         self.callback = callback
  46 
  47 class Cotacao(Entity):
  48     def __init__(self,nome,valor,data):
  49         """ """
  50         self.nome=nome
  51         self.valor=valor
  52         self.data=data
  53     
  54     def __repr__(self):
  55         """ """
  56         return '%s %s %f'%(self.data, self.nome, self.valor)
  57     
  58 class ControloCredencial(Control):
  59     def __init__(self):
  60         self.credenciais=[]
  61         self.credenciais.append( Credencial('vitor','********') )
  62         self.credenciais.append( Credencial('calvin','*') )
  63         
  64     def validarCredenciais(self,credencial):
  65         """ """
  66         found=False
  67         for c in self.credenciais:
  68             if(credencial.utilizador==c.utilizador and credencial.password==c.password):
  69                 found=True
  70                 
  71         if found:
  72             print('Credenciais válidas')
  73             return True            
  74         else:
  75             print('Credenciais inválidas')
  76             return False
  77 
  78 class ControloCotacoes(Control):
  79     def __init__(self):
  80         """ """
  81         self.cotacoes=[]
  82         self.cotacoes.append(Cotacao('YHOO',1,'2016-01-02'))
  83         self.cotacoes.append(Cotacao('CSCO',1,'2016-01-02'))
  84         self.cotacoes.append(Cotacao('YHOO',2,'2016-01-03'))
  85         self.cotacoes.append(Cotacao('CSCO',2,'2016-01-03'))
  86         
  87     def obterNomesAccoes(self):
  88         """ """
  89         accoes=[]
  90         for c in self.cotacoes:
  91             if c.nome not in accoes:
  92                 accoes.append(c.nome)
  93         return accoes
  94     
  95     def obterCotacoesParaAccao(self,accao):
  96         """ """
  97         cotacoesPorAccao=[]
  98         for c in self.cotacoes:
  99             if c.nome == accao:
 100                 cotacoesPorAccao.append(c)
 101         return cotacoesPorAccao
 102 
 103 class ControloMenus(Control):
 104     def __init__(self):
 105         """ """
 106         self.menu=Menu('Menu')
 107         self.menu.adicionarOpcao(Opcao('Cotações','cotacoes'))
 108         self.menu.adicionarOpcao(Opcao('Análises','analises'))
 109         self.menu.adicionarOpcao(Opcao('Sair','sair'))
 110         
 111     def getMenu(self):    
 112         """ """
 113         return self.menu
 114     
 115     def obterOpcaoPorNome(self,nomeOpcao):
 116         """ """
 117         selOpcao=None
 118         for o in self.menu.getOpcoes():
 119             if o.nome==nomeOpcao:
 120                 selOpcao=o
 121         return selOpcao
 122         
 123 class UI(Boundary):
 124     """ Lembrar de SSD System Sequence Diagram/Black Box"""
 125     def __init__(self):
 126         """ """
 127         self.controloMenus = ControloMenus()
 128         self.controloCredencial = ControloCredencial()
 129         self.controloCotacoes = ControloCotacoes()
 130         
 131     def pedirCredenciais(self):
 132         """ """
 133         print('Insira as suas credenciais')
 134         print('Utilizador:')
 135         utilizador = input()
 136         print('Password:')
 137         password = input()
 138         return Credencial(utilizador,password)   
 139     
 140     def validarCredenciais(self,credencial):
 141         """ """
 142         return self.controloCredencial.validarCredenciais(credencial)
 143         
 144     def mostrarMenu(self):
 145         for opcao in self.controloMenus.getMenu().getOpcoes():
 146             print(' %s'%(opcao.nome))
 147         opcao=input()
 148         
 149         selOpcao=self.controloMenus.obterOpcaoPorNome(opcao)
 150         mapa={'cotacoes':self.cotacoes,'analises':self.analises,'sair':self.sair}
 151         # define referencia de metodo conforme o nome de callback
 152         selOpcao.callback = mapa[selOpcao.callback]
 153         return selOpcao
 154     
 155     def cotacoes(self):
 156         print('Menu Cotações')
 157 
 158         for nomeAccao in self.controloCotacoes.obterNomesAccoes(): 
 159             print(nomeAccao)
 160             
 161         print('Escolha a cotação')
 162         cotacao=input()
 163         for c in self.controloCotacoes.obterCotacoesParaAccao(cotacao):
 164             print(c)
 165         
 166     def analises(self):
 167         print('Menu Análises')
 168     
 169     def sair(self):
 170         exit(0)
 171     
 172 if __name__=='__main__':
 173     ui = UI()
 174     credencial = ui.pedirCredenciais()
 175     resultado = ui.validarCredenciais(credencial)
 176     
 177     if resultado==True:
 178         opcao = ui.mostrarMenu()
 179         opcao.callback()

SOLID

https://en.wikipedia.org/wiki/SOLID

Single responsibility principle

a class should have only a single responsibility

Open/closed principle

open for extension, but closed for modification. Decorator pattern add new responsibilities, behavior. final class java. sealed csharp class.

Liskov substitution principle

design by contract using interfaces, have loose coupling by using interfaces

Interface segregation principle

"many client-specific interfaces are better than one general-purpose interface."

Dependency inversion principle

depend upon abstractions (abstract classes or interfaces) not concrete stuff

Software design patterns

Singleton

Ensure a class has only one instance, and provide a global point of access to it

Decorator

Attach additional responsibilities to an object dynamically keeping the same interface. Decorators provide a flexible alternative to subclassing for extending functionality. (SOLID O principle, open for extension closed for modification

Iterator

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation. next() method. IEnumerable in Csharp. linked list, double linked list.

Memento

capture and externalize an object's internal state allowing the object to be restored to this state later. persist state and restore later (history state, undo).

Null object

Avoid null references by providing a default object. (Java8 Optional<T>, Csharp Nullable<T> )

Observer or Publish/subscribe

Define a one-to-many dependency between objects where a state change in one object results in all its dependents being notified and updated automatically. attach() notify() update()

Strategy

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it. sorting algorhitms, hide used algorithm quicksort