Developing Product Line Components Jan Bosch Professor of Software Engineering University of Groningen, Netherlands

Slides:



Advertisements
Similar presentations
2 Introduction A central issue in supporting interoperability is achieving type compatibility. Type compatibility allows (a) entities developed by various.
Advertisements

Object-Oriented Application Frameworks Much of the cost and effort stems from the continuous re- discovery and re-invention of core concepts and components.
Profiles Construction Eclipse ECESIS Project Construction of Complex UML Profiles UPM ETSI Telecomunicación Ciudad Universitaria s/n Madrid 28040,
Architecture Representation
1 Copyright 1998 by Dragos Manolescu and Joseph W. Yoder Building Frameworks With Patterns “An Active Object-Model For A Dynamic Web-Based Application”
Design Principles for Reusable, Composable and Extensible Frameworks Jilles van Gurp.
SERL - Software Engineering Research Labslide1 Frameworks and Hooks by Garry Froehlich Paul Sorenson SERL (Software Engineering Research Lab)
Adding More Value to Your ERP System Using Service-Oriented Architecture (SOA) Copyright © 2001 iWay Software 1 Information Builders.
Page 1 Building Reliable Component-based Systems Chapter 7 - Role-Based Component Engineering Chapter 7 Role-Based Component Engineering.
Page 1 Building Reliable Component-based Systems Chapter 16 - Component based embedded systems Chapter 16 Component based embedded systems.
Software Reuse Building software from reusable components Objectives
1 IBM SanFrancisco Product Evaluation Negotiated Option Presentation By Les Beckford May 2001.
Design Patterns CS is not simply about programming
Unified Modeling (Part I) Overview of UML & Modeling
Feb. 23, 2004CS WPI1 CS 509 Design of Software Systems Lecture #5 Monday, Feb. 23, 2004.
Dept. of Computer Engineering, Amir-Kabir University 1 Design Patterns Dr. Noorhosseini Lecture 2.
Software Engineering Module 1 -Components Teaching unit 3 – Advanced development Ernesto Damiani Free University of Bozen - Bolzano Lesson 2 – Components.
Building software from reusable components.
Page 1 Building Reliable Component-based Systems Chapter 17 - Architectural Support for Reuse Chapter 17 Architectural Support for Reuse.
Reuse Activities Selecting Design Patterns and Components
The Software Product Life Cycle. Views of the Software Product Life Cycle  Management  Software engineering  Engineering design  Architectural design.
Course Instructor: Aisha Azeem
Architectural Design Establishing the overall structure of a software system Objectives To introduce architectural design and to discuss its importance.
Domain-Specific Software Engineering Alex Adamec.
Architecture, Implementation, and Testing Architecture and Implementation Prescriptive architecture vs. descriptive architecture Prescriptive architecture:
Seminar of “CBSE” Course Mohammad Mahdizadeh SM. University of Science and Technology Mazandaran-Babol January 2010 Adaptation of.
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 18 Slide 1 Software Reuse 2.
©Ian Sommerville 2006Software Engineering, 8th edition. Chapter 18 Slide 1 Software Reuse.
Software Engineering Muhammad Fahad Khan
©Ian Sommerville 2004Software Engineering, 7th edition. Chapter 18 Slide 1 Software Reuse.
©Ian Sommerville 2000 Software Engineering, 6th edition. Chapter 14Slide 1 Design with Reuse l Building software from reusable components.
UML - Development Process 1 Software Development Process Using UML (2)
Object-oriented Software Engineering with Reuse Contracts Koen De Hondt, Carine Lucas, Kim Mens, Tom Mens, Patrick Steyaert, Roel Wuyts Programming Technology.
Software Product Families. Generative Programming Main text: Ian Sommerville, Software Engineering, 8 th edition, chapter 18 Additional readings: K. Czarnecki.
Slide 1 Wolfram Höpken RMSIG Reference Model Special Interest Group Second RMSIG Workshop Methodology and Process Wolfram Höpken.
International Workshop on Web Engineering ACM Hypertext 2004 Santa Cruz, August 9-13 An Engineering Perspective on Structural Computing: Developing Component-Based.
©Ian Sommerville 2000 Software Engineering, 6th edition. Slide 1 Component-based development l Building software from reusable components l Objectives.
An Introduction to Design Patterns. Introduction Promote reuse. Use the experiences of software developers. A shared library/lingo used by developers.
Copyright 2002 Prentice-Hall, Inc. Modern Systems Analysis and Design Third Edition Jeffrey A. Hoffer Joey F. George Joseph S. Valacich Chapter 20 Object-Oriented.
I T & S A e r o s p a c eD e f e n c e THALES Research & Technology THALES recommendations for the final OMG standard on Query / Views / Transformations.
Odyssey A Reuse Environment based on Domain Models Prepared By: Mahmud Gabareen Eliad Cohen.
A Novel Approach to Architectural Recovery in Evolving Object- Oriented Systems PhD thesis Koen De Hondt December 11, 1998.
Hyper/J and Concern Manipulation Environment. The need for AOSD tools and development environment AOSD requires a variety of tools Life cycle – support.
Component frameworks Roy Kensmil. Historical trens in software development. ABSTRACT INTERACTIONS COMPONENT BUS COMPONENT GLUE THIRD-PARTY BINDING.
Software Design Patterns (1) Introduction. patterns do … & do not … Patterns do... provide common vocabulary provide “shorthand” for effectively communicating.
Chapter 8 Object Design Reuse and Patterns. Object Design Object design is the process of adding details to the requirements analysis and making implementation.
©Kabira Technologies Inc, 2001 May 7-9, 2001 Westward Look Resort Tucson, Arizona SMUG 2001 Execution in UML.
Design Principle & Patterns by A.Surasit Samaisut Copyrights : All Rights Reserved.
FDT Foil no 1 On Methodology from Domain to System Descriptions by Rolv Bræk NTNU Workshop on Philosophy and Applicablitiy of Formal Languages Geneve 15.
1 Choices “Our object-oriented system architecture embodies the notion of customizing operating systems to tailor them to support particular hardware configuration.
©Ian Sommerville 2000 Software Engineering, 6th edition. Chapter 14Slide 1 Chapter 14 Design with Reuse.
©Ian Sommerville 2006Software Engineering, 8th edition. Chapter 18 Slide 1 Software Reuse.
Design CIS 4800 Kannan Mohan Department of CIS Zicklin School of Business, Baruch College Copyright © 2009 John Wiley & Sons, Inc. Copyright © 2008 Course.
Java EE Patterns Dan Bugariu.  What is Java EE ?  What is a Pattern ?
Design Patterns: Elements of Reusable Object- Orientated Software Gamma, Helm, Johnson, Vlissides Presented By: David Williams.
1 Software Design Lecture What’s Design It’s a representation of something that is to be built. i.e. design  implementation.
Designing a Product Line Architecture Jan Bosch Professor of Software Engineering University of Groningen, Netherlands
1 Unified Modeling Language, Version 2.0 Chapter 2.
Secure middleware patterns E.B.Fernandez. Middleware security Architectures have been studied and several patterns exist Security aspects have not been.
Software Architecture Transformation Jan Bosch Professor of Software Engineering University of Groningen, Netherlands
Banaras Hindu University. A Course on Software Reuse by Design Patterns and Frameworks.
Banaras Hindu University. A Course on Software Reuse by Design Patterns and Frameworks.
Banaras Hindu University. A Course on Software Reuse by Design Patterns and Frameworks.
EMEA Beat Schwegler Architect Microsoft EMEA HQ Ingo Rammer Principal Consultant thinktecture
2000 Research Overview Dr. Kim Mens Programming Technology Lab Vrije Universiteit Brussel.
Tempus Software Maintenance and Evolution JMSE-SM&E Unit 4: Software Reuse (Building Software From Reusable Components) Prof. Mohammad A. Mikki Gaza, Palestine,
Review of last class Software Engineering Modeling Problem Solving
Implementing Language Extensions with Model Transformations
Implementing Language Extensions with Model Transformations
Chapter 8, Design Patterns Introduction
Presentation transcript:

