CS 426 Senior Projects slide 0

CS 426 Senior Projects

  • Published on
    31-Dec-2015

  • View
    19

  • Download
    1

DESCRIPTION

CS 426 Senior Projects. Chapter 1: What is UML? Chapter 2: What is UP? [Arlow and Neustadt, 2005] January 24, 2011. Outline. What is UML? UML history MDA the future of UML Why unified? Objects and UML UML structure UML building blocks UML common mechanisms Architecture. - PowerPoint PPT Presentation

Transcript

  • CS 426Senior ProjectsChapter 1: What is UML?Chapter 2: What is UP? [Arlow and Neustadt, 2005] January 24, 2011

  • */32Outline.What is UML?UML historyMDA the future of UMLWhy unified?Objects and UMLUML structureUML building blocksUML common mechanismsArchitecture

  • */32.OutlineWhat is UP?UP HistoryUP AxiomsUP Core WorkflowsUP StructureDetails on UP Phases

  • 4/32What is UML?The UML (Unified Modeling Language) is a general purpose visual modeling language for systemsUsually associated with OO software systems, but with wider application than thatIncorporates modern best practices in modeling techniques and software engineeringDesigned to be supported by CASE toolsIt is not a methodology, but a notation that can be used in various software development methodologiesNot tied to any methodology or specific lifecycle; however the preferred method for using UML is the UP (Unified Process)

  • */32UML HistoryStages of UML evolution, Fig. 1.2 [Arlow & Neustadt, 2005]

  • 6/32MDA the future of UMLModel driven architecture (MDA) is based on the idea that models can drive the production of executable software environments

  • */32UML: Why unified?UML unification encompasses the following:Development lifecycle: UML can be used from requirements engineering to implementationApplication domains: UML has been used in a profusion of applications, of various typesImplementation languages and platforms: UML is language and platform independent Development processes: UP is only one of the processes supported by UMLIts own internal concepts: UML is based on a set of concepts that have been applied consistently throughout the notations development

  • */32Objects and UMLThe main premise for using UML is that software systems can be modeled as collections of interacting objectsThere are two major, complementary parts in a UML model:Static structure = constituent objects + their relationshipsDynamic behaviour = functionality provided by the collaborating objects

  • */32UML StructureThere are three main parts in UML structure, as indicated below,Fig. 1.4 [Arlow & Neustadt 2005]

  • */32UML Building BlocksUML is composed of three building blocks [Fig. 1.5, Arlow 2005]:Things, or modeling elements (modeling constructs)Relationships, that specify how things relate semanticallyDiagrams, that provide views into UML models and show collections of interrelated things

  • */32UML Building Blocks: ThingsUML 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 elementsAnnotational things, e.g., the sticky note that can be appended to any modeling construct

  • */32UML Building Blocks: RelationshipsUML relationships indicate how two or more things are interconnected. Relationships apply to structural and grouping things and are as follows [Table 1.1, Arlow & Neustadt 2005]:

  • */32UML 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 developmentDiagrams provide views (or windows) into this modelDiagrams also provide mechanisms for entering information into the modelThere are 13 types of UML diagram, 6 of them describing the static structure of the system (the static model), and 7 the dynamic aspects of the system (the dynamic model) [see next slide]

  • 14/32UML Building Blocks: .Diagrams.Types of UML diagrams [Fig. 1.6, Arlow & Neustadt, 2005]

  • */32UML Building Blocks: ..DiagramsUML syntax for diagram [Fig. 1.7, Arlow & Neustadt, 2005] &diagram with implied frame [Fig. 1.8, Arlow & Neustadt, 2005]

  • */32UML Common MechanismsUML has four common mechanisms that are applied consistently, in different contexts, throughout UML [Fig. 1.9, Arlow 2005]

  • */32UML Common Mechanisms: SpecificationsSpecifications are textual descriptions of the semantics of UML elements. Example, Fig. 1.10 [Arlow & Neustadt, 2005]

  • */32UML Common Mechanisms: AdornmentsAdornments allow showing more information on UML elements. Example, Fig. 1.11 [Arlow & Neustadt, 2005]

  • */32UML Common Mechanisms: Common DivisionsCommon divisions are ways of thinking about the world (for modeling purposes)Common divisions in UML are of two types: Classifiers and instances [see Table 1.2 in the book]Interface and implementation

  • */32UML Common Mechanisms: ExtensibilityThere are three types of mechanisms that provide support for UML extensibility, Table 1.3 [Arlow & Neustadt, 2005]

  • */32Architecture.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 objectsProcess view, depicts the threads and processes of the system as active classesImplementation view, shows the physical code base of the system in terms of componentsDeployment 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.

  • */32.Architecture

    The 4 +1 views architecture, Fig. 1.13 [Arlow & Neustadt 2005]

  • */32What 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 UMLFig 2.2 [Arlow & Neustadt 2005]

  • */32UP HistoryUP evolution, Fig. 2.3 [Arlow & Neustadt, 2005]

  • */32UP FoundersGrady BoochVideo: why engineering?Video: the promise, the limits, the beauty of softwareVideo: smarter products for a smarter planetIvar JacobsonJim Rumbaugh

  • */32UP AxiomsUse case and risk driven Architecture centricIterative and incrementalEach iteration contains all the elements of a regular software development project: planning, analysis, design, construction, integration, testing, internal or external release

  • */32UP Core Workflows.Requirements: Determining what the system should doAnalysis: Refining and structuring the requirementsDesign: Defining system architecture to satisfy requirementsImplementation: Building the softwareTesting: Verifying that the implementation is correct

    A baseline is the result of an iteration, a partially complete version of the final system. An iteration is the difference between two consecutive baselines.

  • */32.UP Core WorkflowsFig.2.5 [Arlow & Neustadt, 2005]

  • */32UP Structure.Fig.2.6 [Arlow & Neustadt, 2005]

  • */32.UP Structure Fig.2.7 [Arlow & Neustadt, 2005]

  • */32UP: Details on Phases.Each of the four phases of UP (inception, elaboration, construction, transition) has:A goalA focus of activityOne or more core workflowsA milestone, with a number of conditions of satisfactionDetails of the above for Inception are given next. The remaining three phases are described in Subsection 2.9 of the textbook

  • */32UP: .Details on PhasesInceptionGoal: Get the project off the groundTasks: Assess feasibilityCreate a strong business caseCapture essential requirementsIdentify critical tasksFocus: Requirements specification and analysisMilestone: Life-cycle objectives [see conditions of satisfaction in Table 2.1 of the book]

    ********************************