Please enable JavaScript.

Coggle requires JavaScript to display documents.

NHOM 3_1 - Coggle Diagram

- - - - employing decomposition
      - composition
      - architecture
        styles
      - quality attributes
    - - Box-and-line diagrams
        
        Lines may be associated with arrows to indicate the process direction
        and sequence
        
        Use to
        
        descriptions of components
        and connectors
        
        describe the business concepts and
        processes during the analysis phase of the software development lifecycle
        
        to understand the business concepts and to derive other software modeling and design diagrams such as
        UML
        
        is one of the object-oriented solutions used in software modeling and design.
        
        descriptions that provide common intuitive interpretations
  - - - visualizing
      - specifying
      - constructing
      - documenting the artifacts
        of a software-intensive system
    - - including conceptual notions
        
        business
        processes
        
        system functions as well as concrete designs
        
        programming language statements
        
        database schemas
        
        reusable software components
    - - model the problem domain
      - describe the user requirements
      - identify significant architecture elements during software design
        
        classes
        
        objects
      - describe behavior and interactions among these elements;
      - organize the software structure
        
        its constraints
        
        describe the necessary attributes
    - - Structural (Static) Diagrams
        
        Class Diagram
        
        derived from use-case diagrams or from text analysis of the given problem domain
        
        generated
        
        system analysts
        
        designers
        
        iteratively refined in the subsequent phases during the software development
        
        Package
        
        represented by a tabbed folder that indicates where all included classes and subpackages reside.
        
        play a similar role as a directory for grouping files in a file system
        
        allow the organization of all closely related classes in one “container.”
        
        shows the dependency relationship between packages in which a change of one package may result in changes
        in other packages.
        
        specify the contents of a package, i.e., the classes that constitute a package and their relationships
        
        reduce the dependency complexity and simplify relationships among groups of classes
        
        Deployment
        
        depicts the physical configuration of the software system deployed on hardware server nodes and the network between the nodes
        
        generated in the later phase of the software development life cycle
        
        Component
        
        neither a class nor an object
        
        a deployable, reusable building block used in software design and
        development
        
        Each component has an interface to expose its services and hide its implementations.
        
        The interface is the contract between a reusable component and its clients
      - Behavioral (Dynamic) Diagrams
        
        Use Case Diagram
        
        describe user requirements in terms of system functionality a contract between the users (actors) and the
        software system
        
        describes
        
        a set of scenarios
        
        scenarios may have a set of subordinate
        
        lower-level, use cases
        
        used in the early stages of the software development life cycle, such as analysis and design
        
        use case diagrams to capture and verify user requirements
        
        Activity Diagram
        
        describe complex business processes
        
        a workflow-oriented diagram describing the steps in a single process
        
        use a rounded rectangle to represent an activity
        
        has a starting point and one or more
        finishing points
        
        gives
        
        a detailed dynamic view of a specific task
        
        process within a system so that the software developer
        
        easily recognize the implementation requirements
        
        State Machine Diagram
        
        used for embedded systems and device software analysis and design
        
        is an event-oriented diagram
        
        a state is a rounded rectangle with three subdivisions: state name, state variables, and state activities
        
        A complex composite state may have a subordinate state diagra
        
        help software
        developers understand how a system responds and handles external events and the corresponding event-triggering condition
        
        Sequence Diagram
        
        is a time-oriented interaction diagram showing the chronological sequence of messages between objects
        
        Each participant object
        
        has a vertical timeline for its life cycle
        
        Time goes forward along with the downward timeline
        
        Each vertical timeline
        
        has a number of narrow rectangular boxes (called activations) representing the object-activated state in which it
        receives or sends out messages
        
        Each activation box
        
        have a self-recursive directed link pointed back to itself, indicating that the object passes messages to itself
        
        An activation may also branch or fork many separate lifelines for the if-selection scenario conditions; eventually all forked lines will join together
  - - - describes the functionality of the system
        
        how the user employs the system and how the system provides
        services to the users
        
        helps to make the software architecture consistent with functional and nonfunctional requirements.
      - used to drive architecture design in the earlier phases of software development
      - used for software validation at later phases of the development cycle
    - - based on application domain entities necessary to implement the functional requirements
      - typically used for object-oriented (OO) modeling from which the static and dynamic system structures emerge.
      - specifies system decomposition into conceptual entities and connections between them
      - helps to understand the interactions between entities in the problem space domain of the application and their
        potential variation
      - points out all major tasks the system must complete, and presents the major components and their static
        relationships
    - - derives from the logical view and describes the static organization of the system modules
        
        namespaces
        
        class library
        
        subsystem
        
        packages are building blocks that group classes for further development and
        implementation
      - the subsystem decomposition and organizational issue
      - maps software component elements to actual physical directories and files
    - - focuses on the dynamic aspects of the system, i.e., its execution time behavior
      - derives from the logical view
      - looks at the system's processes and the communications among them.
      - maps functions, activities, and interactions onto runtime implementation with a focus on nonfunctional requirements as well as the implementation of the functional requirements.
      - The process view takes care of the concurrency and synchronization issues between subsystems
      - address nonfunctional requirements such as multithreading and synchronous/asynchronous communications for performance and availability
    - - describes installation, configuration, and deployment of the software application
      - concerns itself with how to deliver the deploy-able system.
      - shows the mapping of software onto hardware. It is particularly of interest in distributed or parallel systems
      - A physical view also takes into account the system's nonfunctional requirements such as system availability, reliability (fault-tolerance), throughput performance, scalability performance, and security.
    - - is an extended view that provides a clear user-computer interface view and hides implementation details.
