chapter 9 from design to implementation n.
Download
Skip this Video
Download Presentation
Chapter 9 From Design to Implementation

Loading in 2 Seconds...

play fullscreen
1 / 25

Chapter 9 From Design to Implementation - PowerPoint PPT Presentation


  • 127 Views
  • Uploaded on

Chapter 9 From Design to Implementation. Implementation Model Forward, Reverse, and Round-Trip Engineering Mapping Designs to Code Test-Driven Development. Implementation Model. 9.1 Implementation Model . Concept of Component Component Diagram Concept of Node Deployment Diagram .

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Chapter 9 From Design to Implementation' - gaerwn


Download Now An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
chapter 9 from design to implementation
Chapter 9 From Design to Implementation
  • Implementation Model
  • Forward, Reverse, and Round-Trip Engineering
  • Mapping Designs to Code
  • Test-Driven Development
9 1 implementation model
9.1 Implementation Model
  • Concept of Component
  • Component Diagram
  • Concept of Node
  • Deployment Diagram
concept of component

Login.dll

Concept of Component
  • a component is a physical and replaceable part of a system that conforms to and provides the realization of a set of interfaces.
  • Graphically, a component is rendered as a rectangle with tabs, usually including only its name.
component diagram

component.java

ImageObserver

image.java

Component Diagram
  • A component diagram shows the organizations and dependencies among software components, including source code components, binary code components, and executable components.
  • Component diagrams contain:
    • Component packages.
    • Components
    • Interfaces
    • Dependency relationships
component diagram1
Component Diagram
  • Captures the physical structure of the implementation
  • Built as part of architectural specification
  • Purpose
    • Organize source code
    • Construct an executable release
    • Specify a physical database
  • Developed by architects and programmers
what is node

<<Node>>

Node #1

What is Node?
  • a node is a physical element that exists at run time and represents a computational resource, generally having at least some memory and, often, processing capability.
  • A set of components may reside on a node and may also migrate from node to node.
  • Graphically, a node is rendered as a cube, usually including only its name.
what is a connection
What Is a Connection?
  • A connection represents a:
    • Communication mechanism
      • Physical medium
      • Software protocol

Kiosk

<<10-T Ethernet>>

Connection

<<Processor>>

Server

<<RS-232>>

Console

deployment diagram
Deployment Diagram
  • A deployment diagram is a diagram that shows the configuration of run time processing nodes and the components that live on them.
  • Captures the topology of a system’s hardware
  • Built as part of architectural specification
  • Purpose
    • Specify the distribution of components
    • Identify performance bottlenecks
  • Developed by architects, networking engineers, and system engineers
deployment diagram example
Deployment Diagram - Example

Desktop PC

Desktop PC

<<Campus LAN>>

<<Campus LAN>>

Registration

Server

<<Campus LAN>>

<<Campus LAN>>

<<legacy>>

<<legacy>>

Course

Billing

Catalog

System

9 2 forward reverse and round trip engineering
9.2 Forward, Reverse, and Round-Trip Engineering
  • Forward Engineering
  • Reverse Engineering
  • Round-Trip Engineering
forward engineering

Generate

Forward Engineering
  • Forward engineering means the generation of code from UML diagrams
  • Many of the tools can only do the static models:
    • They can generate class diagrams from code, but can't generate interaction diagrams.
    • For forward engineering, they can generate the basic (e.g., Java) class definition from a class diagram, but not the method bodies from interaction diagrams.
  • Demo
reverse engineering

Re-Engineer

Reverse Engineering
  • Reverse engineering means generation of UML diagrams from code
  • Demo
round trip engineering
Round-Trip Engineering
  • Round-trip engineering closes the loop
    • the tool supports generation in either direction and can synchronize between UML diagrams and code, ideally automatically and immediately as either is changed.
  • Demo
9 3 mapping designs to code
9.3 Mapping Designs to Code
  • Creating Class Definitions from Class Diagram
  • Creating Methods from Interaction Diagrams
  • Collection Classes in Code
creating class definitions from class diagram
Creating Class Definitions from Class Diagram
  • Defining a Class with Method Signatures and Attributes
9 4 test driven development and refactoring
9.4 Test-Driven Development and Refactoring
  • Test-Driven Development
  • Refactoring
test driven development
Test-Driven Development
  • An excellent practice promoted by the iterative and agile XP method,and applicable to the UP, is test-driven development (TDD).
    • It is also known as test-first development
  • In OO unit testing TDD-style, test code is written before the class to be tested,
    • and the developer writes unit testing code for nearly all production code.
  • Unit testing framework
    • The most popular unit testing framework is the xUnit family (for many languages)
    • For Java, the popular version is JUnit.
    • There's also an NUnit for .NET,
  • Example
refactoring
Refactoring
  • Refactoring is a structured, disciplined method to rewrite or restructure existing code without changing its external behavior,
    • applying small transformation steps combined with re-executing tests each step.
  • Continuously refactoring code is another XP practice and applicable to all iterative methods
  • Code that's been well-refactored is short, tight, clear, and without duplicationit looks like the work of a master programmer.
    • Code that doesn't have these qualities smells bad or has code smells.