Cs 426 senior projects
Download
1 / 30

CS 426 Senior Projects - PowerPoint PPT Presentation


  • 124 Views
  • Uploaded on

CS 426 Senior Projects. Chapter 1: What is UML? Chapter 2: What is UP? [Arlow and Neustadt, 2002] January 26, 2006. Outline. What is UML? UML history Why “unified”? Objects and UML UML structure UML building blocks UML common mechanisms Architecture. .Outline. What is UP?

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 ' CS 426 Senior Projects' - dale


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
Cs 426 senior projects
CS 426Senior Projects

Chapter 1: What is UML?

Chapter 2: What is UP?

[Arlow and Neustadt, 2002]

January 26, 2006


Outline
Outline.

  • What is UML?

  • UML history

  • Why “unified”?

  • Objects and UML

  • UML structure

  • UML building blocks

  • UML common mechanisms

  • Architecture


Outline1
.Outline

  • What is UP?

  • UP History

  • UP Axioms

  • UP Core Workflows

  • UP Structure

  • Details on UP Phases


What is uml
What is UML?

  • The UML (Unified Modeling Language) is a general purpose visual modeling language for systems

    • Usually associated with OO software systems, but with wider application than that

    • Incorporates modern best practices in modeling techniques and software engineering

    • Designed to be supported by CASE tools

    • It is not a methodology, but a notation that can be used in various software development methodologies

    • Not tied to any methodology or specific lifecycle; however the preferred method for using UML is the UP (Unified Process)


Uml history
UML History

Stages of UML evolution, Fig. 1.2 [Arlow & Neustadt, 2002]


Uml why unified
UML: Why “unified”?

  • UML unification encompasses the following:

    • Development lifecycle: UML can be used from requirements engineering to implementation

    • Application domains: UML has been used in a profusion of applications, of various types

    • Implementation languages and platforms: UML is language and platform independent

    • Development processes: UP is only one of the processes supported by UML

    • Its own internal concepts: UML is based on a set of concepts that have been applied consistently throughout the notation’s development


Objects and uml
Objects and UML

  • The main premise for using UML is that software systems can be modeled as collections of collaborating objects

  • There are two major, complementary parts in a UML model:

    • Static structure = constituent objects + their relationships

    • Dynamic behaviour = functionality provided by the collaborating objects


Uml structure
UML Structure

There are three main parts in UML structure, as indicated below,

Fig. 1.3 [Arlow & Neustadt 2002]


Uml building blocks
UML Building Blocks

  • UML is composed of three building blocks [Fig. 1.4, Arlow 2002]:

    • Things, or modeling elements (modeling constructs)

    • Relationships, that specify how things relate semantically

    • Diagrams, that provide views into UML models and show collections of interrelated things


Uml building blocks things
UML Building Blocks: Things

  • UML things, or modeling elements, can be classified as:

    • Structural things, e.g., class, interface, use case, component, node (the “nouns” of a UML model)

    • Behavioural things, such as interactions and state machines (the “verbs” of a UML model)

    • Grouping things, e.g. package, which gathers related modeling elements

    • Annotational things, e.g., the “sticky note” that can be appended to any modeling construct


Uml building blocks relationships
UML Building Blocks: Relationships.

  • UML relationships indicate how two or more things are interconnected. Relationships apply to structural and grouping things and are of four kinds [Fig. 1.5, Arlow 2002]:


Uml building blocks relationships1
UML Building Blocks: .Relationships

  • Details on UML relationships can be found in other chapters of the book, as follows:

    [Table 1.1, Arlow & Neustadt, 2002]


Uml building blocks diagrams
UML Building Blocks: Diagrams.

  • A UML model is a repository of all things and relationships created to describe the structure and behavior of the system under development

  • Diagrams provide views (or windows) into this model

  • Diagrams also provide mechanisms for entering information into the model

  • There are nine types of UML diagram, three describe the static structure of the system (the static model), and six describe the dynamic aspects of the system (the dynamic model) [see next slide]