- - - - It's now time for the O in SOLID, known as the open-closed principle. Simply put, classes should be open for extension but closed for modification.
      - In doing so, we stop ourselves from modifying existing code and causing potential new bugs in an otherwise happy application.
      - Software entities (e.g., classes, modules, functions) should be open for an extension, but closed for modification.
      - the one exception to the rule is when fixing bugs in existing code.
    - - The Liskov Substitution Principle (LSP) applies to inheritance hierarchies such that derived classes must be completely substitutable for their base classes.
      - Simply put, if class A is a subtype of class B, we should be able to replace B with A without disrupting the behavior of our program.
    - - Every class in Java should have a single job to do. To be precise, there should only be one reason to change a class
      - This principle states that a class should only have one responsibility. Furthermore, it should only have one reason to change.
      - Let's see a few of its benefits:
        
        Lower coupling – Less functionality in a single class will have fewer dependencies.
        
        Organization – Smaller, well-organized classes are easier to search than monolithic ones.
        
        Testing – A class with one responsibility will have far fewer test cases.
    - - The I in SOLID stands for interface segregation, and it simply means that larger interfaces should be split into smaller ones. By doing so, we can ensure that implementing classes only need to be concerned about the methods that are of interest to them.
    - - The principle of dependency inversion refers to the decoupling of software modules. This way, instead of high-level modules depending on low-level modules, both will depend on abstractions.
  - - - It is defined as the wrapping up of data under a single unit. It is the mechanism that binds together code and the data it manipulates.
      - Another way to think about encapsulation is, it is a protective shield that prevents the data from being accessed by the code outside this shield
      - Technically in encapsulation, the variables or data of a class is hidden from any other class and can be accessed only through any member function of own class in which they are declared.
      - As in encapsulation, the data in a class is hidden from other classes, so it is also known as data-hiding.
      - Encapsulation can be achieved by Declaring all the variables in the class as private and writing public methods in the class to set and get the values of variables.
    - - Inheritance is an important pillar of OOP(Object Oriented Programming). It is the mechanism in java by which one class is allow to inherit the features(fields and methods) of another class.
      - Let us discuss some of frequent used important terminologies:
        
        Super Class: The class whose features are inherited is known as superclass(or a base class or a parent class).
        
        Sub Class: The class that inherits the other class is known as subclass(or a derived class, extended class, or child class). The subclass can add its own fields and methods in addition to the superclass fields and methods.
        
        Reusability: Inheritance supports the concept of “reusability”, i.e. when we want to create a new class and there is already a class that includes some of the code that we want, we can derive our new class from the existing class. By doing this, we are reusing the fields and methods of the existing class.
    - - Data Abstraction is the property by virtue of which only the essential details are displayed to the user.The trivial or the non-essentials units are not displayed to the user.
      - Ex: A car is viewed as a car rather than its individual components.
      - In java, abstraction is achieved by interfaces and abstract classes. We can achieve 100% abstraction using interfaces.
      - Data Abstraction may also be defined as the process of identifying only the required characteristics of an object ignoring the irrelevant details. The properties and behaviours of an object differentiate it from other objects of similar type and also help in classifying/grouping the objects.
    - - It refers to the ability of OOPs programming languages to differentiate between entities with the same name efficiently. This is done by Java with the help of the signature and declaration of these entities.
      - Polymorphism in Java are mainly of 2 types:
        
        Overloading
        
        Overloading allows different methods to have the same name, but different signatures where the signature can differ by the number of input parameters or type of input parameters or both.
        
        Overriding
        
        In any object-oriented programming language, Overriding is a feature that allows a subclass or child class to provide a specific implementation of a method that is already provided by one of its super-classes or parent classes.
        
        When a method in a subclass has the same name, same parameters or signature, and same return type(or sub-type) as a method in its super-class, then the method in the subclass is said to override the method in the super-class.
