= 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
}}}

{{{#!highlight python
'''
Use case: Add numbers
Actors: User
Goals: Add two numbers
Main scenario:
1. The system prompts for the first number
2. The user inputs the first number
3. The system prompts for the second number
4. The user inputs the second number
5. The system shows the sum of the two numbers 

Extensions:
2.a   The first number is invalid
2.a.1 The system shows the message "Please check the inputed value for the first value"
2.a.2 The use case continues at step 1

4.a   The second number is invalid
4.a.1 The system shows the message "Please check the inputed value for the second value"
4.a.2 The use case continues at step 3
 
Postcondition: two numbers are added
'''
# python useCaseAdd.py
def readNumber(prompt,exceptionMessage):
    gotValue=False
    value=0
    while(gotValue==False):
        try:
            value = int( input(prompt) )
            gotValue=True
        except Exception as ex:
            print(exceptionMessage)
    return value
    
first = readNumber('FirstNumber: ','Please check the inputed value for the first value')            
second = readNumber('Second number: ','Please check the inputed value for the second value') 
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
}}}

{{attachment:addNumbersSSD.png}}

== 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
{{{#!highlight python
#!/usr/bin/python3
"""
All logic still in boundary/UI
"""
class Entity:
    """ """
    def __init__(self):
        pass    
    
class Boundary:
    """ """
    def __init__(self):
        pass 
    
class Credencial(Entity):
    """ """
    def __init__(self,utilizador,password):
        """ """
        self.utilizador = utilizador
        self.password = password

class Menu(Entity):
    def __init__(self,nome):
        """ """
        self.nome=nome
        self.opcoes=[]
        
    def adicionarOpcao(self,opcao):
        """ """
        self.opcoes.append(opcao)
        
    def getOpcoes(self):
        """ """
        return self.opcoes
        
class Opcao(Entity):
    def __init__(self,nome,callback):
        """ """
        self.nome=nome
        self.callback = callback

class Cotacao(Entity):
    def __init__(self,nome,valor,data):
        """ """
        self.nome=nome
        self.valor=valor
        self.data=data
    
    def __repr__(self):
        """ """
        return '%s %s %f'%(self.data, self.nome, self.valor)
    
class UI(Boundary):
    def __init__(self):
        """ """
        self.menu=Menu('Menu')
        self.menu.adicionarOpcao(Opcao('Cotações',self.cotacoes))
        self.menu.adicionarOpcao(Opcao('Análises',self.analises))
        self.menu.adicionarOpcao(Opcao('Sair',self.sair))
        
        self.credenciais=[]
        self.credenciais.append( Credencial('vitor','12345678') )
        self.credenciais.append( Credencial('calvin','wally') )
        
        self.cotacoes=[]
        self.cotacoes.append(Cotacao('YHOO',1,'2016-01-02'))
        self.cotacoes.append(Cotacao('CSCO',1,'2016-01-02'))
        self.cotacoes.append(Cotacao('YHOO',2,'2016-01-03'))
        self.cotacoes.append(Cotacao('CSCO',2,'2016-01-03'))

        
    def pedirCredenciais(self):
        """ """
        print('Insira as suas credenciais')
        print('Utilizador:')
        utilizador = input()
        print('Password:')
        password = input()
        return Credencial(utilizador,password)
    
    def validarCredenciais(self,credencial):
        """ """
        found=False
        for c in self.credenciais:
            if(credencial.utilizador==c.utilizador and credencial.password==c.password):
                found=True
                
        if found:
            print('Credenciais válidas')
            return True            
        else:
            print('Credenciais inválidas')
            return False
            
    def mostrarMenu(self):
        for opcao in self.menu.getOpcoes():
            print(' %s'%(opcao.nome))
        opcao=input()
        selOpcao=None
        for o in self.menu.getOpcoes():
            if o.nome==opcao:
                selOpcao=o
        return selOpcao
    
    def cotacoes(self):
        print('Menu Cotações')
        cots=[]
        for c in self.cotacoes:
            if c.nome not in cots:
                cots.append(c.nome)
                print(c.nome)
        print('Escolha a cotação')
        cotacao=input()
        #mostrar cotacões para acção escolhida
        for c in self.cotacoes:
            if c.nome == cotacao:
                print(c)
        
    def analises(self):
        print('Menu Análises')
    
    def sair(self):
        exit(0)
    
if __name__=='__main__':
    ui = UI()
    credencial = ui.pedirCredenciais()
    resultado = ui.validarCredenciais(credencial)
    
    if resultado==True:
        opcao = ui.mostrarMenu()
        opcao.callback()

}}}