Uml building blocks diagrams1
UML Building Blocks: .Diagrams

The nine types

of UML diagram

[Fig. 1.6, Arlow &

Neustadt, 2002]


Uml common mechanisms
UML Common Mechanisms

  • UML has four common mechanisms that are applied consistently, in different contexts, throughout UML [Fig. 1.7, Arlow 2002]


Uml common mechanisms specifications
UML Common Mechanisms: Specifications

  • Specifications are textual descriptions of the semantics of UML elements. Example, Fig. 1.8 [Arlow & Neustadt, 2002]


Uml common mechanisms adornments
UML Common Mechanisms: Adornments

  • Adornments allow showing more information on UML elements. Example, Fig. 1.9 [Arlow & Neustadt, 2002]


Uml common mechanisms common divisions
UML Common Mechanisms: Common Divisions

  • Common divisions are ways of thinking about the world (for modeling purposes)

  • Common divisions in UML are of two types:

    • Classifiers and instance [see Table 1.2 in the book]

    • Interface and implementation [see Subsection 1.8.3.2]


Uml common mechanisms extensibility
UML Common Mechanisms: Extensibility

There are three types of mechanisms that provide support for

UML extensibility, Table 1.3 [Arlow & Neustadt, 2002]


Architecture
Architecture.

  • The system architecture is “the organizational structure of the system, including its decomposition into parts, their connectivity, interaction, mechanisms and the guiding principles that inform the design of a system.” [Rumbaugh 1998]

  • There is a typical “4+1 views” architecture of a system defined by UML:

    • Logical view, captures the vocabulary of the problem domain using classes and objects

    • Process view, depicts the threads and processes of the system as active classes

    • Implementation view, shows the physical code base of the system in terms of components

    • Deployment view, models the physical deployment of components onto computational nodes

    • Use case view, captures the requirements of the system using a set of use cases. This is the view “+1” to which all other views connect.


Architecture1
.Architecture

The “4 +1 views” architecture, Fig. 1.11 [Arlow & Neustadt 2002]


What is up
What is UP?

  • A software development process (SDP) or software engineering process (SEP) defines the who, what, when, and how of developing software

  • The Unified Software Development Process(USDP) or, in short, the Unified Process(UP) is an industry standard process created by the authors of UML

Fig 2.2, [Arlow 2002]


Up history
UP History

UP evolution, Fig. 2.3 [Arlow & Neustadt, 2002]


Up axioms
UP Axioms

  • Use case and risk driven

  • Architecture centric

  • Iterative and incremental

    • Each iteration contains all the elements of a regular software development project: planning, analysis, design, construction, integration, testing, internal or external release


Up core workflows
UP Core Workflows.

  • Requirements: Determining what the system should do

  • Analysis: Refining and structuring the requirements

  • Design: Defining system architecture to satisfy requirements

  • Implementation: Building the software

  • Testing: Verifying that the implementation is correct

    A baselineis the result of an iteration, a partially complete version of

    the final system. An iteration is the difference between two consecutive

    baselines.


Up core workflows1
.UP Core Workflows

Fig.2.5, Arlow 2002


Up structure
UP Structure.

Fig.2.6, Arlow 2002


Up structure1
.UP Structure

Fig.2.7, Arlow 2002


Up details on phases
UP: Details on Phases.

  • Each of the four phases of UP (inception, elaboration, construction, transition) has:

    • A goal

    • A focus of activity

    • One or more core workflows

    • A milestone, with a number of conditions of satisfaction

  • Details of the above for Inception are given next. The remaining three phases are described in Subsection 2.9 of the textbook


Up details on phases1
UP: .Details on Phases

  • Inception

    • Goal: Get the project off the ground

    • Tasks:

      • Assess feasibility

      • Create a strong business case

      • Capture essential requirements

      • Identify critical tasks

    • Focus: Requirements specification and analysis

    • Milestone: Life-cycle objectives [see conditions of satisfaction n Table 2.1 of the book]


ad