- - - - A sample outline of SDD:
        
        Detailed design
        
        User interfaces
        
        Attributes
        
        Dependency and connection
        
        Decomposition description (module, data, and process)
        
        Design overview, purpose and scope
      - Describes high and low level design:
        
        Detailed information of each module
        
        Developer
        
        Operations
        
        Data attributes
        
        Modules of each components
        
        Components of the system
        
        DB oriented application - data dictionary:
        
        Tables, columns and definition of terms.
    - - Definition
        
        The fundamental organization of a system embodied in its,components, their relationships to each other, and to the,environment, and the principle guiding its design and evolution
      - Role of software architecture:
        
        Highlights early design decisions
        
        Shows how system is structured
        
        Covers functional and non-functional requirements
        
        Blueprint guideline for development
    - - What
        
        An architecture style (also known as an "architecture pattern") abstracts the common properties of a family of similar designs.
        
        It contains a set of rules, constraints, and patterns of how to structure a system into a set of elements and connectors
        
        It governs runtime interaction of flow control and data transfer.
      - Key components
        
        Elements that perform functions required by a system
        
        Connectors that enable communication, coordination, and cooperation among elements
        
        Constraints that define how elements are integrated to form the system
        
        Attributes that describe the advantages and disadvantages of the chosen structure
      - Purposes
        
        Saves cost and time on design
        
        Architecture style represents layout topology of elements
        
        Once overall structure determined, rest are easy
      - Some architecture styles
        
        Data Flow: Batch sequence, Pipe & Filter, Process Control
        
        Data Centered: Repository and Blackboard
        
        Object Oriented
        
        Hierarchy: Layered, Virtual Machine Main/Subroutine
        
        Asynchronous Communication: Event-Based, Buffered Messaging
        
        Interaction Oriented: MVC, PAC
    - - Two Steps in Software Design
        
        Architecture Design:
        
        Describe user accessible components and the interconnections
        among them that are visible to stakeholders
        
        Is front strategy for detailed design
        
        Detailed Design/Tactical Design
        
        Specify the internal details of each component and might
        introduce new invisible components to the stakeholders
      - Why software architecture design is important
        
        Good design:
        
        Makes the system traceable for implementation and testing, and
        leads to software products that have higher quality attributes.
        
        Helps development team works together in an orderly fashion
        
        Reduces the risks associated with software production
        
        Poor design:
        
        May result in deficient product (does not meet system
        requirements)
        
        Is not adaptive to future requirement changes
        
        Not reusable
        
        Exhibits unpredictable behaviour or perform badly
      - Architecture design developers
        
        • Jobs of Software Architect:
        
        System static partition and decomposition
        
        Establishing dynamic control between subsystems
        
        Considering and evaluating all alternative architectural styles
        
        Analysis of trade-off on quality attributes
        
        Software architect, software designer & system analyst:
        
        They map the software system requirements into architecture
        design
        
        They apply various design strategies to divide and conquer the
        complexities
      - What is architectural design?
        
        It defines the relationship between major structural elements
        
        It also define the styles and design patterns used to achieve
        requirements.
        
        Also the constraints that affects the way architecture can be
        implemented
    - - Implementation Attributes
        
        Maintainability & Extensibility: The ability to modify the system and conveniently extend it
        
        Testability: Whether the system allows easy debugging
        
        Scalability: Can system adapt to increase of requests
        
        Flexibility: Ease of modification of system to cater to a different environment
        
        Interoperability
        
        Requires loose dependency of infrastructure
        
        Universal accessibility and ability to exchange data among internal components and the outside world
      - Runtime Attributes
        
        Usability: Completeness, correctness, compatibility and user friendliness
        
        Performance: Time efficiency and resource efficiency
        
        Security: The ability to defend against attacks
        
        Availability:
        
        If system is available 24/7
        
        Can be enhanced by replication
      - Business Attributes
        
        Time to market: The time it takes from requirement analysis to the product is released
        
        Cost: Expense of the building, maintaining, and operating the system
        
        Lifetime: The period of time that the product is alive before retirement
    - - Think of What to Do before How to Do It
      - Think about abstract design before thinking about concrete design
      - Think of non-functional requirements early in design process
      - Think of reusability and extensibility
      - High Cohesion and Loose Coupling
      - Tolerate refinement of design
      - Avoid ambiguous design and over-detailed design
