inf5120 modellbasert systemutvikling n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
INF5120 – Modellbasert Systemutvikling PowerPoint Presentation
Download Presentation
INF5120 – Modellbasert Systemutvikling

Loading in 2 Seconds...

play fullscreen
1 / 94

INF5120 – Modellbasert Systemutvikling - PowerPoint PPT Presentation


  • 148 Views
  • Uploaded on

INF5120 – Modellbasert Systemutvikling. F10-1: ADM, Architectural Patterns, Design Patterns and Refactoring  Forelesning 12.04.2010 Arne-Jørgen Berre. INF5120 - Lecture plan - 2010.

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

INF5120 – Modellbasert Systemutvikling


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
  1. INF5120 – Modellbasert Systemutvikling F10-1: ADM, Architectural Patterns, Design Patterns and Refactoring  Forelesning 12.04.2010 Arne-Jørgen Berre

  2. INF5120 - Lecture plan - 2010 • 1: 25/1: Introduction to MBSU, MDA, OO and Service/SOA modeling, Overall EA, 4 parts: MDE/SSS/MS/MDI (AJB) • Part I: MDE – Model Driven Engineering • 2: 1/2: MDE I: Metamodeling. DSL and UML profiles, MDA technologies (XMI, Eclipse, EMF/GMF) (AJB/BRE) • Part II: SSS – Service Science and Service/SOA technologies • 3: 8/2: SSS I: Service science (top down) - Service and SOA Technologies (bottom up) (AJB) • Part I continued: MDE – Model Driven Engineering • 4: 15/2: MDE II: Model transformations with MOFScript, ATL and other technologies (GO/JO) • 5 :22/2: MDE III: Code generation with MOFScript, ATL and other technologies (GO/JO) • Part III: MOS – Modeling of Services - with SoaML • 6: 1/3: MOS I: Business Process Modeling (CIM) - with BPMN 2.0, and BMM, EA with UPDM (AJB) • 7: 8/3: MOS II: Soaml, UML2 and SysML, Modelio SOA and Scope, –Collaboration and Component models (AJB) • 8: 15/3: MOS III: SoaML (PIM) and Requirements modeling , CIM->PIM and SoaML (AJB) • 9: 22/3: MOS IV: Method Engineering and SPEM / EPF - for Service systems (BRE) • EASTER • Part IV – Model Driven Interoperability • 10: 12/4: MS V: SOA and Service Design, MDA and ADM - Intro to MDI (AJB ) • 11: 19/4: MDI I: Semantic Web with Ontologies and Model Driven Interoperability (TIR) • 12: 26/4: MDI II: Semantic Services and Model Driven Interoperability (TIR) • 13: 3/5: MDE IV: Evolution and industrial practice of modelbased technologies (AJB++) • 14: 10/5: Course summary and preparation for Exam 31/5 (AJB) • Exam: May 31st, 2010 (Monday), 0900-1200 (3 hours)

  3. Agenda • ADM • Architecture Driven Modernisation • Patterns • GRASP patterns • Design principles • Design Patterns • Refactoring 

  4. ADM – Architecture-Driven Modernization (Reverse MDA)

  5. IT Architecture

  6. Business Architecture

  7. Business architecture models in OMG in the Zachman framework

  8. IT Architecture Ecosystem

  9. IT/Business architecture transformation

  10. Modernization horse shoe model

  11. Modernization scenarios

  12. ADM Framework

  13. ADM Standards in OMG

  14. KDM & ASTM

  15. Pattern Recognition and SMM

  16. Visualisation, Refactoring and Transformation

  17. Convergence to Cloud Computing Virtualization VMware, Citrix Enterprise Apps Microsoft, IBM, Oracle, Tibco Desktop Apps Google, Zoho Utility Computing Rackspace, Terremark, Savvis, IBM Desktop as a Service Simtone, Desktone Cloud Computing Adaptive Data Centers IBM, HP, Sun Grids Univa Ud, Gigaspaces, IBM Platform as a Service Google, Microsoft Infrastructure as a Service Amazon.com Software as a Service Saleforce.com

  18. Cloud Computing Definition “Cloud computing is a model for enabling convenient, on-demand networkaccess to a shared pool of configurable computing resources (e.g., networks, servers, storage, applications, and services) that can be rapidly provisioned and released with minimal management effort or service provider interaction. This cloud model promotes availability and is composed of five essential characteristics, three service models, and four deployment models”. 5: On-demand self-service, Broad network access, Resource pooling, Rapid elasticity, Measured Service 3: IaaS, PaaS, SaaS 4: Private, Community, Public, Hybrid NIST Definition of Cloud Computing, Draft version 15, Oct 7, 2009 http://csrc.nist.gov/groups/SNS/cloud-computing/index.html

  19. Government Cloud Framework

  20. Model Capability Provided Example Services SaaS To use the provider’s applications running on a cloud infrastructure and accessible from various client devices through a thin client interface such as a Web browser • Citizen Engagement (Wikis, Blogs, Data.gov) • Government Productivity (Cloud based tools) • Business Enablement (Salesforce.com) • Enterprise Applications (Core Mission & Business Svcs PaaS To deploy onto the cloud infrastructure consumer-created applications using programming languages and tools supported by the provider (e.g., java, python, .Net) • Database and Database Management Systems • Developer / Testing Tools • Virtual Environments IaaS To provision processing, storage, networks, and other fundamental computing resources where the consumer is able to deploy and run arbitrary software, which can include operating systems and applications • Computing • Storage • Application hosting Service Model Overview

  21. REMICS Overall process

  22. REMICS Metamodel extensions

  23. Analysis Design Implementation Architecture Patterns (Macro Architecture) Analysis (Domain) Patterns Domain Framework Idioms (Language dependent patterns) Design Patterns (Micro Architecture) (OO) Reusable Components Patterns: From Analysis to Implementation

  24. Module level patterns: Architecture Patterns Collaboration level patterns: Design Patterns Refactoring Object level patterns: GRASP Patterns on various design levels

  25. GRASP General Responsibility Assignment Software Patterns. Responsibility assignment. 1. knowing (answering) 2. or, doing Guidance and evaluation in mechanistic design. • 1. Expert • 2. Creator • 3. Controller • 4. Low Coupling • 5. High Cohesion • 6. Polymorphism • 7. Pure Fabrication • 8. Indirection • 9. Don’t Talk to • Strangers

  26. Patterns – Abstract Factory

  27. Design patterns (with UML & Java examples) Based on: Gamma/Helm/Johnson/Vlissides (GoF): Design Patterns, 1995 R. Ryan:, D. Rosenstrauch:Design Patterns in Java, 1997

  28. What are patterns? • "A solution to a problem in a context"? • Insufficient, says the “Gang of Four” (GOF) • What’s missing? 3 things: • Recurrence • Teaching (e.g., implementation consequences, trade-offs, and variations) • A name • GOF: • Patterns contain 4 essential elements • pattern name • problem • solution • consequences • Christopher Alexander (as quoted in the GOF book): • "Each pattern describes a problem which occurs over and over again ... and then describes the core of [a] solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice."

  29. Design Pattern A design pattern describes a basic scheme for structuring subsystems and components of a software architecture as well as their relationships. It identifies, names, and abstracts a common structural or functional principle by describing its different parts, their collaboration and responsibilities.

  30. GOF (Gang of Four) 23 Patterns • Creational Patterns (5) • Abstract Factory, Builder, Factory Method, Prototype, Singleton • Structural Patterns (7) • Adapter, Bridge, Composite, Decorator, Façade, Flyweight, Proxy • Behavioural Patterns (11) • Chain of responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template method, Visitor

  31. Skylight Spelunker • “Skylight Spelunker” is a Java framework for a file browser similar in appearance to the “Windows Explorer” included with Windows 98. • Spelunker has two views: • Disks and folders in tree structure (FolderView - Left pane) • All contents of selected folder (ContentsView - Right pane) • Spelunker provides support for : • Multiple ways of arranging ContentsView icons • Accessing network drives as well as local • Deleting, renaming and viewing disk contents

  32. ContentsView FolderView Windows Explorer Screen Shot

  33. Patterns in Spelunker example • Composite • used to model the file tree data structure • Strategy • used to layout the file and folder icons in ContentsView • Observer • used to re-display FolderViews and ContentsViews after user requests • Proxy and State • used to model password-protected network disk drives • Command • used to carry out user requests

  34. The “Composite” pattern • Problem • What is the best way to model the Spelunker file tree? • The Spelunker file tree is a classic tree structure. Thus we need a leaf class (File) and a tree class (Folder) which contains pointers to the Files and Folders in it. • However, there are many operations that are relevant to both a File and a Folder (e.g., getSize()). • The user doesn’t treat Files and Folders differently, so why should calling modules have to? • The design would be less complex and more flexible if the calling module could initiate operations on a target object, without knowing whether the target was a File or a Folder. • File and Folder should share a common interface.

  35. The “Composite” pattern • How the pattern solves the problem • Intent • “Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.” [GHJV94] • Explanation • The Composite pattern works by having leaf and tree objects share a common interface. • Create an abstract base class (or interface) that represents both File and Folder. • Files and Folders need to provide implementations for the same operations, but they can implement them differently. • E.g., leaves usually handle an operation directly, while trees usually forward the operation to its children (and/or perform additional work before or after forwarding)

  36. Component Client Operation( ) children Add(Component) Remove(Component) GetChild(int) Leaf Composite Operation( ) for all g in children g.Operation(); Operation( ) Add(Component) Remove(Component) GetChild(int) The “Composite” pattern • How the pattern solves the problem, cont. • Gang of Four UML [GHJV94]

  37. Node Resource Tree children getSize( ) File Folder getSize( ) size = total of size of each child getSize() getContents() The “Composite” pattern • Use of the pattern in Spelunker • Both File and Folder share a common interface: Node. • Spelunker UML

  38. The “Composite” pattern • Use of the pattern in Spelunker, cont. • Code examples public class File extends Node { private long size = 0; public long getSize() { return size; } } public class Folder extends Node { private Vector contents; public long getSize() { long size = 0; if (contents != null) { Enumeration e = contents.elements(); while (e.hasMoreElements()) { size += ((Node)e.nextElement()).getSize(); } } return size; } }

  39. The “Strategy” pattern • Problem • The way in which the icons are arranged varies according to user preference - the user may choose an iconic view only, or a short/long detail view. • Including the algorithms to arrange the icons as methods in ContentsView would make it cumbersome to add new icon arrangement algorithms to ContentsView; ContentsView would have to be subclassed and some implementation details might have to be unnecessarily exposed. • A switch statement would most likely be used to choose the correct arrangement algorithm.

  40. The “Strategy” pattern • How the pattern solves the problem • Intent • “Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.” [GHJV94] • Explanation • The algorithms for arranging the icons are encapsulated into a separate interface. • The correct arrangement algorithm is chosen polymorphically. • ContentsView neither knows nor cares which arrangement is presently in use.

  41. strategy Context Strategy ContextInterface() AlgorithmInterface() ConcreteStrategyA ConcreteStrategyB ConcreteStrategyC AlgorithmInterface() AlgorithmInterface() AlgorithmInterface() The “Strategy” pattern • How the pattern solves the problem, cont. • Gang of Four UML [GHJV94]

  42. strategy ContentsView ViewManager updateVisibleNodes() updateVisibleNodes() IconViewManager ListViewManager updateVisibleNodes() updateVisibleNodes() The “Strategy” pattern • Use of the pattern in Spelunker • ContentsView delegates the task of arranging the icons to ViewManager. • Spelunker UML

  43. The “Strategy” pattern • Use of the pattern in Spelunker, cont. • Code examples public interface ViewManager { public void updateVisibleNodes(Folder activeFolder); } public class ContentsView extends ResourceTreeView { private ViewManager viewManager; public void showIconView() { viewManager = new IconViewManager(this); } public void showListView(boolean showDetail) { viewManager = new ListViewManager(this, showDetail); } public void updateVisibleNodes(Folder activeFolder) { viewManager.updateVisibleNodes(activeFolder); } }

  44. The “Observer” pattern • Problem • What is the best way to keep all views of the file tree in sync? • We need to be able to re-draw the display window after the user modifies a file/folder (e.g., when user clicks on a folder to select it) • However, there may be several windows and panes that display the same file/folder. We need to re-draw all of them. • To do this, the tree needs to keep a list of all of its views, and notify each one after a modification is done. • However, the tree and view objects might: • have little other relationship besides this notification • need to have their code modified independently • need to be reused separately • So it would be preferable not to make them too tightly coupled to each other.

  45. The “Observer” pattern • How the pattern solves the problem • Intent • “Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.” [GHJV94] • Explanation • The Observer pattern works by defining an abstract class (or interface) with a single method signature. The method will be used as a mechanism for “observer” objects to be notified of changes in their “subject”. • Concrete observer sub-classes will each provide their own implementation of what to do when the notification occurs. • The subject can notify each observer the same way, without caring which specific sub-class of observer the object actually is.

  46. Observer Subject Update( ) Attach(Observer) observers Detach(Observer) Notify( ) ConcreteSubject ConcreteObserver SubjectState ObserverState subject Update( ) GetState( ) ObserverState = subject.GetState() return SubjectState for all o in observers o.update(); The “Observer” pattern • How the pattern solves the problem, cont. • Gang of Four UML [GHJV94]

  47. resourceTreeChanged(Folder) observers ResourceTree ResourceTreeView activeFolder AttachObserver(ResourceTreeObserver) resourceTreeChanged( Folder activeFolder) DetachObserver(ResourceTreeObserver) subject NotifyObservers( ) updateVisibleNodes(activeFolder); repaint(); Enumeration e = observers.elements(); while (e.hasMoreElements()) { ResourceTreeObserver o = (ResourceTreeObserver)e.nextElement(); o.resourceTreeChanged(activeFolder); } The “Observer” pattern • Use of the pattern in Spelunker • ResourceTree notifies all ResourceTreeViews whenever its state is modified. • Spelunker UML ResourceTreeObserver

  48. The “Observer” pattern • Use of the pattern in Spelunker, cont. • Code examples public class ResourceTree { private Vector observers; public void setActiveFolder(Folder folder) { if (activeFolder != folder) { activeFolder = folder; notifyObservers(); } } public void notifyObservers() { Enumeration e = observers.elements(); while (e.hasMoreElements()) { ((ResourceTreeObserver)e.nextElement()).resourceTreeChanged(activeFolder); } } } public abstract class ResourceTreeView extends Panel implements ResourceTreeObserver { public void resourceTreeChanged(Folder activeFolder) { updateVisibleNodes(activeFolder); repaint(); } }

  49. The “Proxy” pattern • Problem • Network drives might require the user to login before the drive can be accessed - however, the protocol for accessing a network drive when logged in might not differ from accessing a local drive. • LocalDrive should not contain network code - this code should be moved to a separate class, i.e. NetworkDrive. • Creating NetworkDrive as a subclass of LocalDrive would be complicated and unwieldy - we would have to check access everytime a drive operation was requested. • Creating NetworkDrive as a subclass of Folder would force us to duplicate all drive access operations already in LocalDrive.

  50. The “Proxy” pattern • How the pattern solves the problem • Intent • “Provide a surrogate or placeholder for another object to control access to it.” [GHJV94] • “A Protection Proxy controls access to the original object. Protection Proxies are useful when objects should have different access rights.” [GHJV94] • Explanation • The network protocols necessary for logging in and out are moved into a subclass of Folder called NetworkDrive. • NetworkDrive contains the code necessary for logging in and out of a network drive. • After logging in, NetworkDrive delegates drive access requests to LocalDrive (indirectly through ConnectionState).