ssdControl.py
{{{#!highlight python
#!/usr/bin/python3
"""
All logic in control/service classes 
"""
class Entity:
    """ Model """
    def __init__(self):
        pass    
    
class Boundary:
    """ View """
    def __init__(self):
        pass 

class Control:
    """ Business Logic - Controller """
    def __init__(self):
        pass 
    
class Credencial(Entity):
    """ """
    def __init__(self,utilizador,password):
        """ """
        self.utilizador = utilizador
        self.password = password

class Menu(Entity):
    def __init__(self,nome):
        """ """
        self.nome=nome
        self.opcoes=[]
        
    def adicionarOpcao(self,opcao):
        """ """
        self.opcoes.append(opcao)
        
    def getOpcoes(self):
        """ """
        return self.opcoes
        
class Opcao(Entity):
    def __init__(self,nome,callback):
        """ """
        self.nome=nome
        self.callback = callback

class Cotacao(Entity):
    def __init__(self,nome,valor,data):
        """ """
        self.nome=nome
        self.valor=valor
        self.data=data
    
    def __repr__(self):
        """ """
        return '%s %s %f'%(self.data, self.nome, self.valor)
    
class ControloCredencial(Control):
    def __init__(self):
        self.credenciais=[]
        self.credenciais.append( Credencial('vitor','********') )
        self.credenciais.append( Credencial('calvin','*') )
        
    def validarCredenciais(self,credencial):
        """ """
        found=False
        for c in self.credenciais:
            if(credencial.utilizador==c.utilizador and credencial.password==c.password):
                found=True
                
        if found:
            print('Credenciais válidas')
            return True            
        else:
            print('Credenciais inválidas')
            return False

class ControloCotacoes(Control):
    def __init__(self):
        """ """
        self.cotacoes=[]
        self.cotacoes.append(Cotacao('YHOO',1,'2016-01-02'))
        self.cotacoes.append(Cotacao('CSCO',1,'2016-01-02'))
        self.cotacoes.append(Cotacao('YHOO',2,'2016-01-03'))
        self.cotacoes.append(Cotacao('CSCO',2,'2016-01-03'))
        
    def obterNomesAccoes(self):
        """ """
        accoes=[]
        for c in self.cotacoes:
            if c.nome not in accoes:
                accoes.append(c.nome)
        return accoes
    
    def obterCotacoesParaAccao(self,accao):
        """ """
        cotacoesPorAccao=[]
        for c in self.cotacoes:
            if c.nome == accao:
                cotacoesPorAccao.append(c)
        return cotacoesPorAccao

class ControloMenus(Control):
    def __init__(self):
        """ """
        self.menu=Menu('Menu')
        self.menu.adicionarOpcao(Opcao('Cotações','cotacoes'))
        self.menu.adicionarOpcao(Opcao('Análises','analises'))
        self.menu.adicionarOpcao(Opcao('Sair','sair'))
        
    def getMenu(self):    
        """ """
        return self.menu
    
    def obterOpcaoPorNome(self,nomeOpcao):
        """ """
        selOpcao=None
        for o in self.menu.getOpcoes():
            if o.nome==nomeOpcao:
                selOpcao=o
        return selOpcao
        
class UI(Boundary):
    """ Lembrar de SSD System Sequence Diagram/Black Box"""
    def __init__(self):
        """ """
        self.controloMenus = ControloMenus()
        self.controloCredencial = ControloCredencial()
        self.controloCotacoes = ControloCotacoes()
        
    def pedirCredenciais(self):
        """ """
        print('Insira as suas credenciais')
        print('Utilizador:')
        utilizador = input()
        print('Password:')
        password = input()
        return Credencial(utilizador,password)   
    
    def validarCredenciais(self,credencial):
        """ """
        return self.controloCredencial.validarCredenciais(credencial)
        
    def mostrarMenu(self):
        for opcao in self.controloMenus.getMenu().getOpcoes():
            print(' %s'%(opcao.nome))
        opcao=input()
        
        selOpcao=self.controloMenus.obterOpcaoPorNome(opcao)
        mapa={'cotacoes':self.cotacoes,'analises':self.analises,'sair':self.sair}
        # define referencia de metodo conforme o nome de callback
        selOpcao.callback = mapa[selOpcao.callback]
        return selOpcao
    
    def cotacoes(self):
        print('Menu Cotações')

        for nomeAccao in self.controloCotacoes.obterNomesAccoes(): 
            print(nomeAccao)
            
        print('Escolha a cotação')
        cotacao=input()
        for c in self.controloCotacoes.obterCotacoesParaAccao(cotacao):
            print(c)
        
    def analises(self):
        print('Menu Análises')
    
    def sair(self):
        exit(0)
    
if __name__=='__main__':
    ui = UI()
    credencial = ui.pedirCredenciais()
    resultado = ui.validarCredenciais(credencial)
    
    if resultado==True:
        opcao = ui.mostrarMenu()
        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 ==
 * https://en.wikipedia.org/wiki/Software_design_pattern
 * https://en.wikipedia.org/wiki/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