- - - - A software architect’s responsibility
        
        Proposing a concrete architecture that best supports:
        
        The detailed design
        
        Implementation
        
        Understand the software architecture's design space to
        design alternatives that can support functional and nonfunctional requirement specifications
        
        Make the decision by balancing on quality attributes
      - Software Structures
        
        Software architecture in multiple Perspectives
        
        Software Static Structure
        
        What & Role
        
        Definition: The software static structure refers to the organization
        of physical software modules and their interrelations
        
        Role
        
        This structure play a critical roles in software architecture design.
        
        Static structure affects the architecture's clarity, construction
        
        strategy, maintenance, reengineering, reusability…
        
        It plays a crucial role in the management of large software systems because it deals with the packaging of software modules in order to facilitate system construction and maintenance through a clear portrayal of intermodule relations.
        
        Component
        
        A software project is typically implemented in multiple files. This
        includes
        
        Executable files
        
        Library files
        
        Binary software component modules
        
        Deployment descriptors
        
        Others resources files
        
        At software development time
        
        The main software elements are source code files
        
        Each modules has assigned functional and nonfunctional attributes
        
        API defined for modules separates module’s interface and implementation
        
        The connectors at this level are in the form of module dependency
        
        Module A is connected to module B, if, A needs to invoke some methods in B during execution.
        
        At deployment time:
        
        The elements are binary versions of the project modules and files.
        
        Several source code modules may be packaged into the same deployment unit
        
        The connectors in the deployment structures are basically the same as those for the source module structures
        
        Managing Static Structural Representations
        
        Managing static structures involves layers of:
        
        Abstraction for encapsulation
        
        Refinement showing visibility
        
        Two kinds of static hierarchical relations:
        
        Linear client-server relation
        
        Tree-like hierarchy of refinement relation
        
        Software Run-time Structure
        
        Role
        
        Software runtime structures serve as the technical backbone of architecture designs and provide the basis from which other structures are derived.
        
        Element
        
        Processes
        
        Threads
        
        Web services
        
        Distributed objects
        
        Connector
        
        Multiplicity
        
        One element can be connected to multiple elements if it needs to
        invoke methods of multiple elements at runtime
        
        Distance and connection media:
        
        Two connected element may communicate in the same thread,in the same process , on the same computers, or on different computers across a network
        
        Copper/optical
        
        Wired/wireless LAN
        
        Decides the system performance and reliability
        
        Universal invocable:
        
        A connector with this attribute set to true allows any external software system to invoke the methods at the connector’s target, irrespective of
        hardware/software platform, and programming languages
        
        Important for heterogeneous system.
        
        Self-descriptive:
        
        A connector with this attribute set to true allows any external software system to invoke its target method without preinstallation of any software specific to the method
        
        It allows clients to choose service providers dynamically.
        
        Management structure (or Deployment
        structure)
        
        Different structures use different elements and connectors, and have different performance attributes
      - Software Elements
        
        At runtime, element is a self-contained component of a system
        
        Has well-defined functions
        
        Implementation can change with the time
        
        Usually interface is public and fixed, and
        
        Connected with each other via connector
        
        Software Architects Job
        
        Map functional requirements to software elements
        
        Some rules on designing software elements:
        
        Rule 1: Re-entrant
        
        Rule 2: Handle Bottleneck First
        
        Rule 3: Make Things Simple
      - Software Connector
        
        Definition & Properties
        
        Connects the modules of a system
        
        Should be refined within the design process.
        
        Connector refinement is heavily influenced by a project’s deployment environment
        
        Can be classified into many categories
        
        Usually determines the quality attributes of a system:
        
        Efficiency
        
        Reliability
        
        Availability
        
        Security
        
        Connector types – Based on synchronization
        
        Blocking
        
        A blocking connector allows one of its incident elements to send a request to another and wait for a response.
        
        The element will be blocked from further execution until it receives a response
        
        Non-blocking
        
        A non-blocking connector allows one of its incident elements to send a request to another and continues its execution without waiting for a response
        
        Connector types – Based on initiator
        
        Connector types – Based on information carrier
        
        Connector types – Based on implementation type
        
        Connector types – Based on connector’s active time
      - Agile Design
        
        Traditional Water-Fall Approach: big gap between
        requirement specification & software architecture
        
        Iterative Refinement: refine designs based on
        changing requirement
