ICSE 2002 Tutorials
Building Systems from Commercial Components
There is a growing gap between the theory and practice of component-based software design. The theory largely assumes that the design task is to develop specifications for software component; in reality, however, most component-based design relies on preexisting components, which have preexisting specifications. With more and more software systems being developed from commercially available components, it is increasingly critical to recognize the novel challenges and unfamiliar constraints inherent in such design. This tutorial describes a number of proven techniques and much needed guidance on how to build component-based systems in a real working environment. This tutorial is intended for audiences who practice, or wish to practice, component-based software system design and development. System architects, chief engineers, project managers, and front-line software engineers will each find immediate value in this tutorial. This is a full-day tutorial held on Monday May 20th.
Architecture-Centric Software Engineering
Many software organizations are in the process of moving from project-centric to architecture-centric engineering of software. The two typical reasons for this move are (1) the architecture allows for a clear break-down in parts whereas a project-centric approach easily leads to a monolithic system and (2) the organization is interested in exploiting the commonalities between its products or systems. This tutorial addresses this development by providing an overview and in depth treatment of the issues around architecture-centric engineering of software. Topics include software architecture design in the presence of existing components and infrastructure (top-down versus bottom-up), architecture evaluation and assessment, software artefact variability management, software product lines and the role of the software architect. These topics are, in addition to the technical perspective, discussed from process and organizational viewpoints. The topics are extensively illustrated by examples and experiences from many industrial cases. This is a full-day tutorial held on Monday May 20th.
Software Engineering Economics: Background, Current Practices, and Future Directions
The field of software economics seeks to develop technical theories, guidelines, and practices of software development based on sound, established, and emerging models of value and value-creation, adapted to the domain of software development as necessary. The premise of the field is that software development is an ongoing investment activity in which developers and managers continually make investment decisions requiring the expenditure of valuable resources, such as time, talent, and money, and the overriding aim of which is to maximize added value for each participant. The goal of the tutorial is to expose the audience to this line of thinking and introduce the tools pertinent to its pursuit. The morning session will focus on fundamental valuation concepts as well as economics of flexibility in technical and process-related choices. The afternoon session will focus on business case development and case studies. The tutorial is designed to be self-contained. It will cover concepts from introductory to advanced. Practitioners and researchers with an interest in the impact of value considerations in software decision-making will benefit from attending it.
This is a full-day tutorial held on Monday May 20th. This tutorial is offered in conjunction with workshop 7. The tutorial is meant in part to enable those who would like to participate in the workshop, but who might not possess the requisite background, to come up to speed.
Dependability of Embedded Systems
Software plays a role in the design, manufacture, and operation of virtually all engineered artifacts from bridges and buildings to automobiles and aircraft, all of which have to be dependable. This is a tutorial at the introductory level that aims to familiarize researchers, software engineers and managers with the basic elements of the theory and practice of dependability as it applies to embedded systems. Topics covered will include system hazard and fault-tree analysis, software specification and verification, and dealing with real-time and distributed targets. Attendees will acquire a familiarity with the field so that they will be able to make appropriate choices in selecting techniques to apply within their own work and in their own future study. Attendees will be assumed to have a working knowledge of basic computer organization, programming in a high-level language, and the software development lifecycle. This is a full-day tutorial held on Monday May 20th.
Meeting the Challenges of Web Application Development: The Web Engineering Approach
Web application development is more complex and challenging than most of us think. But most Web-based systems are still poorly developed and in an ad hoc manner, resulting in poor quality and maintainability and contributing to failures. This tutorial will discuss various issues, challenges and considerations in development of large Web applications compared to traditional software development and provide an overview on Web Engineering—a proactive and holistic approach to successful Web development.
The tutorial will also address the issues of scalability, maintainability, usability, testing, quality assurance, Web project management and other non-technical aspects specific to Web development and offer specific recommendations that Web developers could follow.
This tutorial is targeted for software developers for Internet applications, E-commerce system implementers, project managers, researchers and students. It will provide them with valuable information and insights on successful Web development.
Desired prerequisite: General understanding of Web page and site development and software engineering.
This is a full-day tutorial held on Monday May 20th.
Almost every expert in Object-Oriented Development stresses the importance of iterative development. As you proceed with the iterative development, you need to add function to the existing code base. If you are really lucky that code base is structured just right to support the new function while still preserving its design integrity. Of course most of the time we are not lucky, the code does not quite fit what we want to do. You could just add the function on top of the code base. But soon this leads to applying patch upon patch making your system more complex than it needs to be. This complexity leads to bugs, and cripples your productivity. Refactoring is all about how you can avoid these problems by modifying your code in a controlled manner. Done well you can make far-reaching changes to an existing system quickly, and without introducing new bugs. You can even take a procedural body of code and refactor it into an effective object-oriented design. With refactoring as part of your development process you can keep your design clean, make it hard for bugs to breed and keeping your productivity high. In this tutorial we'll show you an example of how a lump of poorly designed code can be put into good shape. In the process we'll see how refactoring works, demonstrate a handful of example refactoring, and discuss the key things you need to do to succeed. This is a half-day tutorial held on the morning of Monday May 20th.
Introduction to the Rational Unified Process
The Rational Unified Process (RUP) is a software engineering process framework. It captures many of the best practices in modern software development in a form that is suitable for a wide range of projects and organizations. It embeds object-oriented techniques and uses the UML as the principal notation for the several models that are built during the development. The RUP is also an open process framework that allows software organizations to tailor the process to their specific need, and to capture their own specific process know-how in the form of process components. Many process components are now developed by various organizations to cover different domains, technologies, tools, or type of development, and these components can be assembled to rapidly compose a suitable process. This tutorial will introduce the basic concepts and principles, which lie underthe RUP framework, and show concrete examples of its usage. This is a half-day tutorial held on the morning of Monday May 20th.
Hyper/J®: Multi-Dimensional Separation of Concerns for Java®
Hyper/J(tm) supports a new approach to constructing, integrating and evolving software, called Multi-Dimensional Separation of Concerns (MDSOC). Developers can decompose and organize code and other artifacts according to multiple, arbitrary criteria (concerns) simultaneously, to some extent even after the software has been implemented, and synthesize or integrate the pieces into larger-scale components and systems. This tutorial describes how to accomplish MDSOC with Hyper/J(tm), a tool available for free download, in the context of standard Java(tm) development. The focus is on addressing some real, pervasive problems, especially in the areas of evolution, integration, reuse, and (re)use of design patterns, and showing how to encapsulate concerns like features, variants, roles and business rules.
The tutorial is at an intermediate-level and combines presentation with interactive exploration of examples. Participants have the opportunity to select examples from a prepared set, and to contribute their own. Attendees must have experience with object-oriented software engineering, and some familiarity with Java(tm).
This is a half-day tutorial held on the afternoon of Monday May 20th.
Network and Java Security Concepts
Java with it's Write Once Run Anywhere philosophy is fast becoming a de facto platform of choice for development and deployment of enterprise solutions. With Java being available from Smart Card to Super Computers, it lends itself for implementing portable security solutions. Security, which is a critical need in today's networked economy has been one of the overriding requirements in the design of the language. This session will discuss the basics of network security, the variety of infrastructural support and the choice of ready solutions in Java towards building secure products. The mission of this session is to drive home the point that developers need to understand security, and surprisingly, the concepts are quite simple. This is a half-day tutorial held on the afternoon of Monday May 20th.
Mastering Design Patterns
This tutorial will provide designers with the skills to create high-quality object-oriented designs that support reduced modification costs and increased comprehensibility. Design patterns are about the reuse of excellent, established design ideas—best-practice formulas from experienced object-oriented developers. There is an established set of popular and useful patterns, such as the "gang-of-four" (GoF) design patterns described in the hugely popular and influential book Design Patterns, the annual PLOP workshop patterns, and other sources, such as the Pattern-Oriented Software Architecture series. In this information-intensive tutorial, participants will learn how to apply the majority of high-frequency GoF design patterns. This is a full-day tutorial held on Tuesday May 21st.
Component Technologies: JavaBeans, COM, CORBA, RMI, EJB and the CORBA Component Model
This one-day tutorial is aimed at software engineering practitioners and researchers, who are familiar with object-oriented analysis, design and programming and want to obtain an overview of the technologies that are enabling component-based development. We introduce the idea of component-based development by defining the concept and providing its economic rationale. We describe how object-oriented programming evolved into local component models, such as Java Beans and distributed object technologies, such as the Common Object Request Broker Architecture (CORBA), Java Remote Method Invocation (RMI) and the Component Object Model (COM). We then address how these technologies matured into distributed component models, in particular Enterprise Java Beans (EJB) and the CORBA Component Model (CCM). During the tutorial we provide demonstrations of examples that have been built using these technologies. We conclude by assessing the maturity of each of these technologies and sketch how they are used to build distributed architectures. This is a full-day tutorial held on Tuesday May 21st.
Describing Software Architecture with the UML
The presence of a solid architectural vision is a key discriminator in the success or failure of a software project. This tutorial examines what software architecture is and what it is not. It discusses and illustrates how to describe architecture through a set of design viewpoints and views and how to express these views in the UML, in the spirit of the new IEEE Standard 1471:2000: Recommended practice for architectural description. The tutorial shows of how architectures drive the development process and how to capture architectural decisions and architectural design patterns using the UML. It is illustrated by several widely applicable architectural patterns in different domains: embedded and real-time systems, and enterprise systems. This is a full-day tutorial held on Tuesday May 21st.
Introduction to Agile Processes and Extreme Programming
Extreme Programming is one of the most discussed subjects in the software development community. But what makes XP extreme? And how does it fit into the New World of agile methodologies? This tutorial will establish the underpinnings of agile methodology and explain why you might want to try one. Then we will see how XP uses a set of practices to build an effective software development team that produces quality software in a predictable and repeatable manner.
This is a half-day tutorial held on the morning of Tuesday May 21st.
Advanced Visual Modeling: Beyond UML
With the adoption of UML by the OMG and industry as the linguae-francae of visual systems modeling, one begins to ponder what will come next in this field? This tutorial brings a vision for visual modeling beyond UML. We present and consolidate radical new notations, proposed in a series of research papers and with quickly increasing adoption by industry, for the specification of complex systems in an intuitive visual, yet precise manner. The recurring theme of these notations is the upgrading of familiar diagrams into a powerful visual language. Spider diagrams considerably extend Venn-diagrams to the specification of OO-systems. Most familiar OO-concepts are translated to set theoretical terms: class into set of objects, inheritance corresponding to subset, and even Harel's statecharts interpreted as the set of objects in that state. Constraint diagrams enhance the arrow notation to describe static system invariants that cannot be described by UML class-object diagrams. Reasoning rules are developed for the notation and strong completeness results are given. Finally, 3D-diagrams show how the third dimension and VRML modeling can be used for a conceptual modeling of dynamic system behavior. Much of the tutorial will be based on a case study developed in industry, illustrating how the new notations are combined with those of UML, including OCL.
This is a half-day tutorial held on the morning of Tuesday May 21st.
Information Systems Architecture
The last decade or so has been one of technology churn. We've seen client/server, CORBA, J2EE, COM, .NET and a host of other enterprise platforms appear or fade from view, or both. Keeping up with resulting alphabet soup is a full time job, even without applications to ship. But amongst all of this churn, some techniques stay relatively constant. So we've been trying to identify these common patterns and taking note of how we use the ideas from one technology and use similar, but not the same designs in others. (You can find these at martinfowler.com/isa) In this talk we'll explore a number of these patterns. We'll touch on various topics including layering, business logic organization, database mapping, webserver design, and session state management. The talk is based on the material at <http://martinfowler.com/isa/>. This is a half-day tutorial held on the afternoon of Tuesday May 21st.
Non-Functional Requirements: From Elicitation to Modelling Languages
Complex information systems need models that handle with functional as well as non-functional aspects. This tutorial intends to show to the attendees not only how to elicit non-functional requirements, but also a method to integrate them into functional oriented specification. It will be demonstrated that this integration will lead to a better understanding of the impacts that will arise when one decides to satisfy non-functional requirements. As specification models, this tutorial will cover: Use Cases Diagrams, Scenarios, Class, Sequence and Collaboration Diagrams. We will show that the use of this method can lead to lower costs on software development and to fewer changes in the software during its evolution. Considering non-functional requirements since the requirements elicitation phase leads to a final product that better matches the client's expectation. This is a half-day tutorial held on the afternoon of Tuesday May 21st.
|© ACM SIGSOFT, 2000-2002. Website Maintainer: Kenneth M. Anderson. Last Updated: 05/10/2002; 8:58:54 AM|