Please enable JavaScript.

Coggle requires JavaScript to display documents.

Software Engineering ch7 Implementation, Development platform tools, Open…

- - - - At this level, you don’t reuse software directly but use knowledge
        of successful abstractions in the design of your software.
    - - At this level, you directly reuse objects from a library rather than
        writing the code yourself.
    - - Components are collections of objects and object classes that
        you reuse in application systems.
    - - At this level, you reuse entire application systems.
- - - - where support is provided to keep track of the different versions of software components. Version management systems include facilities to coordinate development by several programmers.
    - - where support is provided to help developers define what versions of components are used to create each version of a system. This description is then used to build a system automatically by compiling and linking the required components.
    - - where support is provided to allow users to report bugs and other problems, and to allow all developers to see who is working on these problems and when they are fixed.
- - - - When you develop an application in this way, the design process becomes concerned with how to use the configuration features of that system to deliver the system requirements.
    - - Structured object-oriented design processes involve developing a number of different system models.
      - They require a lot of effort for development and maintenance of these models and, for small systems, this may not be cost-effective.
      - However, for large systems developed by different groups design models are an important communication mechanism
      - Process stages
        
        There are a variety of different object-oriented design processes that depend on the organization using the process.
        
        Common activities in these processes include
        
        Define the context and modes of use of the system;
        
        Design the system architecture;
        
        Identify the principal system objects;
        
        Develop design models;
        
        Specify object interfaces
        
        Process illustrated here using a design for a wilderness weather station.
      - Object classes
        
        Object Class Identification
        
        Approaches to identification
        
        Base the identification on tangible things in the application domain.
        
        Use a scenario-based analysis. The objects, attributes and methods in each scenario are identified.
        
        Use a behavioural approach and identify objects based on what participates in what behaviour.
        
        Use a grammatical approach based on a natural language description of the system.
        
        Design models
        
        Design models show the objects and object classes and
        relationships between these entities.
        
        There are two kinds of design model:
        
        Structural models describe the static structure of the system in
        terms of object classes and relationships
        
        Dynamic models describe the dynamic interactions between objects
        
        Examples of design models
        
        Subsystem models that show logical groupings of
        objects into coherent subsystems.
        
        Shows how the design is organised into logically related groups of objects.
        
        In the UML, these are shown using packages - an encapsulation construct. This is a logical model. The actual organisation of objects in the system may be different.
        
        Sequence models that show the sequence of object
        interactions.
        
        Sequence models show the sequence of object
        interactions that take place
        
        Objects are arranged horizontally across the top;
        
        Time is represented vertically so models are read top to bottom;
        
        Interactions are represented by labelled arrows, Different styles of arrow represent different types of interaction;
        
        A thin rectangle in an object lifeline represents the time when the object is the controlling object in the system.
        
        State machine models that show how individual objects
        change their state in response to events.
        
        State diagrams are used to show how objects respond to different service requests and the state transitions triggered by these requests.
        
        State diagrams are useful high-level models of a system
        or an object’s run-time behavior.
        
        State diagrams are useful high-level models of a system
        or an object’s run-time behavior.
        
        Other models include use-case models, aggregation
        models, generalisation models, etc.
      - Design patterns
        
        A design pattern is a way of reusing abstract knowledge about a problem and its solution.
        
        A pattern is a description of the problem and the essence of its solution.
        
        It should be sufficiently abstract to be reused in different settings.
        
        Pattern descriptions usually make use of object-oriented characteristics such as inheritance and polymorphism.
        
        Patterns
        
        Patterns and Pattern Languages are ways to describe best practices, good designs, and capture experience in a way that it is possible for others to reuse this experience.
        
        Pattern elements
        
        Name
        
        A meaningful pattern identifier.
        
        Problem description
        
        Solution description
        
        Not a concrete design but a template for a design solution that can be instantiated in different ways.
        
        Consequences
        
        The results and trade-offs of applying the pattern.
        
        The Observer pattern
        
        Name
        
        Observer.
        
        Description
        
        Separates the display of object state from the object itself.
        
        Problem description
        
        Used when multiple displays of state are needed.
        
        Solution description
        
        See slide with UML description.
        
        Consequences
        
        Optimisations to enhance display performance are impractical.
        
        Design problems
        
        Tell several objects that the state of some other object has
        changed (Observer pattern).
        
        Allow for the possibility of extending the functionality of an
        existing class at run-time (Decorator pattern).
        
        To use patterns in your design, you need to recognize that any design problem you are facing may have an associated pattern that can be applied.
        
        Provide a standard way of accessing the elements in a collection, irrespective of how that collection is implemented (Iterator pattern).
        
        Tidy up the interfaces to a number of related objects that have
        often been developed incrementally (Façade pattern).