- - - - The purpose
        
        to reuse the subroutines
        
        have individual subroutines developed independently
      - typically data are shared by related subroutines at the same level
      - With object orientation
        
        the data is encapsulated in each individual object so that the information is protected
      - a software system
        
        decomposed into subroutines hierarchically refined according to the desired functionality of the system
      - Data is passed as parameters to subroutines from callers
        
        Pass by reference where the subroutine may change the value of data referenced by the parameter
        
        Pass by value where the subroutine only uses the passed data but cannot change it
      - a simple example of a purchase process requirement
        
        process #5 checks stock availability, while process #6 checks the customer credentials before making the invoice
        
        On the alternate path, process #7 checks the return policy
        
        To continue the transaction process #3 next selects one of the two different action paths;
        
        process #8 performs the refund transaction accordingly
        
        The data is forwarded to the next process (circle #2) which validates the request (either return or purchase), and if the request is invalid it is rejected and the customer is notified (circle #4).
        
        The process circle #1 receives requests from the customer and records all related information
      - Benefits:
        
        easy to decompose the system based on the definition of the tasks in a top-down refinement manner
        
        can still be used in a subsystem of OO design
      - Limitations:
        
        Globally shared data in classical main-subroutines introduces vulnerabilities.
        
        Tight coupling may cause more ripple effects of changes as compared to OO design
    - - is a variant of the main-subroutine architecture style that supports fault tolerance and system reliability
      - In this architecture
        
        slaves provide replicated services to the master
        
        the master selects a particular result among slaves by certain selection strategies
        
        The slaves may perform the same functional task
        
        by different algorithms and methods
        
        by a totally different functionality.
      - Other characteristics of this architecture
        
        parallel computing
        
        accuracy of computation
      - Since the same task is delegated to several different implementations, inaccurate results can be ruled out easily
        
        majority vote strategy
        
        other algorithms
      - Applicable domains of master-slave architecture
        
        used for the software system where reliability is critical
        
        due to the replication (redundancy) of servers.
        
        the terms master-slave or parent-child are employed to specify the dependency of one entity on another
        
        If the master node is deleted then the slave node has reason to stay
    - - Presentation layer
        
        to display information
        
        the screens with which users interact
        
        responsible for
        
        the structure
        
        styling
        
        interactivity of apps
        
        not responsible for enforcing business rules or storing data
        
        only communicates with the business logic layer to fetch information to display to users
        
        For example, a software application’s presentation layer may control the colour of headings for each pet’s breed and the ability to click on a pet to view more information.
      - Business logic layer
        
        is not responsible for displaying information or storing it
        
        coordinates the end-to-end process
        
        implements the business rules in a project
        
        communicates with both the presentation layer and the data layer.
        
        to enforce business rules
        
        For example, a software application’s business logic layer may determine that the application must show only 3-year-old labradors to a specific user based on their preferences.
      - Data layer
        
        The business logic layer accesses it to fetch (read) or save (create, update, delete) information
        
        For example, a software application’s data layer may store each pet’s details and images.
        
        to store information
    - - is built up on an existing system and provides a virtual abstraction, a set of attributes, and operations
      - In most cases a virtual machine separates a programming language or application environment from an execution platform
      - A virtual machine may appear similar to emulation software
      - JVM (Java Virtual Machine) Architecture
        
        is an abstract machine
        
        A specification where working of Java Virtual Machine is specified
        
        implementation provider is independent to choose the algorithm
        
        implementation has been provided by Oracle and other companies
        
        An implementation Its implementation is known as JRE (Java Runtime Environment)
        
        Runtime Instance Whenever you write java command on the command prompt to run the java class, an instance of JVM is created
        
        operation
        
        Verifies code
        
        Executes code
        
        Loads code
        
        Provides runtime environment
        
        provides definitions for the
        
        Register set
        
        Garbage-collected heap
        
        Class file format
        
        Fatal error reporting etc
        
        Memory area
        
        Classloader
        
        a subsystem of JVM which is used to load class files
        
        Whenever we run the java program, it is loaded first by the classloader
        
        There are three built-in classloaders in Java
        
        Bootstrap ClassLoader:
        
        loads the rt.jar file which contains all class files of Java Standard Edition
        
        java.lang package classes, java.net package classes, java.util package classes, java.io package classes, java.sql package classes etc
        
        Extension ClassLoader:
        
        is the child classloader of Bootstrap and parent classloader of System classloader
        
        loades the jar files located inside $JAVA_HOME/jre/lib/ext directory
        
        System/Application ClassLoader
        
        is the child classloader of Extension classloader
        
        loads the classfiles from classpath
        
        By default, classpath is set to current directory
        
        can change the classpath using "-cp" or "-classpath" switch
        
        Class(Method) Area
        
        stores per-class structures
        
        field
        
        method data
        
        the runtime constant pool
        
        the code for methods.
        
        Heap
        
        It is the runtime data area in which objects are allocated
        
        Stack
        
        holds local variables and partial results, and plays a part in method invocation and return
        
        Each thread has a private JVM stack, created at the same time as thread.
        
        stores frames
        
        A new frame is created each time a method is invoked. A frame is destroyed when its method invocation completes.
        
        Program Counter Register
        
        contains the address of the Java virtual machine instruction currently being executed
        
        Native Method Stack
        
        contains all the native methods used in the application.
        
        Execution Engine
        
        contains:
        
        Interpreter: Read bytecode stream then execute the instructions.
        
        Just-In-Time(JIT) compiler:
        
        compiles parts of the byte code that have similar functionality at the same time
        
        hence reduces the amount of time needed for compilation
        
        used to improve the performance
        
        the term "compiler" refers to a translator from the instruction set of a Java virtual machine (JVM) to the instruction set of a specific CPU.
        
        A virtual processor
        
        Java Native Interface
        
        a framework which provides an interface to communicate with another application written in another language like C, C++, Assembly etc
        
        Java uses JNI framework to send output to the Console or interact with OS libraries.