Developing Product Line Components Jan Bosch Professor of Software Engineering University of Groningen, Netherlands Copyright © 2001 Jan Bosch

Developing product line components2 Overview A software component is a unit of composition with explicitly specified provided, required and configuration interfaces only  traditional component development  object-oriented frameworks

Developing product line components3 Software Components  three levels of component reuse  reuse of software components over subsequent versions of a product  we know this trick  reuse of components over product versions and various products  we’re learning this trick  reuse of components over product versions, various products and different organizations  we’re nowhere near learning this trick (except in very restricted domains, e.g., Visual Basic)

Developing product line components4 Component Development

Developing product line components5 Domains  a domain is an area of functionality identified by as an entity by the user of the domain  application domains  software domains  domain taxonomies, e.g. OMG’s special interest groups  component versus domain: issue of granularity

Developing product line components6 Component interfaces  an interface defines a contract between a component requiring certain functionality and a component providing that functionality  issues with interfaces:  all operations available at all times  only support for call-reply  actual component interface more complex  syntax does not guarantee semantics

Developing product line components7 Component interfaces  provided interface  an identifier  a list of operations  a list of interface identifiers  required interface  not necessarily one-to-one!

Developing product line components8 Component interfaces  variability versus adaptation  configuration interface (technical + documentation part)  mechanisms:  inheritance  extensions  configuration  template instantiation  generation

Developing product line components9 Component adaptation  requirements  black-box  transparent  composable  reusable  configurable  mechanisms  copy-paste  inheritance  wrapping

Developing product line components10 Component adaptation

Developing product line components11 Aspects, Constraints and Rules  aspects: concurrency, synchronization, persistence, transactions and distribution  constraints, e.g. amount of resources (CPU, memory, communications, etc.)  rules: standardised ways of performing certain tasks

Developing product line components12 Object-Oriented Frameworks  A framework is a set of classes that embodies an abstract design for solutions to a family of related problems  categorisations:  white-box versus black-box  calling versus called  evolution pattern: abstract white-box, white-box extensible, black-box, visual builder, DSL

Developing product line components13 Object-Oriented Frameworks  concepts  core framework design  framework internal increment  application specific increment  object-oriented framework  application

Developing product line components14 Componentizing frameworks composition problems  framework control  legacy components  framework gap  composition overlap of framework entities  entity functionality

Developing product line components15 Framework component models  system-specific extension model  standard-specific extension model

Developing product line components16 Framework component models  fine-grained extension model  generator-based model

Developing product line components17 Designing frameworks  domain and variability analysis  architectural design  framework design  framework implementation  framework testing  test instantiation generation  documentation

Developing product line components18 Conclusion  two views on components  traditional  object-oriented frameworks  domains  interfaces  adaptation  framework component models