Dvdate3.3.4 error 8

dvdate3.3.4 error 8

|Planned synthesis of results the reported standard error. |Subgroup analysis and assessment of. heterogeneity. 8 References for Eligible Studies Date coded, DVDate ___ - __ - __ DNA (treatment) group standard error, ES_TxSE__________. We give DVdate 4 out of 5 stars, as most functions can be used Hello guys I am getting an error in my script, here's what is giving me.

Dvdate3.3.4 error 8 - for

Overview of my first PE4 project

Discussions concerning Premiere Elements version 1 - 4.

Overview of my first PE4 project

Postby Gerry » Sat Oct 13, pm

I just finished my first real project in PE4, and thought I'd just give an overview.

The project is a minute movie that's filled with DV-AVI, still photos, reduced-size photos moved via keyframe to particular spots on the screen, several different transitions, several "Brady bunch" screens with moving DV-AVI backgrounds, music in spots, and some animated titles. Nothing extraordinary, but "typical" for a project for me.

Overall my experience with PE4 was very good. Once you get used to the new layout of the workspace (I was previously using PE2), things tend to go very fast.

One feature in particular helped me get accustomed to the new "video and audio together" workspace: "Remove unused tracks." Since most of my tracks beyond Track 1 were simply still photos, there was no need for audio tracks beneath most of them. "Remove unused tracks" helped save real estate on the timeline by deleting those audio tracks with nothing on them.

I've NEVER had the file corruption problem that's been highly discussed here, but in the course of putting together the movie I did have two serious problems -- one was a complete "memory dump" in which my computer virtually instantly shut down, and one "Serious error" with reporting to Microsoft. To be fair, I believe both problems were caused by ME trying to do too much while the computer was processing (flipping between windows, sending the timeline back to the beginning, etc.). Thankfully, I'd been judicious about saving every few minutes.

As I've reported elsewhere, I still can't get animated text to stay on the screen longer than the animation lasts, which is a program flaw. And I can't find the "make new title based on an old title" feature.

Too, despite the warnings about not screwing around with the workspace layout on the screen, I did, but was never able to get a dual monitor layout that I liked. One of the reasons is that the "Full Screen" button will only put the full screen playback on Monitor 1, so everything had to be put on Monitor 2 -- not my usual way of working.

Also, once a DVD is burned, there seems to be no way to get back into the SHARE/BURN DVD screen again to burn additional copies, so as to use the files that are already rendered. Hitting SHARE/BURN DVD simply produces the "Your DVD has been successfully burned" screen again. (I burned 1 test copy, watched it, and thought I could then burn 4 additional copies.) I guess the trick is to set the number of copies to "5" and watch the first one before inserting the next DVDs.

Throughout the process, I only had to refer to the manual twice -- which really does say something for the intuitiveness of the program (if you're already using a prior PE version).

Overall I'd give my experience with PE4 a "B-." I sort of like it already. Sort of.

Dell XPS desktop w/ Intel i CPU @ ghz / 22 gigs RAM / Radeon HD 1g dedicated video memory/ PrEl 11 & 9 / Photoshop and Illustrator CS5 / After Effects CS4 / Olympus OM-D E-M5 DSLR (i HD video)

Time is money, life is change.

User avatar
Gerry
Senior Contributor
Senior Contributor
 
Posts:
Joined: Mon Feb 19, pm
Location: Minnetonka, MN

Top


Re: Overview of my first PE4 project

Postby Wheat King » Sat Oct 13, pm

Good review Gerry, Thanks!

_

Time and Date Subtitle Generator



NEW VERSION

Time and Date Subtitle Generator is a program that generates a date and time .srt file from the metadata found in AVCHD (.mts) files from HD video cameras. It also contains a tool to batch process a directory of .mts files or an entire directory tree of .mts files and generate corresponding .srt files. The latest version includes an experimental feature to dump all the frame specific metadata to a text file, so that you can examine the hex tags and hex data from you videocam files.

Free software
OS: Win
Version:
Released: Jun 24,
File size: MB
Download

DV_Datecode



NEW VERSION

DV_Datecode is a small tool for Windows, reads the DATACODE(time and date) for each frame in a DV AVI file automatically. The DATACODE is displayed on DV_DataCode's window and there are two files(ssa, sub subtitles files) created which can be used for further processing of the DATACODE in other programs.

Free software
OS: Win
Version:
Released: Feb 18,
File size: MB
Download

TimeDateSRTCreator



NEW VERSION

TimeDateSRTCreator creates a basic subtitle file (.srt) containing the time/date info for any video type supported by MediaInfo. Uses the duration parameter along with creation time for the respective file. Both individual and folder selection is available. Time/date info is defined as a sprers.eu custom string and is fully configurable. Requires sprers.eu 2 (or above).

Free software
OS: Win
Version:
Released: Jun 3,
File size: MB
Download

Video Updater Tools



NEW VERSION

Video Updater Tools is: VideoUpdater - A simple tool used to convert EDL files into Chapters and embed the Chapters (EDL) and Subtitles (SRT) files into MP4, M4V or MKV files. SubtitleExtractor - A simple tool used to extract subtitles (including multiple subtitle tracks) from video files (MKV, MP4, M4V etc) into SRT formatted subtitle files. EDL2Chapter - A simple GUI tool used to validate and convert EDL files into XML and TTXT chapter files. SRTValidate - A simple command line tool used to validate and correct (if possible) SRT files. ToMKV - A simple tool used to convert any Video file into a MKV file container.

Freeware
OS: Win
Version:
Released: Jan 31,
File size: MB
Download

Change Date Time Batch



NEW VERSION

Change Date Time Batch adjusts created/modified windows dates to match the files encoded/tagged metadata which can get altered due to transferring, editing, etc. Also some encoded/tagged data can be incorrect due to being wrong during being filmed such as a camera that had a dead battery and defaulted to manufacturers date. This allows dates to be altered from windows to meta or meta to windows and even has a manual method to set custom dates to either encoded or created. Batch time change all video files.

Freeware
OS: Win
Version:
Released: Feb 8,
File size: MB
Download

WACUP



NEW VERSION Preview

WACUP (Winamp Community Update Project) is an audio player based on Winamp. WACUP (which can be pronounced as wakeup or wac-up or however you prefer it in your native tongue) is designed to work only with the patched Winamp release to provide bug fixes, updates of existing features and most importantly new features with the goal to eventually become it's own highly Winamp compatible media player. WACUP makes use of the benefits of Winamp being heavily based on a plug-in system so new plug-ins can add additional features as well as allowing replacements to be created which provide better implementations over the plug-ins natively included with Winamp. If none of that makes sense, a good way to think about WACUP is that it is like a video game mod where you initially use the original game but then files related to it are added to or edited in-order to provide a better experience.

Freeware
OS: Win
Version: Preview
Released: Mar 11,
File size: MB
Download

DVdate



NEW VERSION

DVdate is a nice utility for all video avi-files, but specially useful when dealing with DV video clips. Retrieve basic video information like the codec, image size, duration, audio format. DV files specific features: retrieve datecode,timecode, type. Rename a video clip with its datecode. Add the datecode or timecode to the name of the video file and also convert a file from DV type 1 to DV type 2 and reciprocally.

FreewareTrialware
OS: Win
Version:
Released: Mar 13,
File size: MB
Download

AVCutty



NEW VERSION

AVCutty is able to capture video material from a DV camera. It saves the videos in AVI files. It also simplifies the splitting of AVI files into the different scenes. It scans the AVI files and detects the scene changes either optically or per DV date stamp. Each scene can be saved into a new AVI file. Because AVCutty does not recompress the video data, the process is lossless. Also it is possible to trim the scenes in a comfortable manner. So, AVCutty is very useful, particularly at the beginning of your video project. Optical scene detection in AVI files, cutting+trimming of scenes/AVIs, splitting+joining of AVIs, export of BMPs, writing scene/AVI index with thumbnails.

Donateware
OS: Win
Version:
Released: Jan 2,
File size: 1MB
Download

LAME MP3



NEW VERSION / ACM

LAME is a MP3 encoder and the Lame ACM MP3 is an ACM codec that you can use in most applications for example in Virtualdub(to install the ACM codec just extract all files and right click on the sprers.eu and select Install). LameDropXPd is a practical frontend for LAME that makes things easier to the user, as there is no need to know about command line usage: most LAME settings are reachable on a graphical interface.

Free software
OS: Win
Version: / ACM
Released: Sep 9,
File size: MB
Download

DV Analyzer



NEW VERSION

DV Analyzer is a technical quality control and reporting tool that examines DV streams in order to report errors in the tape-to-file transfer process, such as video error concealment information, invalid audio samples, timecode inconsistency, inconsistent use of arbitrary bits in video DIF blocks, and DIF structural problems. DV Analyzer also reports on patterns within DV streams such as changes in DV time code, changes in recording date and time markers, first and last frame markers within individual recordings, and more.

Free software
OS: WinMacLinux
Version:
Released: Sep 26,
File size: MB
Download

MythTV



NEW VERSION

MythTV is a project aiming to create a homebrew set-top box. The end goal is to have a nice interface for watching TV, recording shows, listening to music, etc., all displayed on a TV and controlled by a remote. Also video streaming.

Free software
OS: Linux
Version:
Released: Feb 23,
File size: MB
Download

MediaInfo



NEW VERSION

MediaInfo is a convenient unified display of the most relevant technical and tag data for video and audio files. The MediaInfo data display includes: Container: format, profile, commercial name of the format, duration, overall bit rate. Video: format, codec , aspect, frame rate. Audio: format, codec id, sample rate, channels. Text: format, codec id, language of subtitle Chapters: count of chapters, list of chapters.

Free software
OS: WinMacLinux
Version:
Released: Jun 23,
File size: MB
Download

VisualSubSync Enhanced



NEW VERSION

The Visualsubsync Enhanced is a natural enhanced extension of the awesome Visualsubsync by toffparis. It includes new functions like a complete internal filter graph support via mpc-home cinema and lav codecs, online dictionary automatic search (Italian language), new tools for resync, a new tool for progressive desync issues, new updated vsfilter for improved subtitles quality and much more.

Free software
OS: Win
Version:
Released: Jul 28,
File size: MB
Download

Jubler



NEW VERSION

Jubler is a tool to edit text-based subtitles. It can be used as an authoring software for new subtitles or as a tool to convert, transform, correct and refine existing subtitles. Requires Mplayer for previewing video and Java runtime.

Free software
OS: WinMacLinux
Version:
Released: May 31,
File size: MB
Download

OooPlayer



NEW VERSION

OooPlayer is a free audio player for Microsoft Windows. It has a clean, lightweight user interface and it is also friendly with your computer resources. It is one of the best candidates if you look for an alternative to Winamp® or just looking for a simple, easy-to-use music and radio player. The listed versions are clean, without no bundles/installers and it has support for most popular audio formats.

Free software
OS: Win
Version:
Released: Jul 16,
File size: MB
Download

movie thumbnailer



NEW VERSION

movie thumbnailer (mtn) saves thumbnails/screenshots of movie or video files to jpeg files. It uses FFmpeg's libavcodec as its engine, so it supports all popular codecs, e.g. . h/hevc, h, divx h mpeg1 mpeg2 mp4 vc1 wmv xvid, and formats, e.g. .3gp .avi .dat .mkv .wmv. Command line tool(useful for batching) but GUI/Frontend also available.

Free software
OS: WinMacLinux
Version:
Released: Feb 15,
File size: MB
Download

FLVTool2



NEW VERSION

FLVTool2 is a manipulation tool for Macromedia Flash Video files (FLV). FLVTool2 calculates various meta data and inserts a onMetaData tag in the video. It cuts FLV files and adds cue Points (onCuePoint). A debug command shows the inside of a FLV file and the print command gives meta data information in XML or YAML format. Ideal for serverside automatic meta data injection. Command line application.

Free software
OS: Win
Version:
Released: Feb 9,
File size: MB
Download

tsDemux



NEW VERSION

tsDemux/tsdemuxer is a AVCHD/Blu-Ray demuxer. Joins and demuxes HDMV M2TS/MTS (MPEG-2 transport stream) or TS (transport stream) files to Elementary streams. It tries to align tracks and write mkvtoolnix timecode files (tmc), it`s needed for NTSC framerates (29,97 etc.). Demuxer also writes mkvtoolnix chapters file, SRT file and show mkvmerge command example. Command line version and GUI/Frontend.

Free software
OS: WinLinux
Version:
Released: Aug 28,
File size: MB
Download

BitrateCalc



NEW VERSION

BitrateCalc is a bitrate calculator. It is useful for finding appropriate bitrates for encoding video and audio. It is very similar to the popular calculator in MeGUI but has been updated to work standalone. Bitrate Calculator is built with and requires the .NET Client Profile.

Free software
OS: Win
Version:
Released: May 25,
File size: MB
Download

JuceVLC



NEW VERSION

JuceVLC is VLC with a simple MediaCenter-like fullscreen User Interface. Browse and watch movies from your couch with a wireless mouse. This is not mean to be a XBMC killer! It gives a Media Center feel to VLC while keeping the player as lightweight as possible.

Free software
OS: Win
Version:
Released: Mar 24,
File size: MB
Download

youtube-dl



NEW VERSION

youtube-dl is a small command-line program to download videos from YouTube and a several more sites(like Facebook, Twitter, Vimeo, NBC, ABC, CNN, FOX NEWS, etc, see supported sites). If you don't like command line software then get a GUI like youtube-dl-gui. Or from the command prompt just type sprers.eu sprers.eu?v=x8UZQkN52o4 and it will download your youtube video.

Free software
OS: WinLinux
Version:
Released: Dec 16,
File size: MB
Download

Reel Downloader



NEW VERSION

A youtube-dl and Aria2c wrapper which downloads virtually everything! Downloads Playlists at once ! (mp3/mp4 format). Converts downloaded videos to mp4. Pause-Resume dl's (just enter same URL to resume). Builtin update for youtube-dl. No privacy intrusion, home-calls, telemetry, analytics, ads etc. Downloads from virtually any protocols , magnet links / torrent networks with chunked multi connection option!

Free software
OS: Win
Version:
Released: May 5,
File size: MB
Download

xavc rtmd2srt



NEW VERSION

xavc rtmd2srt / x_rtmd2srt is a tool to decrypt real-time (per frame) camera parameters from Sony XAVC S video files as they change during shooting and put them as usual SRT subtitles (to view over video in VLC player). Command line software.


Free software
OS: Win
Version:
Released: Jun 19,
File size: MB
Download

MacYTDL



NEW VERSION

MacYTDL is a macOS GUI front end for youtube-dl the cross-platform video downloader. It runs on any Apple Mac with OS X or later. It has been developed in AppleScript. The code is not protected and can be opened in Script Editor. It is code signed and should pass Gatekeeper.

Free software
OS: Mac
Version:
Released: Jul 25,
File size: MB
Download

PhotoRec



NEW VERSION / Beta

PhotoRec is file data recovery software designed to recover lost files including video, documents and archives from hard disks, CD-ROMs, and lost pictures (thus the Photo Recovery name) from digital camera memory. PhotoRec ignores the file system and goes after the underlying data, so it will still work even if your media's file system has been severely damaged or reformatted.

Free software
OS: WinMacLinux
Version: / Beta
Released: Jul 14,
File size: 20MB
Download

FireDM



NEW VERSION

FireDM is a python open source internet download manager with multi-connections, high speed engine, it downloads general files and videos from youtube and tons of other streaming websites. Developed in Python, based on "pyCuRL/libcurl", "youtube_dl", and "PySimpleGUI". No longer developed?

Free software
OS: WinLinux
Version:
Released: Feb 5,
File size: 54MB
Download

Videomass



NEW VERSION

Videomass is a free, open source and cross-platform GUI for FFmpeg and youtube-dl / yt-dlp, concatenate (mux or encode videos), presets manager, conversions. This video encoder is userfriendly for beginners and more advanced users. Using the step by step interface (GUI) you can simply choose a preset or make your own. For the people that are familiar with FFmpeg there is the possbility to easily make your own presets using the FFmpeg command line or make a preset through the GUI and adapt this to your specific needs. It offers out of the box output to all possible file formats like MP4, MKV, MOV etc. Video: MPEG-4, H/AVC, H/HEVC, VP9 and audio: AAC, MP3, OPUS, WAV, FLAC or AC-3 and subtitles and much more! Also you can copy streams (lossless video and/or audio) and extract audio. Finally it has a simple timeline editor, extended multimedia information and optional youtube downloader.

Free software
OS: WinMacLinux
Version:
Released: May 3,
File size: 67MB
Download

Powder Player



NEW VERSION

Powder Player is a video player that supports torrents, over websites and local media. Offers casting to Chromecast and AppleTV, auto-fetching subtitles, detailed information about items and much more. It can do everything that a Torrent Client can, everything that a Video/Audio Player can and much more! No longer updated ?!?

Free software
OS: Win
Version:
Released: May 31,
File size: MB
Download

DVD Shrink



NEW VERSION

DVDShrink is a free software to backup DVD disks. You can use this software in conjunction with DVD burning software of your choice, to make a backup copy of any DVD video disk. DVD Shrink is no longer updated. If you have trouble ripping use the free DVDFab Decrypter to rip and then use DVD Shrink to shrink it.

Freeware
OS: Win
Version:
Released: Jul 25,
File size: 1MB
Download

ImageGrab



NEW VERSION

ImageGrab is a powerful and user-friendly software that opens all kinds of video files and allows to extract images either in the format bmp, or in jpeg with a quality adjustable. It also allows you to copy them to the clipboard so as to use them in your favorite application.

Freeware
OS: Win
Version:
Released: Mar 13,
File size: MB
Download

AVI ReComp



NEW VERSION

AVI ReComp allows you to recompress your AVI files. Uses only XviD codec to recompression process. AVI ReComp can be very useful for users who want to clear their AVIs out of GMC or Qpel functions to prepare the clips for standalone DVD players. The program contains a feature of embedding/hardcode subtitles into video.

E-Book Overview

Successful businesses and organizations are continually looking for ways to improve service and customer satisfaction in order to achieve long-term customer loyalty. In light of these goals, software developers must ask the question: how does customer orientation influence traditional approaches, methods, and principles of software development? In this book, a leading software architect and his team of software engineers describe how the idea of customer orientation in an organization leads to the creation of application-oriented software. This book describes what application-oriented software development is and how it can be conceptually and constructively designed with object-oriented techniques. It goes further to describe how to best fit together the many different methodologies and techniques that have been created for object-orientation (such as frameworks, platforms, components, UML, Unified Process, design patterns, and eXtreme Programming) to design and build software for real projects. This book brings together the best of research, development, and day-to-day project work to the task of building large software systems.

*Written by and for developers of large, interactive, and long-lived software systems
*Includes patterns of proven analysis, design, and documentation techniques
*Shows how to develop an appropriate design approach and concrete software development techniques

E-Book Content

Object-Oriented Construction Handbook

This page intentionally left blank

sprers.eu

31/8/04

PM

Page iii

Object-Oriented Construction Handbook Developing Application-Oriented Software with the Tools & Materials Approach

Heinz Züllighoven IT-Workplace Solutions, Inc., and University of Hamburg, Germany With contributions by as co-authors Dirk Bäumer Petra Becker-Pechau Holger Breitling Ute Bürkle Rolf Knoll Anita Krabbel Daniel Megert Dirk Riehle Axel Schmolitzky Wolfgang Strunk Henning Wolf

as lead authors Robert F. Beeger Wolf-Gideon Bleek Guido Gryczan Carola Lilienthal Martin Lippert Stefan Roock Wolf Siberski Thomas Slotos Dirk Weske Ingrid Wetzel

AMSTERDAM ● BOSTON ● HEIDELBERG ● LONDON ● NEW YORK ● OXFORD PARIS



SAN DIEGO



SAN FRANCISCO



SINGAPORE



SYDNEY



TOKYO

MORGAN KAUFMANN PUBLISHERS IS AN IMPRINT OF ELSEVIER

HEIDELBERG

Copublished by Morgan Kaufmann Publishers and sprers.eu Morgan Kaufmann Publishers sprers.eu Senior Editor: Tim Cox Senior Editor: Christa Preisendanz Publishing Services Manager: Simon Crump Project Manager: Brandy Palacios Editorial Assistant: Richard Camp Cover Design: Frances Baca Design Cover Image: Montage of tools in boxes, courtesy of Digital Vision and Getty Images Text Design: Julio Esperas Composition: Newgen Imaging Systems Technical Illustration: RDC Tech Translators: Angelika Shafir, Bob Bach Copyeditor: Harbour Fraser Hodder Proofreader: Graphic World Inc. Indexer: Graphic World Inc. Interior printer: The Maple-Vail Book Manufacturing Group Cover printer: Phoenix Color Corp. Morgan Kaufmann Publishers is an imprint of Elsevier. Sansome Street, Suite , San Francisco, CA Available in Germany, Austria, and Switzerland from sprers.eu Ringstraße 19B Heidelberg, Germany sprers.eu © by Elsevier Inc. (USA) and sprers.eu (Germany) Designations used by companies to distinguish their products are often claimed as trademarks or registered trademarks. In all instances in which Morgan Kaufmann Publishers is aware of a claim, the product names appear in initial capital or all capital letters. Readers, however, should contact the appropriate companies for more complete information regarding trademarks and registration. No part of this publication may be reproduced, stored in a retrieval system, or transmitted in any form or by any means—electronic, mechanical, photocopying, scanning, or otherwise-without prior written permission of the publisher. Permissions may be sought directly from Elsevier’s Science & Technology Rights Department in Oxford, UK: phone: (+44) , fax: (+44) , e-mail: [email&#;protected] You may also complete your request on-line via the Elsevier home-page (sprers.eu) by selecting “Customer Support” and then “Obtaining Permissions.” Library of Congress Cataloging-in-Publication Data Application submitted MK ISBN: dpunkt ISBN: This book is printed on acid-free paper. For information on all Morgan Kaufmann publications, visit our website at sprers.eu Printed in the United States of America 04 05 06 07 08 5 4 3 2 1

CONTENTS

Preface

1

xvii

Introduction



APPLICATION ORIENTATION — THE SUBJECT OF THIS BOOK Motivation 1 Structure of This Book 3 THE TOOLS & MATERIALS APPROACH (T&M) The T&M Approach in a Nutshell 4 T&M As a Method 8

4





PROJECTS BEHIND THIS BOOK



The Scope of the T&M Projects

9 10

THE EQUIPMENT MANAGEMENT SYSTEM EXAMPLE REFERENCES 15

14

2 The T&M Object Metamodel

THE OBJECT METAMODEL

17

Introduction 17 Definition: The Object Metamodel 18 Context: What’s the Purpose of an Object Metamodel? 18 Context: A Classification of Programming Languages 19 The Object Metamodel and the Software Model 20 Definition: Objects 20 Discussion: Object Identity 24 T&M Design: Structuring an Interface 25 Definition: Classes 25 Discussion: Generic Operations 27 T&M Design: Generic Operations 27 Discussion: The Object Life Cycle 28 T&M Design: The Object Life Cycle 29

1

vi

CONTENTS



MODULARIZATION



TYPES





38

40 Introduction 40 Definition: Types 41 Context: The Theoretical Concept of Types Discussion: Types 42



41

43

Introduction 43 Classes in Your Design 43 Differences between Types and Classes 43 Discussion: Classes versus Types 44 Background: Programming Languages and Types T&M Design: Classes and Types 45

VALUES AND OBJECTS

36

Introduction 38 Definition: Contract Model 38 Discussion: The Contract Model 39 Context: The Contract Model and Abstract Data Types T&M Design: The Contract Model 40

CLASSES AND TYPES

35

36

Introduction 36 Context: Modules and Object Orientation Definition: Principles of Object-Oriented Modularization 37

THE CONTRACT MODEL



Definition: Inheritance 30 Discussion: Inheritance 30 T&M Design: Inheritance 31 Discussion: Role Relationships as an Alternative to Inheritance 32 Definition: Use Relationships 32 Discussion: Use Relationships 33 Definition: Polymorphism 33 Definition: Abstract Classes 34 Discussion: Specification and Implementation Definition: Loose Coupling 35 Discussion: Loose Coupling 36

45

Introduction 45 Characteristics of Values and Objects 46 Using Values 47 Context: Values and Objects in Programming Languages 48 Definition: Domain Values 49

44

39

CONTENTS



METAOBJECT PROTOCOLS



T&M Design: Domain Values Implementing Domain Values

49 49

50

Introduction 50 Motivation for a Metaobject Protocol 51 Definition: Metaobject Protocol (MOP) 51 Representing Your Application Model 51 Representing Your Runtime System 53

REFERENCES

55

3 Guiding Metaphors and Design Metaphors

INTRODUCTION

DESIGNING APPLICATION SOFTWARE Definition: The Usage Model 58







Background: Methodology Books versus Design Guidelines 58

Background: Guiding Metaphors in Software Development 60 The “Object Worlds” Guiding Metaphor 60 The Direct Manipulation Guiding Metaphor 61 Discussion: Guiding Metaphor of Direct Manipulation The Guiding Metaphor of the Factory 62 Discussion: The Factory Guiding Metaphor 62

DESIGN METAPHORS



57

GUIDING METAPHORS FOR APPLICATION SOFTWARE 59



57

Definition: Metaphors

61

63 63

T&M GUIDING METAPHORS AND DESIGN METAPHORS 64

A T&M Guiding Metaphor: The Expert Workplace Background: The Supportive View 65 Discussion: Metaphors and Patterns 66 Definition: A Tool 67 The Tool as a Design Metaphor 67 T&M Design: Software Tools 67 Definition: Material 68 Material as a Design Metaphor 68 T&M Design: Software Materials 68 Definition: The Work Environment 69

64

vii

viii

CONTENTS



4

69

73

WORKPLACE TYPES



The Work Environment as a Design Metaphor T&M Design: The Work Environment 70 Definition: Automatons 70 The Automaton as a Design Metaphor 70 T&M Design: Software Automatons 71 Definition: The Container 71 The Container as a Design Metaphor 72 T&M Design: Containers 72 Discussion: Design Metaphors 73

Definition: Workplace Types 74 T&M Design: The Expert Workplace Type 74 T&M Design: The Functional Workplace Type 74 T&M Design: The Back-Office Workplace Type 75 T&M Design: The Electronic Commerce Frontend Workplace Type 76

77

REFERENCES

Patterns, Frameworks, and Components 79



INTRODUCTION



BACKGROUND: PATTERNS, FRAMEWORKS, AND COMPONENTS 80



PATTERNS



80

Definition: Patterns 80 The Characteristics of a Pattern 81 A Taxonomy of T&M Patterns 83 Conceptual Patterns 83 Design Patterns 84 Programming Patterns 85 T&M Design: Design Patterns 86 T&M Design: Models, Metaphors, and Patterns Background: Pattern Form 88 T&M Design: Pattern Form 88 Pattern Collections 89

FRAMEWORKS

86

90

Background: Class Libraries 90 Definition: Frameworks 91 Application Frameworks 91 Black-Box and White-Box Frameworks 92 Connectors between Frameworks 94 JWAM Framework: Layered Framework Architecture

95

CONTENTS



COMPONENTS



5

REFERENCES

96

99

Application-Oriented Software Development



INTRODUCTION



APPLICATION-ORIENTED SOFTWARE Application Software







Definition: Application Orientation Background: Application Orientation Usage Quality T&M Design: Structural Similarity

THE DEVELOPMENT PROCESS

6

96

Background: Software Components Definition: Components 97 Current Component Products 98 Components and Frameworks 98



Definition: Software Development The Application-Oriented Development Process Discussion: The Development Process The Author-Critic Cycle Discussion: The Author-Critic Cycle Evolutionary System Development Documentation in Software Development Discussion: Documentation Application-Oriented Development Documents Discussion: Application-Oriented Document Types T&M Design: Application-Oriented Document Types Discussion: T&M Document Types Project Documents Documentation Guidelines

REFERENCES



Software Development as a Modeling Process

INTRODUCTION

A SIMPLIFIED SOFTWARE DEVELOPMENT MODEL





Discussion: A Descriptive Software Development Model

THE APPLICATION DOMAIN



Definition: Application Domain Discussion: Analyzing the Application Domain





ix

x

CONTENTS



THE DOMAIN MODEL







Definition: The Application System Discussion: The Application System



Discussion: Software Development Contexts The Application Domain Context Discussion: The Application Domain Context Applied Technique Handling and Presentation Discussion: Handling and Presentation

CONTEXTS INFLUENCING THE SOFTWARE ARCHITECTURE







SOFTWARE DEVELOPMENT CONTEXTS



Context: The Application System Model Definition: Application System Model Discussion: Structural Similarity and Macrostructures

THE APPLICATION SYSTEM





THE APPLICATION SYSTEM MODEL





Modeling Your Application Domain Discussion: Modeling Your Application Domain

Discussion: How Contexts Influence Your Software Architecture

REFERENCES



7 T&M Conceptual Patterns



CONCEPTUAL PATTERNS

Conceptual Patterns in the Development Process The T&M Conceptual Patterns





A GUIDED TOUR OF THE T&M CONCEPTUAL PATTERNS



THE INTERRELATION OF TOOLS AND MATERIALS PATTERN





THE MATERIAL DESIGN PATTERN



THE TOOL DESIGN PATTERN



THE WORK ENVIRONMENT PATTERN



THE CONTAINER PATTERN



THE FORM PATTERN



THE AUTOMATON PATTERN



THE DOMAIN SERVICE PROVIDER PATTERN







CONTENTS

8



THE TECHNICAL AUTOMATON PATTERN



THE PROBE PATTERN



THE ADJUSTING TOOL PATTERN





T&M Design Patterns



INTRODUCTION



A GUIDED TOUR OF THE T&M DESIGN PATTERNS



THE ASPECT PATTERN



THE TOOLS COMPOSITION PATTERN





Construction Part: Using Components to Build Tools Construction Part: Using Components to Build Combination Tools Construction Part: Identifying Tool Boundaries

THE FEEDBACK BETWEEN TOOL PARTS PATTERN Construction Part: Event Pattern Construction Part: Event Objects Construction Part: Chain of Responsibility







Construction Part: Using Inheritance or Interfaces to Implement Aspects Construction Part: Using Object Adapters to Implement Aspects Construction Part: Using Development Tools to Realize Aspects Construction Part: Alternatives to Using Aspects

THE SEPARATING FUNCTION AND INTERACTION PATTERN





Construction Part: Tool Component with Reaction Mechanisms

THE SEPARATING FP AND IP PATTERN



Construction Part: Interactive Part (IP) Construction Part: FP





THE SEPARATING HANDLING AND PRESENTATION PATTERN



THE FEEDBACK BETWEEN INTERACTION FORMS AND IP PATTERN

THE DOMAIN VALUES PATTERN



Construction Part: Domain Value Classes Construction Part: Immutable Domain Value Objects Construction Part: Mutable Domain Value Objects

xi

xii

CONTENTS Construction Part: Implementing Domain Values as Streams Construction Part: Domain Value Types by Configuration





THE DOMAIN CONTAINER PATTERN

Construction Part: Using Technical Containers to Implement Domain Containers Construction Part: Loading Materials Construction Part: Tables of Contents for Containers Construction Part: Implementing Tables of Contents as Materials Construction Part: Implementing Tables of Contents as Domain Values Construction Part: Coping with Changes to Containers

THE FORM SYSTEM PATTERN



THE AUTOMATONS IN TECHNICALLY EMBEDDED SYSTEMS PATTERN THE DOMAIN SERVICES PATTERN THE ENVIRONMENT PATTERN



USING THE T&M DESIGN PATTERNS FOR THE JWAM FRAMEWORK Materials Construction Tools Construction Domain Values Presentation and Interaction Forms Forms Domain Services Work Environment

REFERENCES



9 T&M Model Architecture



THE T&M MODEL ARCHITECTURE



THE DOMAIN CORE OF A SOFTWARE ARCHITECTURE The Use Context The Product Domain The Business Domain How Different Domains Relate



CONCEPTS AND ELEMENTS OF A T&M MODEL ARCHITECTURE



CONTENTS

Components of an Object-Oriented Software Architecture Elementary Rules for Combining Elements of a Software Architecture Protocol-Based Layer Architectures Object-Oriented Layer Architectures The Layer Concept of the T&M Model Architecture The Three-Tier Architecture The T&M Model Architecture



DESIGN PATTERNS FOR THE T&M MODEL ARCHITECTURE The Role Pattern The Product Trader Pattern



REFERENCES





10 Supporting Cooperative Work BACKGROUND: COMPUTER-SUPPORTED COOPERATIVE WORK CSCW Technical and Domain Transparency

IMPLICIT COOPERATION





EXPLICIT COOPERATION BY EXCHANGING MATERIALS Cooperation Medium: Mailboxes Cooperation Medium: Mailing System



EXPLICIT COOPERATION MODEL: TRANSACTION PROCESSING SUPPORT The Concept of Process Patterns Cooperation Medium: Routing Slips REFERENCES



11 Interactive Application Systems and Persistence

BACKGROUND: INTERACTIVE APPLICATION SYSTEMS

PERSISTENCE SERVICES



Software Registry The Basic Concept of a Software Registry Cooperation Model for a Registry



xiii

xiv

CONTENTS Usage Model for a Registry JWAM: Architecture for a Software Registry The Generic Persistence Service



DESIGN CRITERIA TO IMPLEMENT PERSISTENCE Client-Server Architecture Identifiers

Technical Data Modeling and Structural Mapping Querying and Data Warehousing Load-on-Demand Transactions and Locking Class Evolution Legacy Databases





REAL-WORLD EXAMPLES JWAM Projects MedIS and SyLab

12 The Development Process BACKGROUND: EVOLUTIONARY AND TRADITIONAL PROCESS MODELS The Context of Our Process Model The Process Model’s Application Orientation The Classic Waterfall Model The Spiral Model An Idealized Evolutionary Process Model TOPICS FOR A DEVELOPMENT STRATEGY Sequence of Development Activities Objectifying the Development Process Lehman’s Software Classification The Cooperative Development Process Organizational and Domain Integration Developing an IT Organization QUALITY ASSURANCE IN THE DEVELOPMENT PROCESS Direct User Integration Prototyping Reviews Pair Programming Refactoring QUALITY ASSURANCE IN CONSTRUCTION Characteristics of OO Testing Testing OO Programs



CONTENTS

PROJECT MANAGEMENT



Fundamental Activities of the Management Process The Contexts of the Management Process

PROJECT PLANNING CONCEPTS AND TECHNIQUES Project Calibration Project Goals Decision Principles Project Establishment STRUCTURING A PROJECT BY SYSTEM DECOMPOSITION Core System and Special-Purpose Systems Core System and Extension Levels

SCHEDULING AND TASK PLANNING





General Rules for Time Estimates Planning the Project Stages Using Base Lines for Detailed Planning The UP and T&M Project Planning



DISCUSSING T&M, UNIFIED PROCESS, AND XP

Structure of the UP and T&M Development Processes





REFERENCES

13 T&M Document Types SCENARIOS



Using Scenarios in the Development Process Subtypes of Scenarios Scenarios and UML

INTERVIEWS





The Interview Process

THE CONCEPT MODEL





Using a Concept Model in the Development Process Concept Models and UML

GLOSSARIES



Using a Glossary in the Development Process Glossaries, UML, and UP

SYSTEM VISIONS







Using System Visions in the Development Process System Visions and XP System Visions and UML



xv

xvi

CONTENTS

PROTOTYPES



Using Prototypes in the Development Process Prototypes and UP

COOPERATION PICTURES



Cooperation Pictures in the Development Process Cooperation Pictures and UML Using Purpose Tables in the Development Process Purpose Tables and UML

TECHNICAL DOCUMENT TYPES IN UML Class Diagrams Object Diagrams Use Case Diagrams Interaction Diagrams Statechart Diagrams Activity Diagrams Component Diagrams Deployment Diagrams









Application-Oriented and Technical Documents

Index





PURPOSE TABLES

REFERENCES





P R E FAC E

We have written this book because developing good application software is so hard to do. We have been trying to develop good application software for more than a decade, and we wrote this book because we hope to give some help to those who realize that technology and tools are not enough to develop good software. This is a book about application orientation, which means structuring large interactive software systems along the concepts, interactions, and relations of an application domain. But this also means organizing software projects so that domain experts—the potential users—can actively participate and shape the future system. And, last but not least, it means using metaphors to analyze, design, use, and talk about systems. We have worked on the idea of application orientation for many years and have used it in a large number of commercial and scientific projects. Over the years we have collected a repertoire of metaphors, concepts, techniques, strategies, patterns, and best practices for designing and constructing software and for managing and conducting projects. This collection, together with a specific way of looking at software development, we call the Tools & Materials approach (T&M).

0 .1 T H E R E A D E R This book is intended for the following target groups: ● ● ● ●

Software developers Project managers Computer science students Method developers

It is neither a programming textbook nor a book about GUI design.

Target Groups Now, in more detail, who are the readers who will benefit from this book? Admittingly, we were quite ambitious, as we defined several target groups: ●

Experienced practitioners who develop object-oriented application software. By our definition, they are familiar with at least one popular object-oriented language, disposing of basic project experience. They feel challenged to develop

Practitioners

xvii

xviii

P R E FAC E

Project managers



Students



Method developers



new components or frameworks in future projects, use existing frameworks, and integrate ready-made components. They understand the fundamental meaning of design patterns. With this background, experienced practioners are looking for an approach that allows them to combine and embed different—both old and new—concepts and technologies with their own experience to form a suitable approach. This book is intended to provide answers for experienced developers and “software architects” who have different questions relating to the design and construction process. To this end, we have tried to put our concepts and experiences together in the form of patterns and have arranged these patterns as collections in the relevant chapters of this book. The example used throughout this book, and its implementation with a Java framework, “the application example” will show how large-scale application software can be developed. Finally, we will explain how these concepts and construction approaches can be represented in an iterative and document-driven development process. Experienced project managers running object-oriented projects who are keen to learn the ideas of an evolutionary approach, but who are looking for a feasible and reproducible project organization. They have found that rigid waterfall models merely create the illusion of a controllable project. They know that technical software know-how and tools are useless unless you also have some applicationspecific knowledge. They also understand that you cannot achieve persistent software development and high usage quality of your products unless you have technical concepts and excellent tools. They probably have explored the Unified Modeling Language (UML) and the Unified Process and have heard contradictory rumors about agile processes like eXtreme Programming. They may wonder how these technologies can be used in a specific project. We have elaborated concepts, guidelines, and document types for these project managers to help them prepare their own application-oriented approach for their teams and the entire organization. Our approach attempts to combine the proven strategies of evolutionary software development with useful aspects of agile processes. We thereby hope to achieve precise planning, high flexibility for changes, and constructive quality assurance. Committed students who have a solid education in computer science and are looking for an integrated view of all aspects involved in object-oriented software development. They have studied relevant technical tools and know how to write code in an object-oriented language. Though they know the UML notation, they may have used it only in small examples. In this book we try to show such students our approach from practical experience, where our patterns will be useful. In teaching software engineers, we have often found that much depends on direct cooperation and joint experience in real-world projects. However, this is not sufficient. Our systematic and annotated collection of patterns in this book will help the student to grasp an overall view of design and construction problems. Again, we will use an example showing how to implement methodological and technical ideas in UML notation in order to build real-world projects. Critical method developers who are challenged to select and tailor methods for use in real-world projects. They are probably interested in getting a detailed insight into the extent of the T&M approach and in order to estimate whether or not

THE READER

xix

this approach can be transported to their use contexts. We think that purely conceptual representations are not sufficient, so we attempt in this book to collect current knowledge and opinions from various groups and experts working actively in promoting the T&M approach. The contents of this book will give experienced method developers an overview of the lessons learned in this approach. Who should not read this book? ●





Beginning programmers who are interested in learning an object-oriented language like Java. This book is not a programming textbook. All programming examples included in the text itself are only sketches to illustrate construction ideas. For this reason, they are not even good examples of particularly “clever” constructions in a respective programming language. They are designed for experienced programmers who will know how to transport these examples into their own contexts. Since we want to focus on the concept behind constructions, this book does not include extensive code examples. Instead, we often use only class or interaction diagrams. The full code example can be downloaded at sprers.eu Readers with no programming experience will find most of these constructions hard to understand. User interface designers who want to learn more about designing sophisticated graphical user interfaces for object-oriented software. We discuss the overall design of interactive software within the frame of a comprehensive usage model. We illustrate this aspect/approach by showing the basic ideas of combining functionality, interaction schemes, and GUI elements. As the actual GUI design is not important for this discussion, our screenshots of user interfaces show very simple examples. From the viewpoint of software ergonomics, they may look rough or clumsy. Elaborate user interfaces are an advanced topic in their own right and are beyond the scope and purpose of this book. IT managers interested in gaining an overview of object orientation. This book does not answer questions like “What is object orientation?” or “Is object orientation suitable for real-world projects?” This book assumes that such questions have been answered and understood. Even the sections in the first part of this book that discuss these concepts are intended for an advanced exploration of object orientation.

What are the prerequisites needed to profit from reading this book? ● ● ●



Fundamental knowledge of software engineering. Knowledge of programming in an object-oriented language. “Access” to Design Patterns by Gamma et al.;1 this seminal work on design patterns has coined the lingo of object-oriented software developers all over the world. We also deal extensively with the patterns described in Gamma’s work and reference them in our own design patterns. Access to a book about UML notation.2 Though we will explain our own interpretation of UML, we will introduce the notation only briefly.

1. E. Gamma, R. Helm, R. Johnson, J. Vlissides: Design Patterns. Reading, Mass.: Addison-Wesley, 2. For example see, G. Booch, J. Rumbaugh, I. Jacobson: The Unified Modeling Language. Reading, Mass.: Addison-Wesley,

Not a programming textbook

Not a user interface design guideline

Not a general introduction to object orientation

How to profit from this book

xx

P R E FAC E

GUIDELINES FOR USING THIS BOOK This section explains how to use this book and what its various parts mean. We recommend different ways to read this book for each of our target groups.

Different Ways to Read This Book Reference guide

Pattern-type organization

This book is conceived as a reference guide, ordered by topic. The first German edition demonstrated that formulating each chapter independently, that is, each with its own self-contained topic, was a good idea. References to other chapters are intended to represent further reading on a specific issue. Chapters 7 and 8 are built as pattern collections. Of course, each chapter makes a different presumption of the reader’s knowledge of the topic dealt. But in general, interested readers will find answers to their questions in each chapter without having to read the entire book. On the other hand, nothing in this book prevents you from reading it consecutively from beginning to end. We arranged the chapters so that you should be able to identify some direction of development. We also hope that there are not too many irritating redundancies. However, since this book was mainly designed as a reference guide, there may be some redundancies, which is another reason why we opted for a the pattern form of organization rather than a strictly linear exposition. Chapters 7 and 8 of this book are organized as pattern collections in the sense of the familiar design patterns. At the beginning of Chapter 7, we will introduce the pattern form to be used. You will also find a pattern-type structure in the rest of this book, which, we thought would facilitate reading. In general, we used the following structure for this book. ●









Introduction This section is a short summary of what the chapter discusses and what the special lessons to be learned are. It often includes a note about the target group that would profit most from that section. Definition This section defines important terms introduced in the chapter. Background This section contains background information, that is, it reports about the state of discussion on the issue concerned. It also includes historical comments or cross-references to other topics. This section provides food for thought and is aimed at readers interested in getting more detail on a topic. Discussion This section discusses concepts introduced in the chapter as well as the pros and cons of the solutions. T&M Design This section gives instructions for the specific development process. It normally includes recommendations as well as positive and negative experiences gained from real-world projects.

GUIDELINES FOR USING THIS BOOK

xxi

Recommended Reading by Target Group Experienced practitioners should read the following sections: ●





The first part of this book is conceptual and forms the basis for a common language between the authors and their readers. Experienced developers will find the terms and concepts used throughout this book. The basic terms and definitions pertaining to object orientation are clarified in Chapter 1. On this foundation, we go on to explain and complete the concepts of the T&M approach in Chapters 2 to 5 in order to establish a common language for development teams. Chapters 7 and 8 include conceptual and design patterns that have been completed by construction approaches for interactive software, thus it represents the most important part of the book for experienced practitioners. Depending on the issues and problems of concern, they then will focus on particular sections of Chapters 9 to 11 and deal with the implemented example extensively. Chapters 12 and 13 look at the process side of our approach. They explain how to get the T&M approach working. They also include our proposals for dealing with application-oriented document types and their correspondence to the UML notation. Thus this is also a particularly interesting part of the book for developers.

Software developers

Project managers

Project managers should read the following sections: ●





This target group will find sections on models and design metaphors, applicationoriented software development, and software development modeling in Chapters 2 to 5 of this book. They will learn what the T&M approach is meant to be. This target group can skip Chapters 7 to However, project managers will find useful definitions of terms. The last two chapters of this book are conceived for project managers interested in implementing an evolutionary document-driven approach in a planned and controlled way. In Chapter 11 they will find the principles as well as various techniques and strategies of our iterative evolutionary process. They will see how this process fits in with relevant and proven aspects of agile processes like eXtreme Programming. Chapter 12 introduces the appropriate document types. Managers will learn how UML can be taken to work within an evolutionary strategy and where additional application-oriented document types make sense.

Students should read the following sections: ●



The first 6 chapters provide the defining basis. Students can check whether or not their knowledge will allow them to understand our concepts. It is necessary to read this part of the book to better understand the rest of our discussion. This target group should work through Chapters 7 and 8 systematically, because the pattern collection represents a step-by-step introduction to building interactive software. In addition, they should analyze the corresponding examples. The other chapters discuss advanced issues that this target group may read as needed or according to their interests.

Students

xxii

P R E FAC E ●

This target group can read Chapters 12 and 13 selectively; they deal mainly with aspects of using notations for application-oriented modeling and applying this approach in evolutionary and cyclic project models.

Method developers should read the following sections: Method developers







The EMS example

Practical project examples

Programming languages and notations used in this book

The first 6 chapters provide an important overview of the basic concepts of the T&M approach, but method developers can skip Chapter 1, which deals with the object metamodel. Of particular interest for this target group is Chapter 7, because it explains our design approach. We recommend that developers read Chapters 12 and

The Equipment Management System (EMS) example described below is used throughout this book. We intentionally kept this example small and easily manageable so that readers would be able to understand its professional and technical aspects. This example, which appears in various places in the text of this book, serves to illustrate the basic idea of the T&M approach. Note that we have not even tried to turn this example into a “realistic” application system. This holds true both for the Java code and for the user interface examples we use. They primarily serve as simple and clear illustrations of the issue we are introducing. Thus they are neither meant to be efficient code nor good interactive GUI designs. A complete implementation in Java, using the JWAM Java framework, can be downloaded from the website of this book.3 Whenever we discuss the EMS example we denote our discussion by a note in the margin. We tried to create a “real-world look and feel” to our book by using examples from our project practice. For example, we repeatedly describe designs produced for banks, insurance companies, or hospitals. Again, we will highlight each example in the margin. To build the examples included in this book, we used mainly Java and some C and Smalltalk as programming languages. As mentioned above, we have no intention to teach programming in these languages. We used these popular programming languages so that the reader will get an impression of how a construction might look in the respective language. The notations used in this book are based on the de facto standard defined in UML (Version ). We assume that most of our readers are familiar with these notations. Chapter 12 includes a description of the notations and the special variants used in this book.

THE WRITING PROCESS AND SOURCES This section explains how we wrote this book and the sources involved. It makes clear that the writing of this book was motivated mainly by two goals: first, to bring together the practical work and experience of many different people from many professional contexts, and second, to produce a uniformly designed and written work.

3. sprers.euions//.

THE WRITING PROCESS AND SOURCES

Motivation for This Book We developed our particular way of writing and publishing a book during our work on the first German edition. Since we first published a comprehensive presentation of the T&M approach in , much has happened, which naturally pleases us. Many design discussions in various cooperation projects, new design ideas, and a changing technical foundation all had their influence on the T&M approach. We held discussions in different contexts and assessed our experiences. In , the time was right for a design and construction book on the T&M approach. This book reflects our view of the state of the art. However, several years have passed since the publication of the German edition, and many new results have accumulated. Therefore, this English edition has been completely revised, but in it we still use an editorial concept similar to that in the first German edition: Lead authors: We agreed on a list of core topics. Each topic was accepted by one or two persons in the role of lead authors. They fully revised this text and coordinated the work of the other authors. Coauthors: Each coauthor contributed essentially to this book. This can mean that he or she was an author (or lead author) of the German edition, or that he or she made a major contribution to the English edition. Primary author: Beyond authoring major parts of this book, Heinz Züllighoven edited all sections of the book, ensured uniform style, and established cross-references. Translator: American native speaker Angelika Shafir translated and adapted the German text to English. All modifications made in the course of the translation were discussed with the lead authors and the primary author, in order to minimize semantic shifts from translation. Editor: Tim Cox served as the editor for this edition of the book for the publisher. We discussed with Tim the concept of the revision for this edition as well as the readability and coherence of every chapter after its translation. Stacie Pierce, Richard Camp, Mamata Reddy, Brandy Palacios, and Suzanne Kastner then greatly helped to bring the manuscript into production. Reviewers: After translation, every chapter was reviewed by specialists in the field. These reviewers contributed significantly to the second round of revisions. With this rather complicated and labor-intensive editing and translation process, we hope to have done justice to the various contributors and their contributions to the development of the T&M approach without denying the reader a book with uniform style.

Sources The coauthoring arrangements do not by a long shot cover all sources of the T&M approach for this book. Therefore, we list here those persons whose publications and ideas also contributed significantly to this book. Since many of these sources were published in German only, we do not provide a detailed list of references. First, we want to mention the spiritual fathers of the ideas behind the T&M approach: Reinhard Budde and Karl-Heinz Sylla.

The editorial concept

xxiii

xxiv

P R E FAC E

The following people, with their dissertations and theses contributed greatly to the further development of the T&M approach: Christian Beis, Holger Bohlmann, Marlies Eschner, Malter Finsterwalder, Boris Fittkau, Frank Fröse, Michael Gatzhammer, Achim Gehrke, Thorsten Görtz, Andreas Hartmann, Andreas Havenstein, Andreas Kornstädt, Holger Koschek, Timm Krauß, Sven Lammers, Klaus Müller, Lara Niemeyer, Fabian Nilius, Björn Ostermann, Michael Otto, Jörg Penning, Thomas Pfohe, Sabine Ratuski, Joachim Sauer, Norbert Schuler, Michael Skutta, Eike Steffen, Olaf Thiel, Horst-Peter Traub, Matthias Witt, and Ulfert Weiss.

Introduction

1

1 .1 A P P L I C AT I O N O R I E N TAT I O N — THE SUBJECT OF THIS BOOK Recent major changes in global markets have encouraged, if not forced, many corporations to review their corporate strategies, with “customer orientation” being the ubiquitous catchword. This section discusses the motivation behind customer orientation, what it means, and why it requires a new approach toward software development—the application orientation. This discussion demonstrates that application orientation relates both to software products and how projects should be managed.

Motivation The global economic environment has motivated many companies to orient themselves more closely to their customers. Customer wishes, requirements, and expectations are central factors in your corporate strategy, and products and services have to be tuned to this environment. The more individual you want your products and services to be, the more specialized the application systems you use in your organization have to be. This flexibility translates into high demands on any software development project. Does this sound far-fetched? Not really. In fact, these could be the introductory words of a speech about the Tools & Materials Approach (T&M). They could provide the economic background to motivate potential listeners or readers in an intuitive way to deal with this approach. Note, however, that these words mean more than just a marketing strategy. Customer orientation not only has become one of the modern catchwords in the business but is also a term expressing a visible change in many organizations. Customer orientation means understanding that for an organization to be successful in the current harsh economic climate, it has to distinguish itself from its competitors, and customer orientation is what can help it achieve this goal. As Peters and Waterman have observed, customer orientation may have been the trigger that released the current reorganization processes for the following reasons: ●



Customer orientation

Competition is becoming increasingly fierce, so that corporate managers are forced to rethink their assumptions. Many products and services are introduced to the markets, so that a large number of these become interchangeable from the customer’s perspective. 1

2

INTRODUCTION ●



Application orientation

Large-scale application software

Poor service drives customers away, while many organizations overlook the fact that the acquisition of new customers is generally more expensive than keeping their existing customer base. Companies increasingly look for ways to distinguish themselves with aboveaverage service or additional service offers to win more satisfied customers and a more loyal customer base.

In this tense situation, customer orientation translates into a continuous effort to improve customer satisfaction in order to achieve long-term customer loyalty and ensure the company’s success. As a consequence, success-oriented organizations have been critically reviewing their work processes, organizational structures, and corporate strategies. One of the most important factors within this reorientation effort is information technology. It has quickly become clear that information technology must only be a means to an end and never an end in itself. In the field of software development, this scenario challenges us to ask how traditional approaches, methods, and principles can contribute to customer orientation. The practitioner does not normally have a clear answer to this question, encountering serious doubts when taking a closer look at the technologies and tools used in the real world. Can new products and approaches give rise to hope for a decisive improvement of the current situation? When observing the current euphoria about Java and J2EE, application servers, and Internet services, you may easily think so. The authors of this book are more critical. Methods, technologies, and tools are just the means to an end. We think that the idea of customer orientation in an organization should lead to application-oriented information technology. This means that an organization’s staff can act in a customer-oriented way provided that they have the corresponding technical support at the workplace. Let’s look at application software as a relevant and integral part of information technology in the sense of our discussion. We can then ask how this application software should be designed to actually contribute to customer orientation. Our short answer is that only application-oriented software development can supply the prerequisites required to achieve this goal. The central purpose of this book is to explain what application-oriented software development is and how it can be conceptually and constructively designed by use of object-oriented means. When we talk about application software in this book we mean large, interactive, and long-lived software systems. By our definition, “large” means object-oriented software systems with more than 1, classes developed by a team composed of at least five to ten people over a period of more than a year. “Interactive” means application software that can help do the job via different technical and marketing channels within a specific application as a means to its end, where the way the program runs is influenced by both user intervention and system feedback. And “long-lived” means that this application software can be used over a period of several years and has to be adapted continually to business and usage conditions as they change. Finally, we consider a piece of application software to be “large” when more than one project within the same application domain works with components or versions of that system. We also think that frameworks, platforms, and components are an indispensable part of these dimensions. Frameworks (nowadays often called platforms) form the architectural backbone of the system, and large software systems cannot be built at an acceptable cost and with satisfactory technical quality without this backbone. But

Zullqxd 20/8/04 AM Page 3

A P P L I C AT I O N O R I E N TAT I O N — T H E S U B J E C T O F T H I S B O O K

frameworks are no panacea. Both the development and the use of large frameworks are extremely complex, so that many software projects are simply overtaxed. For this reason, we will explain how you can develop and use frameworks. The attentive reader will note that application orientation plays a decisive role once again. We think that one of the major problems with existing frameworks is their technical orientation. In the course of this book we will show how application-specific concepts and structures can influence the architecture of software systems on both micro and macro levels. Since the beginning of the nineties we have observed vehement discussions about the use of components as an alternative to frameworks. As Clemens Szypersky put it, “A software component is a unit of composition . . . [It] can be deployed independently and is subject to composition by third parties.” At this point, we should ask how and in what context this composition is supposed to take place. We will explain that components and frameworks can complement one another well. Another thing that plays a major role in the description of frameworks and components are patterns. Relying extensively on the seminal work of Gamma et al. and our own work, the main part of this book will describe conceptual and design patterns that are used to develop interactive application software. We will use the presentation means of the Unified Modeling Language (UML) for technical figures. However, we don’t want to stop at the architecture of a software system and its construction. We think that application orientation requires an altogether different approach to software development. There is currently much discussion about the role and proper use of the Unified Process (UP). We will show that an application-oriented approach is compatible with the principles of UP. In fact, this approach can be seen as a user-oriented interpretation of UP. Among other things, this new approach will lead to different software products and a different development process. This book is about both of these issues.

Structure of This Book This book is divided into three main parts: ●





The T&M approach did not emerge ad-hoc or without any concept. The first part of this book, which includes Chapters 1 to 6, describes the T&M idea, what motivated it, and which important object-oriented concepts and modeling rules it uses to achieve an evolutionary approach. Part 2, encompassing Chapters 7 to 11, discusses in detail how to build interactive application software. We will first explain how you can use metaphors to design an interactive system. Then we show how to systematically convert this conceptual design into the implementation of tools and all the other elements of the T&M approach. Chapter 9—a central chapter of Part 2—describes a framework-based architecture for large application systems. The remaining chapters of this part discuss other approaches and constructions; important issues include the support of cooperation and coordination, and persistency. Part 3 begins with Chapter 12, which discusses the development process; Chapter 13 describes document types. We will explain how we see industrial software projects from the management perspective, and how these management aspects can be planned within an evolutionary approach. One of the central issues discussed in this context are the document types proposed in UML and the

3

Zullqxd 20/8/04 AM Page 4

4

INTRODUCTION

basic approach defined in the Unified Process. In this context, application orientation requires a set of document types that extend UML. Agile processes like eXtreme programming are often seen as an alternative to “heavy-weight” strategies like UP. Having participated in the early discussions about agile processes, we disagree. We will introduce a balanced integration of agile and evolutionary approaches, pointing at their underlying unifying concepts—the need for software developers and users to understand each other and to cooperate. Therefore, it appears meaningful to interpret the general statements of the Unified Process from an application-oriented view. This issue forms the focus of this part.

1 . 2 T H E T O O L S & M AT E R I A L S A P P R O A C H ( T & M ) This section provides a brief overview of the most important ideas behind the Tools & Materials (T&M) approach. It describes models and central design metaphors, such as tools, materials, automaton, and environment, as well as the general principles of and useful document types for our approach. It discusses why the T&M approach differs from many object-oriented methodologies.

The T&M Approach in a Nutshell The T&M approach attempts to achieve application orientation in software development. Application orientation focuses on software development, with respect to the future users, their tasks, and the business processes in which they are involved. Application-oriented software is thus characterized by high usage quality, in other words, on the characteristics that a system should show when actually used. We can identify some important characteristics of this type of software: ●

● ●

The system functionality is oriented to the tasks to be solved within the application domain. The system is easy to use and manipulate by its designated users. The processes and steps defined in the system can be easily adapted to the actual requirements, depending on the individual application domain.

Based on object-oriented design and techniques, this approach combines many different elements, such as a model with design metaphors, application-oriented documents, and an evolutionary development strategy with prototyping. But the T&M approach is not only a collection of best practices. The underlying idea links its different elements in a way that makes designing good application software easier. You start by choosing a guiding metaphor and fleshing it out by appropriate design metaphors. So, for example, you decide to build a software system as an expert workplace for a customer advisor (guiding metaphor) in a bank. You add different form sheets, folders and trays as well as tools like an interest rate calculator or an account finder as equipment to an electronic desktop (design metaphors). Constructing the system you look at the patterns like “Interrelation of Tools and Materials” related to the design metaphors. They fit into the proposed model architecture. As you set up your project you will find guidelines and document types that put the application-oriented idea to work.

Zullqxd 20/8/04 AM Page 5

T H E T O O L S & M AT E R I A L S A P P R OA C H ( T & M )

Building large object-oriented systems is a demanding task. Today, many developers have realized the need for a clear architectural concept for these systems. The central architectural idea behind the T&M approach is that the structures of the application domain and the software system should be similar. This structural similarity means that objects and concepts from the application domain are taken as a basis for the technical software model. The result should be a close correspondence between the applicationspecific terminology and the software architecture. This is not a new idea as it was the initial spark for Simula, the first object-oriented language. But we took the idea from designing systems from the small ones (e.g., on the GUI level) up to the overall structure of large distributed systems. Having similar structures for the two worlds, that is, the application domain and the software model, offers two major benefits. First, the application system represents the real-world objects and work-specific terms for the users. This means that these users can organize their work in a familiar way. Second, the developers have a development plan for their system. They get an idea of how to structure the “landscape” of the domain. At a more fine-tuned level they can put software components and application concepts in specific relationships, so that they can be easily identified when the software needs to be adapted to real-world changes. To deserve the term “interactive,” an application software has to combine a taskoriented functionality and suitable handling and presentation means. From this perspective, software development is a design challenge in the original sense: both the form and the contents have to match. This brings up the question of what “shape” a software product should take and how it should be handled to help complete the task. Software developers should be supported in this design challenge. Within the scope of the T&M approach, this support is provided in the form of a “guiding metaphor.” A guiding metaphor for our purposes is a pictorial term that characterizes a unifying view in the software development process. As a familiar term it helps both users and developers to understand and design the application software. This means that it is not used for GUI design but to shape the functional and behavioral characteristics of the entire application. Currently, our most successful guiding metaphor is the expert workplace. This metaphor has proven valuable in the large number of software projects we have conducted in the banking and service industries. These industries primarily support office work done by qualified staff, in other words, activities that, in addition to industry-specific knowledge and experience, require some amount of independent work and initiative. When looking at the expert workplace as a guiding metaphor, the reader should realize some fundamental ideas related to it: ● ● ●



A workplace is a place where people accomplish their work tasks. It is furnished or equipped with the necessary things for doing the job. An expert workplace is meant for a person who knows how to cope with the different work tasks of the job. The expert is the actor; the workplace simply offers the means to an end.

Other guiding metaphors, such as the functional or back-office workplaces, have also proven to be valuable in different working contexts or domains.

5

Model and design metaphors

Zullqxd 20/8/04 AM Page 6

6

INTRODUCTION

What is a tool?

What is a material?

What is an automaton?

What is a work environment?

What is cooperative work?

A guiding metaphor should be “granular” to ensure that it can really be understood. To achieve this goal, we use a set of matching design metaphors that describe that “leading” metaphor in more detail. A design metaphor uses an object from the real world to describe a concept or a component of the application system. Such a design metaphor creates a common basis of understanding for developers and users, as it clearly refers to a common background of experience and represents an understandable term. To match the guiding metaphor of a workplace, we use the following design metaphors: tool, material, automaton, and work environment. Obviously, these metaphors originate from the context of human work. When working, people take intuitive decisions between the things that represent their work objects, and things they use to get their jobs done. Accordingly, our definition of the fundamental metaphors, or tools and materials, is as follows: A tool supports recurring work processes and actions. It is normally useful for a different set of tasks and objectives. A tool is handled by its users according to the requirements of a situation and put aside when it is not needed. It does not dictate fixed work steps or processes. If it is a software tool, it allows users to manipulate work objects interactively. A material is a work object that is manipulated so that it will eventually become the work result. Materials are manipulated by use of tools. Software materials embody “pure” domain-specific functionality. They are never used directly and are never active on their own. A software material is normally characterized by its behavior rather than its structure. In an office environment, there are more than tools and materials. Today, many tedious work routines are done automatically. We thus introduced the automaton as an additional design metaphor: An automaton completes a task that has been fully specified in advance and produces a defined result in defined variants. Once parameterized, an automaton can run without intervention over a lengthy period of time. A software automaton normally runs in the background. It is initially configured by the user, fed with additional information upon demand, or stopped in case of emergency. An automaton may have a simple interactive interface. Tools, automatons, and materials need a place where they can be provided, arranged, and stored. This is the purpose of the work environment metaphor. A work environment is the place where work is completed and the required work objects and tools are provided. Work environments embody a spatial concept and ordering principle. We distinguish between personal workplaces, allowing privacy and an individual arrangement of things, and generally accessible rooms in a work environment. In an organization, we can often define meaningful workplace types with a matching set of characteristic equipment. In the context of office work, and in many other domains as well, it is no longer sufficient to support individual work. Application systems for cooperative work represent new challenges to software developers. Our experiences in this field led to the conclusion that cooperative work can be supported by work tools and objects similar to those for the individual workplace. However, cooperative work involves new resources that address the special character of cooperation. This includes design metaphors like archives, circulation folders, and dockets.

Zullqxd 20/8/04 AM Page 7

T H E T O O L S & M AT E R I A L S A P P R OA C H ( T & M )

This expansion of our design metaphors to include cooperative work needs to fit into the context of the selected guiding metaphor. In cooperative work, as in individual work, there are users who have to decide within their work situation whether they handle a predefined standard process, or whether specific changes to the workflow and the work distribution are meaningful. Other workplace types and forms of cooperation represent other requirements for cooperative work support. Based on the cooperation types, we have put together a basic choice of cooperation tools and media. For developers, application orientation means that they have to understand the tasks they are supposed to support with appropriate software systems. To achieve this goal, they have to gain access to the specialized knowledge and experience of the experts in the application domain. The keyword here is evolutionary system development, because this type of development process is oriented to close cooperation between the developers and the users. However, cooperation needs a foundation. Therefore, we use application-oriented document types and the prototyping concept. Using application-oriented document types as a necessary basis to understand the concepts and tasks of an application domain is nothing new. What’s important to understand is that these document types describe the application under development in the specialized user language. These document types are considered an expansion and specialization of the UML standard documents. We use the “classic” UML document types for the technical design. In addition, we use the following applicationoriented document types: A scenario is an interpretation of an organization’s business use cases. It describes the current work situation, focusing on the tasks within the application domain and how these tasks will be completed by the use of tools and work objects. Scenarios are formulated by the developers based on interviews with users and other groups involved in the application domain. A glossary defines and reconstructs the set of terms of the specialized language in the work environment. Glossary entries are written by the developers parallel to the scenarios. They provide initial ideas about the materials needed in designing the system. System visions correspond to use cases. They are at the transition point between the analysis of the application domain and the construction of the future system. Based on the scenarios, system visions anticipate the future work situation. They are oriented primarily to the developers and help build a common system vision. They describe the ideas about the domain functionality and how tools, materials, automatons, and other system components should be handled. A prototype is an executable model of the application domain, representing an important and constructive enhancement of the system visions. A prototype makes the ideas about the system “tangible.” In particular, so-called “functional prototypes” are of central significance not only in the developers’ communication with the users, but also in giving developers the necessary experience and experimental basis for the technical construction of the system. This means that prototyping plays a central role in our approach. To analyze cooperative work and design that is appropriate to application software, we need to extend the set of document types described above. Scenarios, glossaries, and system visions can be used to describe the different set of tasks and activities from the workplace perspective. What’s missing is an overall view. To solve this problem, we have successfully used so-called cooperation pictures.

Evolutionary system development

Applicationoriented document types and UML

Scenarios

Glossary

System visions

Prototypes

7

Zullqxd 20/8/04 AM Page 8

8

INTRODUCTION Cooperation pictures

The development process

Author-critic cycles

A cooperation picture is an extension of use case diagrams, which are used for group discussion and workshops. Cooperation pictures are essentially based on well-understood pictograms that represent the work objects and information to be exchanged between all participating parties or “actors.” Once we have defined our guiding and design metaphors, together with document types and prototypes, we have a set of interrelated concepts and techniques on hand to support software development that is focused on the application domain. This means that the developers have all the prerequisites to start working towards the goal set: high usage quality. However, whether or not this goal can really be achieved depends largely on the right implementation of the concepts and the use of tools during the development process. Therefore, we think that it is mandatory also to prepare a set of instructions for the design of this process for the developers. The basic principle is then to look at software development not as a primarily technical or formal task but as a communication and learning process. Learning and communicating are evolutionary processes driven by constant feedback between the participants. This means that we agree with the basic principles of the Unified Process. This evolutionary process between development and feedback includes basically all documents pertaining to that project. It is not a matter of completing milestone documents sequentially in a defined order, but of linking the analytic, modeling, and evaluation activities as needed. This obviously conflicts with the principles of the classic waterfall or phase models, but it can be harmonized with the core workflows of the Unified Process. The evolutionary process, in our definition, is realized in the form of so-called author-critic cycles in all our projects. Our author-critic cycle means switching between analyzing, modeling, and evaluating activities, where the developers are normally the authors. Their work objects are documents and prototypes. The critics are normally all participating parties who have the required specialized or domain knowledge. In the sense of application orientation, these are normally the users. Ideally, the author-critic cycle is iterated quickly and often. To better understand our approach, it is important to bear in mind that the problems identified in the feedback process determine what activities should follow next and which documents should be prepared. In this sense, there is no predefined sequence of documents and work steps. You could basically prepare any document at any given time. Of course, there is no doubt that the entire set of activities have to be planned and controlled in every project and cannot be subject to individual arbitrariness. What we should take home from these definitions is that the basic process itself is determined by application-oriented issues rather than by a technical mechanism.

T&M As a Method

What is a method?

This book discusses the T&M approach. Now, what is it? Shouldn’t we simply speak of a T&M method? A large amount of object-oriented literature contains a collection of graphical notations and associated instructions for use, including UML literature. Unfortunately, notations, diagrams, and graphical CASE (Computer Aided Software Engineering) tools are not sufficient to fully support a specialized software development process, because this notation does not tell you what should be modeled.

Zullqxd 20/8/04 AM Page 9

PROJECTS BEHIND THIS BOOK

At the other end of the spectrum, you find books on methods, organized similarly to cookbooks or do-it-yourself handbooks for model construction kits, with instructions like, “Take this, do that, be careful about a third thing, and . . . your objectoriented application system is ready.” We are somewhat skeptical about such books, because almost thirty years of software engineering history and experience have taught us that this type of instruction does not work in the real world. That’s why we say: the methodical approach should provide a set of techniques and means of representation. In addition, there should be a set of instructions telling how to use these techniques and means of representation based on concepts. In her seminal work, Christiane Floyd draws the following conclusion: despite all similarities, each software project is definitely different from its predecessors. So, for a method to be successful, you cannot simply apply it, you have to work it out in your project. Consequently, the T&M approach is not a ready-to-use method but ● ●

● ● ●

a view of object-oriented application development; a collection of proven construction, analysis, and documentation techniques in the form of patterns; a description of matching concepts and architectural models; an evaluation of different and extensive project experience; and a set of guidelines to develop a concrete construction technique and a matching approach.

In short, the T&M approach is designed to help elaborate a method tailored to a specific project and a specific development organization. To achieve this goal, it is important for our readers to be able to reconstruct our views to a sufficient extent. Views evolve on the basis of experiences and value concepts. This background cannot be represented in a handbook. Nevertheless, this basic understanding between the author and reader has to be established. For this reason, we comment on all concepts and constructions, show examples, and report on the experience we have gained from our real-world projects. We think that this will create the right context for our readers to understand the T&M approach and use it in their own work. Finally, a word about originality. We never intended to create something totally new, or to knowingly distance ourselves from others with the T&M approach. Those readers who find known constructions, representation means, or ideas in this book should know that this was our intention exactly. After all, as software engineers we don’t want to be “originality geeks,” but instead rely on work that has proven reliable and meaningful. In this sense, we also do not distance ourselves from UML or the Unified Process. We rather interpret both techniques and concepts in the application-oriented sense, giving developers a set of instructions about how to handle these diagrams and principles in their project organization. The goal of this set of instructions is to combine high usage quality in our software with state-of-the-art software technologies.

1. 3 P R O J E C T S B E H I N D T H I S B O O K In the following we give an overview of the scope of the projects where the authors of this book were actively involved and in which T&M played a major role. The reader

The T&M approach is a methodical framework

Views

Originality of T&M Relationship to UML and UP

9

Zullqxd 20/8/04 AM Page 10

10

INTRODUCTION

will thereby understand more of the background of this book and get a better feeling about the relevance of our approach to his or her everyday work.

The Scope of the T&M Projects For almost fifteen years the T&M approach has evolved. A lot of people from different fields and organizations have contributed their ideas about software development and application orientation. But the essential driving force of our approach has always been project work. The experiences of many projects in many areas have both served as a usability test and as an inspiring source for new ideas or revisions of concepts and techniques. The projects where the T&M approach has been used covers a wide area, from workplace solutions to technical embedded systems. Examples include: ● ● ● ● ● ● ●

An IDE (Interactive Development Environment) for logic programming; Workplace systems for banking; Fleet management for a car rental company; Workflow editor for e-commerce; Certified aircraft engine software; Embedded medical lab system; and Maintenance management for municipal water works.

In the following, we will look at some projects in more detail.

AN OBJECT-ORIENTED PROGRAMMING ENVIRONMENT FOR LOGIC PROGRAMMING In the mids in a software technology department of a national research institute, we developed a programming environment for logic programming in Prolog. The architecture of this environment featured the nucleus of many technical T&M concepts—we used tools and materials for the first time. Through discussions with users, we realized the importance of usage quality and a clear domain-oriented usage model. The programming environment was used for several years at universities and research institutes for research and training.

A WORKPLACE SYSTEM FOR RETAIL BANKING A software and service center for a major German banking group was faced with an urgent customer demand for a new workplace system that would comprehensively support their customer advisors. An initial software project along the traditional lines of a waterfall model and procedural programming had failed. A rather desperate management ventured to relaunch the project with object-oriented techniques and an application-oriented strategy. We trained and coached the team and consulted management. The T&M approach was used both for all basic constructions and for designing the different workplace types with their usage models. Within an incremental process of almost three years the workplace system was developed in several extension levels and is working at almost 2, workplaces in more than banks. It received an outstanding reception by its users. Several external evaluations and reports showed the high level of usage quality.

Zullqxd 20/8/04 AM Page 11

PROJECTS BEHIND THIS BOOK

REORGANIZING THE IT DEPARTMENT OF A BANKING SOFTWARE AND SERVICE CENTER Motivated by the unexpected success of the workplace system project, the software and service center just mentioned decided to reorganize their IT department. Objectorientation was chosen as the main technology for application development. All other IT activities were to be grouped around this strategic concept. We consulted IT management, trained and coached teams, and cooperated in major conceptual projects. Over a period of six years, more than developers and technical staff were trained in object- and application-oriented concepts and techniques. We coauthored the company’s project strategy and handbook. Together with the company’s architecture group, we designed the architecture of their banking framework, which was a major source for the T&M model architecture. The consistent conceptual view of the T&M approach and the concept of structural similarity proved to be the fertile basis for the growth of a common development culture in the company. The company played an outstanding technological and strategic role among the software and service centers of the banking group.

A FLEET MANAGEMENT SYSTEM FOR A CAR RENTAL COMPANY The German branch of a European car rental company needed a system for the strategic management of their vehicle fleet. They used to work with their company-wide central information system. This system, however, gave no proper support for ordering, buying, or selling vehicles, or for the bookkeeping related to them. First, we analyzed the business processes involved and cooperated with the technical departments in restructuring these processes on the basis of cooperation pictures and presentation prototypes. In subsequent project stages we developed an integrated fleet management system (plus a specialized bookkeeping module) with interfaces to the central information system. Both management and users were convinced by the combination of usability and complex domain logic of the system.

A GRAPHIC WORKFLOW EDITOR FOR E-COMMERCE An Internet company had the idea of a new e-commerce application by which the business organization staff could design and model e-commerce business processes. The application consisted of a graphic editor for designing workflow processes and a generator component that transformed the graphic models into Internet applications. We contracted for the design and implementation of the graphic editor. As a promotion show at an international IT trade fair was already scheduled, we had roughly three months to analyze, design, and implement a fully functional prototype. We set up a programming team of eight people who used an agile process incorporating the principles of eXtreme programming. The project was a complete success under all technical and domain aspects. We delivered the prototype with all requested features precisely on time and on budget. Unfortunately, the product never met a market as the Internet company became insolvent after the trade fair.

A CERTIFIED AIRCRAFT ENGINE SOFTWARE A German race car engine-tuning company had the idea of using an augmented standard vehicle engine as the basis for an aircraft engine for sporting airplanes. A new electronic motor control unit had to be developed. This embedded software system had

11

Zullqxd 20/8/04 AM Page 12

12

INTRODUCTION

to be certified by national and international avionic authorities. We contracted for elaborating a development and quality assurance process that could be certified. In order to meet the very high demands for software quality and for a clearly documented and reproducable development process, we combined the main features of our applicationoriented development strategy, that is, Design by Contract, our interpretation of eXtreme programming (especially engineering cards and test first, of Sections and ) and the UML document types. Within six months, we designed a metamodel and a software development process according to the FAA’s (Federal Aviation Administration) RTCA (RTCA Inc is an association of aeronautical organizations of the U.S.A. from both government and industry) requirements, which was then certified by all relevant avionic authorities. The IT department was happy about the development strategy and the quality assurance process, which on the one hand fulfilled all the formal requirements, and on the other hand fitted well into the actual teamwork and programming practices. The new aircraft engine went into production and was a major market success.

REDESIGNING A REVERSE AUCTIONS APPLICATION An Internet company successfully provides an application for reverse auctions, where buyers publish their tender offers and potential suppliers can place their bids. These suppliers then have the opportunity to undercut their competitors. The existing software for this application, however, had grown rather complex and was hard to understand and maintain. We analyzed the system, wrote a report, and proposed a complete redesign. The T&M conceptual patterns and the model architecture helped to clarify the pros and cons of the existing system and to highlight the improvements of the new design. Within several architecture workshops, the development team discussed our proposals and was able to work out a scheme for completely refactoring the reverse auction system.

AN EMBEDDED MEDICAL LAB SYSTEM A market leader for medical labs wanted to develop a new generation of medical lab systems with a higher throughput of samples and a more efficient control system. The task was demanding, as a smooth integration of low-level automation, interactive analysis workplaces, and high-level system calibration was required. Major parts of the lab’s hardware and basic software were custom-made. We redesigned the entire secondlevel automation software and the control system and added tailored integrated workplace systems. Starting with the core design metaphors of the T&M approach, we refined our tool construction and the workplace types. We were able to design a system with a clear technical and usage model that overcame a few severe shortcomings of the previous generation. While the prototypes of the system were very satisfactory, the first live tests unveiled major structural and performance problems in the database connection. The database mapping and the access interface had to be redesigned. Then the system ran smoothly and went into production.

PRODUCT DESIGN SYSTEM AND CONTRACT MANAGEMENT FOR AN INSURANCE COMPANY A German insurance company, one of the middle-sized enterprises in this domain, wanted to redesign its host-based legacy system for contract management and at the

Zullqxd 20/8/04 AM Page 13

PROJECTS BEHIND THIS BOOK

same time implement a new concept for designing insurance products. We worked as consultants and software architects with their software team. Introducing eXtreme programming, we used techniques like pair programming, story writing, and tracking to improve programming skills, product quality, and project management. The T&M design metaphors helped to create a common vision of the future workplace system. The model service architecture was used as the basis for designing and implementing the new components and services for product design and contract management. The layer architecture provided the interface concepts for the connection to the host backend and its stepwise displacement. The first desktop tools with related services are operative, as well as an Internet portal for insurance agents.

COOPERATIVE WORKPLACE SYSTEM FOR CORPORATE BANKING A major Swiss bank had the need to redesign its workplace system in the corporate customer department due to poor acceptance and performance. The existing system was implemented with a 4 GL (i.e., a 4th generation database manipulation language) system on top of a complex host network. As the system had been installed just a year before with the goal of improving the rather poor user support, the banking staff was not amused by the idea of yet another software project. In addition, a new development team of twelve with many graduates was hired, who had few skills in object-oriented design and little project experience. We were contracted as consultants and software architects. In a pilot project we combined object-oriented training with team formation and becoming acquainted with the banking domain. The T&M approach served both as a guideline to object-oriented development and as the overall view on application development. The actual project started after almost one year and ran for one and a half years. By the end the team size had doubled. An entirely new workplace system with different workplace types and several rather complex software tools was designed, implemented, and evaluated at some pilot banks. The different workplaces were linked with a clear cooperation model for the underlying flexible workflow management system. A few weeks before the actual roll-out the bank merged with another company of equal size. The top management decided that for the new company’s corporate banking the business strategy of the other bank was to be used. Thanks to the layers of the T&M model architecture we had used, the team was able to substitute the entire business logic within three months, reusing most components for handling, interaction, and cooperation. The system successfully went operative.

REDESIGN OF A MANAGEMENT SYSTEM FOR MUNICIPAL DAY-CARE CENTERS The public administration of the municipal day-care centers of a major German city was developing a management system. The small development team had little background for developing a complex system of this size and had chosen to use Visual Basic. We worked as trainers and software architects. The T&M model architecture and the conceptual patterns were a substantial help in getting across the idea of designing and implementing a large and complex system. As the programming skills within the team varied considerably, the distinction between tools, materials, and services were essential to establish a fitting division of work. The T&M design patterns proved to be on the right level of abstraction, as we could easily specialize them for a system implemented in Visual Basic. Most redesigned modules have seen integrated successfully and the project is in good progress.

13

Zullqxd 20/8/04 AM Page 14

14

INTRODUCTION

A WORKPLACE FRONTEND FOR A TELEPHONY SYSTEM A manufacturer was supplying server software for distributed telephony systems. They had a call-center application with a rather poor interface. We worked as software architects and developers. The task was both to design a highly usable frontend for call-center applications and an architecture for this software components that would fit into the overall architecture of the telephony system. We introduced the concept of different workplace types and design metaphors. Although the general characteristics of tools, materials, and automata were applicable to this domain, we found it useful to refine some of these design metaphors. So we proposed the conceptual patterns of adjustment tool, probe, and technical automaton. This led to an improved usage model, as the users could understand potential delays and missing reactions when they tried to adjust the actual telephone switches encapsulated in a technical automaton with a tool. The new call-center software was implemented using these patterns and was a success from the very beginning, as a network of distributed call-centers managed the nationwide marketing campaign of one of the biggest German IPOs in years without major problems.

1. 4 T H E E Q U I P M E N T M A N AG E M E N T S Y S T E M EXAMPLE In this section we introduce the Equipment Management System (EMS). It is the main example we will be using throughout the book. This example is of small size and moderate complexity. It should meet the background of most software developers and shows a lot of characteristics of a domain, where interactive workplace solutions are useful. Imagine that we are a small software company developing the JWAM framework as a platform for its project work. The JWAM team comprises approximately twenty people, with the usual fluctuation. Each developer has access to a networked workstation. In addition, there are the following devices: two servers, two printers, one integration computer, and one fax machine. All developers have to rely intensively on their computers, so that the underlying infrastructure is a critical task. Our ficticious software company calls this task “Equipment Management,” and an equipment manager is responsible for it. The equipment manager finds himself in a constant target conflict: members of the staff keep asking for better-performing computers, but the budget for device procurement is limited. The central tasks of our equipment manager include: ●





Procurement of new devices: A device is normally procured upon the request of a member of the staff (see the scenario “Buying a new device” in Section ). In such a case, the equipment manager has to carefully weigh the requirement against the budget. The employee’s old device is either disposed of or passed on to another employee (see the action study “Sorting out a device” in Section ). Minimizing costs in device procurements: To procure a device the equipment manager has to get several cost estimates from different vendors to ensure economic management (see the scenario “Buying a new device” in Section ). Upgrading existing devices: Existing devices are checked regularly as to their performance and upgraded, if necessary, for example, by adding main memory or hard disk capacity (see the system vision “Updating devices” in Section ).

Zullqxd 20/8/04 AM Page 15

REFERENCES

15

Building D Room D Robert Baldwin

Room D/ Software Lab

1 UltraI, 64MB, , 17"-Color

4 Pentium MMX-PCs, 1 UltraII, , 17"-Color, PC/Solaris-Server 1 UltraII, , 20"-Color, PC/Solaris-Server

1 Sparc2, 64MB, , File-Server 1 PC-Pentium II , PC-Server,

3 SunSparc4, 32MB, , 17"-Color, 1 Sun-IPX,16MB,

Room D Chris Robin Ed Bear

Room D Carol Lillile Gideon Wolfe

1 Pentium PC,

1 Pentium II,

1 Pentium II, (Video-Desktop-System)

1 PC-Pentium MMX,

1 PC , 32MB, , 17"-Color,

1 Apple-Laserwriter IIg, 1 MacIIci, , 19"

1 Pentium MMX,

1 Pentium , , 17"-Color

1 Pentium II,

1 Pentium II,

1 Pentium ,

1 Pentium MMX,

Chris Caroll Room D

Guy Strangelove Room D

Iris Young Room D

Ralph Kempinski Room D

1 PC-Laptop 64 MB,

Pinkus Potter Room D

Martina Ritchie Room D

FIGURE The EMS example’s room plan.



Updating the office plan: The team members are allocated to projects, and projects are located in adjacent rooms. Therefore, equipment and team members frequently have to change offices. An office plan showing a plan of all rooms with the team members and their equipment has to be updated with every change. A manual version of this office plan, that was used before the new system was developed, is shown in Figure

The company estimates that the number of computers to be managed will double within the near future, because new members of the staff are going to join the JWAM team. This will, of course, increase the equipment manager’s workload.

1. 5 R E F E R E N C E S D. Bäumer, G. Gryczan, R. Knoll, C. Lilienthal, D. Riehle, H. Züllighoven: “Framework Development for Large Systems”. Communications of the ACM, October , Vol. 40, No. 10, pp. 52– This article describes the model architecture for large application frameworks based on the T&M approach.

Zullqxd 20/8/04 AM Page 16

16

INTRODUCTION G. Booch, J. Rumbaugh, I. Jacobson: The Unified Modeling Language. Reading, Mass.: AddisonWesley, The current standard work on UML. R. Budde, H. Züllighoven: “Software Tools in a Programming Workshop”. In C. Floyd, H. Züllighoven, R. Budde, R. Keil-Slawik (eds.): Software Development and Reality Construction. Berlin, Heidelberg: Springer-Verlag, This publication is a short version of the dissertation of both authors, discussing the conceptual background of the T&M approach. U. Bürkle, G. Gryczan, H. Züllighoven: “Object-Oriented System Development in a Banking Project: Methodology, Experience, and Conclusions”. In Human-Computer Interaction, Special Issue: Empirical Studies of Object-Oriented Design, Vol. 10, Nos. 2 & 3. Hillsdale, New Jersey, England: Lawrence Erlbaum Associates Publishers, , pp. – This is a detailed report about the approach and experiences gained in our first and largest application project based on the T&M approach. C. Floyd: “Outline of a Paradigm Change in Software Engineering”. In G. Bjerknes, P. Ehn, M. Kyng (eds.): Computers and Democracy: A Scandinavian Challenge. Aldershot, Hampshire: Dower Publishing Company, ; pp. – The seminal work, where the author also describes our understanding of software engineering. E. Gamma, R. Helm, R. Johnson, J. Vlissides: Design Patterns. Reading, Mass.: Addison-Wesley, The seminal work on patterns, which formed the basis of our construction handbook. T. Peters, R. H. Waterman: In Search of Excellence: Lessons from America’s Best-Run Companies. New York: Harper & Row, One of the best books (albeit criticized) that initiated the discussion about customer relations. C. Szyperski: Component Software. Reading, Mass.: Addison-Wesley, A popular and substantial book on software components.

Zullqxd 20/8/04 AM Page 17

The T&M Object Metamodel

2

2 .1 T H E O B J E C T M E TA M O D E L Introduction Work on object-oriented development projects requires all developers to share a common understanding of the basic terms relating to object orientation. In this respect, the authors of this book have a different conception from those of method books.1 In addition, relying on an object-oriented programming language won’t help either since various languages implement the concepts more or less cleanly. For this reason, we begin this section with a definition of our so-called object metamodel. A metamodel essentially provides the elements and relations that can be used to build models. In the context of our work it means that an object metamodel helps us to understand the concepts behind, for example, UML diagrams or the Java language constructs. Our object metamodel reflects the principle of application orientation. We will show how the elements of technical object-oriented models correspond to the concepts and notions used for domain-specific analysis and modeling. By the end of this chapter readers will know what the authors mean by, for example, inheritance. They will also understand the importance of relating the terms of an application domain to a hierarchy of classes. When this chapter is used by a software team, it helps developers to arrive at a common understanding of object-oriented modeling and programming from the perspective of the T&M approach.

1. The authors of various method books diverge considerably on the basic concepts that will be discussed here.

17

Zullqxd 20/8/04 AM Page 18

18

T H E T & M O B J E C T M E TA M O D E L

Definition: The Object Metamodel What is an object metamodel?

Object orientation offers a set of concepts to describe domain-specific and technical models:2 An object metamodel describes ● ● ● ●

elements, relationships, element properties, and formation rules,

which are all available for object-oriented modeling. The most important elements are objects and classes, linked by a use relationship and inheritance. In addition, there are (mostly pragmatic) rules specifying how to link elements by relationships. Among the most important elements in our object metamodel are classes. A class has specific properties, for example, an interface with admissible operations and a hidden description of attributes and implementations of operations. An inheritance relationship is one of the most important relationships used to link classes. An inheritance relationship has certain properties. For example, a subclass inherits all attributes of its superclass. Inheritance as a pure software concept may be used in many different ways. One important formation rule of our object metamodel says that you should use inheritance mainly to model domain-specific generic terms and semantic members of these terms. Therefore, our Equipment Managment System (EMS) example, BusinessCard, is a specialization of the generic concept, Form. The rules of composition are thus of great importance. They give us guidelines for utilizing various elements and relations in modeling. They thereby support a common understanding of models and a clean use of the elements from a software engineering viewpoint.

Context: What’s the Purpose of an Object Metamodel? In the context of this book, we look at object-oriented application development from a software engineer’s perspective, that is as a way of designing models (see Chapter 6). In fact, the core of the T&M approach is to create a domain-specific and technical object-oriented model, based on the objects and terms of that application domain, and to derive an object-oriented program from it. To do this, we need an exact understanding of what all the basic terms of object-oriented modeling mean and how they should be used. At this point, you may be asking yourselves why we have gone to all this trouble, since each known programming language in practice implements such an object metamodel. This is true. Each program written in one of these languages shows what the elements of the language mean. But the problem with object-oriented languages is similar to those with method books. In recent years, we have used different object-oriented

2. When speaking of technical models in the course of this book, we always mean technical software models. When discussing the modeling of technical embedded systems, we will make that clear.

Zullqxd 20/8/04 AM Page 19

T H E O B J E C T M E TA M O D E L

19

(and conventional) programming languages in our projects based on the T&M approach. What we have found is that each language implements a more or less different object metamodel. This leads to situations that we do not find useful, neither from the software development nor from the user’s perspective. It has proven useful instead to turn a uniform object metamodel into the basis for conventions and program macros in our projects in order to achieve a common understanding of our modeling and programming efforts. These issues led to the following requirements for our object metamodel: We have to define our object metamodel so that it can be used to describe the domain concepts of our future application. It has to be defined as closely as possible by the concepts of an object-oriented programming language so that we really can implement a domain model. And finally, our object metamodel should encourage software quality characteristics such as easy understanding and easy modification.

Context: A Classification of Programming Languages When we talk about the basic elements of an object metamodel, we use the accepted classification of programming languages proposed by Peter Wegner. He defines a threelevel model, where each level comprises the programming language characteristics that a language has on that level. The classification leads from object-based via class-based to the last level of object-oriented programming languages (see Figure ). According to Wegner’s classification, a language is object-based if it creates and lets you manage objects as a primary language construct. In contrast, class-based languages have the class concept in addition to the object concept. This means that similar objects can be defined in appropriate classes, and that these classes are then responsible for creating objects as instances. Finally, an object-oriented language adds the inheritance FIGURE Wegner’s classification of programming languages.

object-based objects + classes

class-based

objects + classes + inheritance

object-oriented

e.g. Ada (Packages) Modula (Modules)

CLU Euclid Mesa

Simula Smalltalk C++ Eiffel Beta Java

Zullqxd 20/8/04 AM Page 20

20

T H E T & M O B J E C T M E TA M O D E L

concept to the features of a class-based language. This inheritance concept allows you to create a hierarchy of subclasses and superclasses. Such class hierarchies have to be supported by a polymorphic-type system to be able to call an object of a subclass indirectly in the context of a superclass, that is, through a typed identifier. In the course of this book, we will only deal with object-oriented languages. Based on this classification, we will describe the important elements of our object metamodel in detail.

The Object Metamodel and the Software Model One of the fundamental ideas of the T&M approach is that the terms of the software model can be put in relation to the terms of the application domain. Figure shows how the elements of the domain and the software models interrelate. The processes called generalization, specialization, use, and composition lead to a concept model based on domain-specific objects and concepts of the application domain. This concept model can be mapped onto a software model, formed by the elements and relationships specified by the object metamodel. Note that mapping the concept model onto the software model does not break the model, because the structure and meaning of the elements used in both models are similar. However, precisely this similarity represents a central rule of our object metamodel. For example, the model elements called term, generalization, specialization, composition, use, and hierarchy of terms correspond to the elements of the object metamodel called class, inheritance, aggregation, association, and class hierarchy. This means that terms are modeled by objects and that their behavior is modeled by operations, as shown in Figure This interrelation will become clear in this section as we continue interpreting the elements of the object metamodel from both the domain and the software perspectives. Note that we elaborated the software side of the object metamodel in more detail, because the main part of this book focuses on views relevant to the creation of the software model. Nevertheless, we will continue dealing with the domain modeling and the interrelation between the domain and the software models in later chapters (see particularly Chapters 6 and 9).

Definition: Objects This section defines the term object from our two perspectives, that is, for the domain model and the software model. FIGURE Interrelations between the domain and the software models defined in the object metamodel.

Relations of the object metamodel: Domain model

Technical model

Thing

Object

Interaction

Operation

Concepts

Class

Generalization, Specialization

Inheritance

Composition

Aggregation, Association

Sub- and Superconcepts

Class hierarchy

Zullqxd 20/8/04 AM Page 21

T H E O B J E C T M E TA M O D E L

21

In the domain model, an object is a concrete thing or an ideal concept used in daily work and forms the starting point to model an application as software objects. These objects are characterized by their behavior, that is, how they can be handled and manipulated. We distinguish probing and altering behavior: ●



What information can be drawn from an object? Which domain states are relevant? What changes can be affected in an object without destroying or transforming it into another object? What actions can I invoke on an object?

In the software model, objects encapsulate data and operations to form a program component. They are the units of the operative software system. An object can be uniquely identified across the entire system, and it has a state represented in a private memory location of the object. The operations of an object that can be seen from the outside form the interface. Each of these operations is defined by its signature. The operations assigned to an object provide information about that object and can change the object’s state. These operations are the only means to read or change the state of an object. To activate an operation, you have to send a message to that object. In addition, a contract (see Section ) can be used to make assertions about an object’s behavior at the interface. Figure shows how we describe a device within our EMS example, described in Chapter 1. Both the structure and the behavior of similar objects are defined in the common class of these objects. This class also defines the visible and hidden properties of an object. From the software model, we need to ask ourselves to what extent the language we use supports encapsulation of an object’s properties. For example, with the appropriate declaration, we can access the internal structure of an object from the outside in both Java and C; Smalltalk, on the other hand, does not let you protect operations from being called by clients at all. Furthermore, a type is assigned to each object. In most statically typed objectoriented programming languages (e.g., C), the type is defined by the class that an object belongs to. Each object has to be created explicitly at runtime. To create an object at runtime, you call a creation operation of the relevant class. While they are created, objects are allocated in memory, and then perhaps initialized and bound to an identifier. Once created, this object is an instance of that class as long as it lives. Note that the type of an object also remains the same for an entire lifetime. On this basis it is important to

Device Name Classify Order at dealer Purchase at date Describe with text Due for upgrade?

Visible and encapsulated object properties

Class and type

Creating an instance

FIGURE Object-oriented, domain-specific description of a device from the EMS.

Zullqxd 20/8/04 AM Page 22

22

T H E T & M O B J E C T M E TA M O D E L TypeA

interface

operation1(arg1:Type1):Return Type1 +operation1 (arg1:Type1) :ReturnType1

{

+operation2 (arg2:Type2) :ReturnType2





}

+operationN (argN:TypeN) :ReturnTypeN

operation operation name

parameter objects

result object

FIGURE An object’s interface.

signature

understand the difference between static and dynamic types of object identifiers: Static or dynamic identifer types

Static identifier type: To be able to use your object in a program, you have to bind it to an identifier, using a reference. This identifier obtains a static type (in statically typed languages) by declaration. Dynamic identifier type: At runtime, due to polymorphism, objects of a subtype can be bound to an identifier by either assignment or parameter passing. This defines the dynamic type.

State

Objects are direct instances of their creating class. This means that, at runtime, these objects have the structure of attributes (also called fields) defined in the class. Such attributes can contain values (see Domain Values in Section ) or references to other objects. As mentioned above, each object has a state. A state is specified by the particular 3 values of the object’s attributes and references. The state of an object is protected against access from the outside; it can be probed or altered only by operations defined at the interface.

Interface, visibility

Services

Each operation you declare for an object defines the name of this operation and its argument types and return type. All these elements together form the signature of an operation. The set of all signatures of the public operations of an object form its interface (see Figure ), where public means that these operations are visible to the outside. In contrast, an internal interface can be accessed only by the object itself. The interface of an object defines its services. We expect from an object to offer a set of domain services. The services an object offers at its interface are often realized so that services provided by other associated, that is, referenced, objects are used. In this connection, we often speak of a call-in or incoming interface, as opposed to a call-out or outgoing interface. For a programming language, the call-in interface is always explicit 3. State refers to the values of all attributes at a given point in time.

Zullqxd 20/8/04 AM Page 23

T H E O B J E C T M E TA M O D E L client

23

provider uses

service service

reference

service client

provider

FIGURE service

(because it is the public interface of an object), while the call-out interface can normally be determined only by analyzing the program code. The idea of services supplies a basic interpretation of the use relationship between objects: one object offers services, acting as a provider, and another object, acting as a client, uses these services. An object can be both a provider and a client for other objects (see Figure ). We have to distinguish the interface of an object and the call of services over this interface, both as terms and as concepts. Conceptually, the interface’s elements are called operations, that is, executable steps or activities running on a computer system. In terms of programming languages, these operations are implemented by the constructs of each language and are then called procedures, methods, or routines. When we call an operation, we often speak of sending a message to the called object. Such a message includes the identifier of the object (as the addressee), the name of the operation, and the call parameters. When polymorphism is used, then the respective operation in its specific implementation is executed at runtime. This is also called late or dynamic binding. When handling objects, we often find that operations cannot always be called in any state of the object. The reason is that an object obeys a certain use or state model, which can be explicit (e.g., as a finite state automaton) or implicit. We speak of the protocol of an object: ●

An object’s protocol is a set of rules, defined processes, or operation calls that each client has to observe to enable the object to render certain services. This depends on the state of the object. To be able to observe a protocol, the client must at least know the appropriate interface.

Objects acting as providers and clients of services.

Operations, messages, routines, procedures, and functions

Protocol

Zullqxd 20/8/04 AM Page 24

24

T H E T & M O B J E C T M E TA M O D E L

Occasionally, the literature dealing with object orientation uses the terms protocol and interface synonymously. Our definition of protocol originates from the field of distributed systems, where the term describes the interplay beween two partner instances, which, in our sense, provide a bundle of services. However, popular object-oriented programming languages offer no way of representing a protocol at the interface, except for assertions in Eiffel. Although the interface of an object defines the operations and perhaps attributes of the object that are visible from the outside, encapsulation means that you cannot access any property not explicity exported from the outside. This is normally called information hiding. Encapsulation, information hiding

Information hiding in object-oriented languages means that encapsulation is used to hide the specific representation of an object’s state, that is, its structure. Dave Parnas recommends localizing design decisions in an object. The clients of an object depend only on the elements of the interface. You can change the implementation without losing the object’s consistency from the client’s perspective. The encapsulation concept also means that, though the client knows the signature of an operation and can draw conclusions about that operation’s behavior from the contract model (see Section ), the implementation is totally hidden. In this respect, any change to the implementation should be made in such a way that no change in the specified behavior is visible from the outside.

Discussion: Object Identity It is important to understand that an object’s identity has nothing to do with it being addressable. The fact that an object is addressable means that you can access an object from within one or more contexts (which might then lead to the so-called dynamic alias problem; see Section ). Addressability is an external object quality and depends on the context. In contrast, the identity of an object allows you to uniquely identify this object, regardless of the path you have to use to reach this object. From a software-specific stance, identity means first and foremost that whether or not two identifiers point to the same object or to two objects in the same state can be determined on the level of programming language. This means that identity is an internal object quality, that is, it belongs to the object, regardless of its context and the way its structure and operations are defined. In addition, we need a concept to obtain a domain-specific identity. This domainspecific identity has to be independent of the software-specific identity of an object. Two objects with a different software identity can have one single domain identity. For example, a bank customer can be a debtor in one context and a portfolio owner in another. The identity of that person must be unique, regardless of the behavior in the respective context. This means that the developers have to be able to express what they mean by identity and how this identity relates to equality: Do they mean equal values, equal behavior of objects, or equal domain identity of an object? Note that the domain identity can never be a global property of an object. It can be modeled in

Zullqxd 20/8/04 AM Page 25

T H E O B J E C T M E TA M O D E L

25

a meaningful way only in dependence from the application domain. We will propose a possible solution to this problem in Section

T&M Design: Structuring an Interface As mentioned earlier, objects have a state that can be probed or altered. Depending on this state, sometimes operations cannot be called for software and domain reasons. To better understand this relationship in the domain and software models, the domain description of how objects are handled and the description of their interfaces should be arranged similarly (see Figure ). ●



From the domain-specific view, an object is organized as follows: – Instructions (in the sense of commands, actions) change the state of an object, resulting in procedures. – Requests supply information about the object in the form of domain-specific result objects, resulting in functions. – Tests are a special form of requests that probe the domain-specific state of an object and return a Yes/No answer, resulting in predicates, which are used in assertions. From the software-specific view, the interface of an object is organized as follows: – Procedures alter the (externally visible) state of an object. This change of state is not necessarily admissible at any given point in time. It normally depends on the actual internal state of an object. – Functions return result objects, without changing the externally visible state of the object, that is, a function always returns the same result, while the state and arguments of the object remain the same. A function can be partial, if it returns a result only for specific arguments and object states. – Predicates probe the state of an object and return a boolean result. They do not change the state and can be called at any given time.

We distinguish the concept of procedures, functions, and predicates rather than using a syntactic differentiation of a signature in input, input/output, and result parameters. Nevertheless, it is important to see how this differentiation is supported by a programming language to better understand our concepts. For example, in C each operation has the syntactic form of a function, and there is (currently) no primitive boolean type; in Smalltalk, on the other hand, each operation returns a result object.

Definition: Classes We define a class as follows: In the domain model, classes model the concepts and terms behind the objects we use in our daily work. This means that a class is an abstraction of similar objects, Supplier instruction request test

orderAtDealer(order:Order) purchaseAtDate(date:Date) getDescription():Description IsDueForUpgrade():Boolean

FIGURE Organizing an interface in statements, requests, and tests.

Zullqxd 20/8/04 AM Page 26

26

T H E T & M O B J E C T M E TA M O D E L

based on the common behavior of different domain objects. The similarity of terms can be thought of as a generic term. Such generalizations or hierarchies of terms are part of the respective domain language, which forms the basis for cooperation and furthers a better understanding of the application domain. Hierarchies of terms are modeled by subclasses and superclasses. In the software model, a class is a piece of program text describing the fundamental properties of the objects it can create. A class is defined by its name, its inheritance relationship to its superclasses, and a set of object properties (see Figure ). These properties include the interface of objects and their internal implementation by algorithms and data structures. This means that a class defines the creation and behavior model of its instances. An object is always an instance of exactly one class.

Generic operations

Thus, in addition to the behavior at runtime, a class also defines how its instances are created and initialized. Each object you create differs from all other instances of a class in that each one has its own memory location. In the example shown in Figure , this would be for each Room object the reference to the respective lists of devices. Encapsulation is used to protect the internal representation of an object against inadvertent use. For example, the reference to the object with the devices identifier in Figure is not visible in objects belonging to the RoomMap class; it belongs to the internal representation. Classes define internal interfaces, in addition to the public interface. The internal interfaces of a class are first the so-called inheritance interface, which is used only for

FIGURE Classes describe the interface and representation of their instances.

RoomMap

:RoomMap

:RoomMap

Room

devices = devicesA

devices : DeviceList putBusinessCard() putDeviceCard() dimension() isConsistent()

aRoom

aRoom

devices = devicesA

Zullqxd 20/8/04 AM Page 27

T H E O B J E C T M E TA M O D E L

subclasses of a superclass and not by clients, and the private interface, which denotes the operations for use within one and only one class. Many programming languages can protect, that is, hide, their internal interfaces by use of language constructs (e.g., protected and private in Java or C). You often find in the literature and programming environments that a reading and a writing operation are supplied for each attribute of a class. These are generic operations, not to be confused with “generic components” or “genericity”: Generic operations are normally a pair of read and write operations (set and get) for each attribute of a class.

Discussion: Generic Operations Generic operations are used in graphical interactive programming environments (e.g., VisualAge) to make application objects “accessible” for graphical interface elements. The same approach is often found in database application software. These generic operations can violate the information-hiding principle at the public class interface, because they publish the internal structure of an object, at least in part. In addition, they can easily destroy the domain consistency of an object. In general, we recommend not using such generic operations. Let’s look at a class, Account, where the generic operations could be setBalance and getBalance. When designing the class, the developer will have considerable troubles to implement the bank-specific handling of accounts using these operations. A better way would be to use deposit, withdraw, and calculateFees to define the conditions when a balance may be modified.

T&M Design: Generic Operations Note that the T&M approach does use generic operations, provided that they are used at the internal interface. It has proven to be a good idea from the software viewpoint to use generic operations to implement all probing and state-altering operations. Generic operations should thus be used in their defining class and all subclasses. More specifically, the generic operations are defined in the class that introduces the corresponding attribute. At this point, the attentive reader will probably ask whether these generic operations can be protected as internal interfaces by the mechanisms provided by the programming languages. The answer is that, C or a similar programming language have a special language construct (protected). But you can only implement this by appropriate categories and related programming conventions in Smalltalk. In the example shown in Figure , the class Note offers an operation, enumerate, with a parameter object of the class Number. Internally, this operation uses the protected generic operation, setNo, to set the encapsulated private attribute _No of type integer. This introduces a form of data abstraction to the internal relationship between classes. This approach can be used to implement abstract things. For example, generic operations can be abstracted to serve as template operations in superclasses, where their attributes are then added to subclasses.

The Bank example

27

Zullqxd 20/8/04 AM Page 28

28

T H E T & M O B J E C T M E TA M O D E L Note -_No:int -_To:String

FIGURE Generic operations at the internal interface of a class.

# setNo(no:int)

{

# getNo():int

;

# setTo(to:String)

sprers.eu(no);

# getTo():String

;

+ enumerate(no:Number)

}

Discussion: The Object Life Cycle Life cycle of objects

In the interplay between objects and classes, there are a few operations that limit the life cycle of an object; they are considered “critical situations” in software modeling and construction: ● ● ●

Creating objects

Deleting objects

Conceptually, none of these operations can be assigned to the object itself, because an object cannot create, delete, or transform itself. These operations belong to the metalevel (see Section ). In programming languages where classes themselves are available as objects in the system, creating is normally implemented as a class operation, that is, for each class there is at least one operation (constructor) that can create instances of that class. In compiler languages, which do not represent classes as objects, the compiler generates code to create objects, and the actual instantiation is normally handled by the runtime system. The creating procedure is then normally defined as a specialized operation within the class text. In many cases, implementing another operation that puts the object in an initial state, in addition to the creating operation, has proven to be a good idea. This initialization operation can be called when creating an object and whenever needed during the object’s lifecycle. Deleting technically specifies how an object is removed from the runtime memory. In object-oriented systems, this process comprises two steps: ●



Transforming objects

Create, delete, and transform into another object.

There is no more reference to the object in any location of the application system, and the object can no longer be reached in the application system.4 An object is removed from the heap. This can be handled by the garbage collector, if available, when the object is no longer referenced. Otherwise, the delete operation has to be specifically written, and problems relating to lost objects, dangling pointers, and the correct deletion order of related objects have to be dealt with.

Transforming means transfering an object into another one. This is normally the case when an object is processed so that it changes its “character” due to a specific action, resulting in a “different” object. 4. We will not be discussing problems with objects stored in a database, where they can be accessed as a result of database queries, at this point.

Zullqxd 20/8/04 AM Page 29

T H E O B J E C T M E TA M O D E L

Such a transformation of an object into another one is normally necessary for domain-specific reasons and rather difficult to reproduce in an object-oriented environment. From the technical stance, this often means that the object has to change its class and type membership, which is not supported in strongly typed object-oriented languages. Normally, if an objects needs to change class, you first create a new instance of the “target” class, then you transfer the required values from the old object to the new one, and finally, you delete the old object. Though this solution is simple, it can be problematic, because it can happen that both the software and the domain identities of the original objects are lost.

Changing class

T&M Design: The Object Life Cycle When we design the usage model (see Section ) of an interactive system, we have to clarify how objects can be created. The users of our system have to clearly understand how and from where they can obtain new domain instances of their task-related objects. In practice, it has proven a good idea to use tools or domain containers (e.g., form files) to create new materials. In addition, the tools themselves can be created by use of toolboxes or tool managers. The same rules apply to deleting objects. The question here is the domain view that a user has about the “deletion” of an object. We can easily see that there is a big difference between the software and domain views. To allow users to easily express that they no longer need an object, we recommend defining an explicit “location” for the domain-specific deletion of objects, for example, a tool or a domain container (e.g., a desktop bin). Let’s look at these things in our EMS example. Assume that a developer changes offices. The device manager updates the room plan, using the Device Organizer tool, then puts the updated room plan into a device file and closes the device Organizer. The usage model assumes that both the room plan and the tool are still available for work. However, from the software view, once the room plan and the tool settings were saved, both objects could be deleted from the runtime system. If, however, the device manager moved an old work copy of the room plan to the bin and then empties the bin, this action tells us that he no longer has any use for this plan. Still, the actual software-specific deletion of the object could be postponed until the system is shut down. We already said that transforming an object into another one is normally due to domain reasons. Let’s look at a bank example: A customer consultant prepares for a meeting with a customer, filling in personal information in an application form for a small loan. Some information will be added in the course of his meeting with the customer. Next, the form is printed and signed by the customer, the customer consultant, and a second consultant. This means that the application form is now a contract for all participating parties. The customer consultant selects the “Contract signed” option in the form editor. From that point, no changes should be made to this contract object. For the software implementation of this scenario, we could use different wrappers around an “object core” instead of changing the object’s class. We will introduce a more complex technique for role modeling in Section For example, the roles of a core object could be “contract” and “form.”

29

The EMS example

The Bank example

Zullqxd 20/8/04 AM Page 30

30

T H E T & M O B J E C T M E TA M O D E L

Definition: Inheritance An inheritance relationship is an essential feature that distinguishes object-oriented languages from conventional ones. From the domain view, an inheritance relationship organizes classes in hierarchical structures. This allows us to model a hierarchy of terms using generalizations and specializations. From the software view, inheritance facilitates the reuse of classes. For inheritance, all descriptions of a superclass are initially descriptions of its subclasses. Then a subclass can modify the properties it inherited from its superclass: ●







Inherited operations can be implemented (or defined) in a subclass, while they are merely specified in its superclass. Operations can be redefined when a new implementation in the subclass overrides (hides) the implementation existing in the superclass. New attributes (descriptions of the storage structure) and operations can be added. Access rights can be modified.

We speak of single inheritance when the inheritance hierarchy is arranged in a tree, that is, if a class has only one direct superclass and an arbitrary number of subclasses. In contrast, multiple inheritance is given when a class has more than one direct superclass. The inheritance unit is a class, and the inheritance relationship remains unchanged during runtime, at least in statically typed languages. Note that many object-oriented languages allow you to restrict the access to inherited properties (particularly for operations): ●



First, you can generally restrict the interface for clients, that is, an inherited property that is visible in the superclass no longer belongs to the public interface in the subclass. Examples include the private inheritance in C, where the subclass relation is lost, or the non-export in Eiffel, where type errors can occur due to the subclass relation. Second, you can restrict the interface, with the exception of specific classes, that is, only specific client classes can access the properties. For example, this can be implemented by selective export in Eiffel, or by breaking the data encapsulation between classes, for example, by using the friend construct in C.

Discussion: Inheritance

Using inheritance

You can think of inheritance as a mechanism that allows you to reuse specifications and code. In Simula 67, inheritance is called program concatenation. In addition, inheritance forms the basis for polymorphism in connection with the appropriate type system. The way you use inheritance determines its meaning for the domain model and the software model. There has been vigorous discussion about single and multiple inheritance among language developers. Languages like Smalltalk or Beta support only single

Zullqxd 20/8/04 AM Page 31

T H E O B J E C T M E TA M O D E L

31

inheritance, while multiple inheritance is supported in Eiffel and C. Java supports single inheritance on the class level, and the multiple inheritance concept can often be replaced by named interfaces. Note that you should be careful when restricting access to inherited properties. This technique can be useful when building frameworks or implementing complex patterns. The downside, however, is that this often reduces the readability of your code or design. Major problems can occur with type or runtime errors, particularly with the non-inheritability of friend constructs in C.

T&M Design: Inheritance In our T&M design, we pragmatically assume consistent use of single inheritance when modeling concepts and terms in the domain model, because it ensures that our concept model is clear. After all, a concept model built in the form of a tree is easier to understand than a mesh of complex relationships, although our everyday language has many examples of meshed terms (like the relations of bird—flying animal—fast runner— ostrich). On the other hand, we do not simply map our everyday language to our application systems but reconstruct a domain language instead. This reconstruction should be easy to understand in our targeted application domain. And it should be as clear and minimal as possible. In contrast, multiple inheritance is often useful in the software construction, provided that it is used in a disciplined way and supported by an appropriate low-cost language implementation. Section shows an example that uses multiple inheritance. Let’s look at these things in our EMS example. It is important for our device manager to be able to copy both the current business cards of all staff and a device identification card. For this reason, the class design for our EMS includes a copyable interface and the copy() operation. This interface implements two classes, BusinessCard and DeviceCard. However, the operation is implemented in a different way, because the data to be copied from business cards and device cards differ. Concept modeling is the primary domain motivation for the use of inheritance. From the software view, we are additionally motivated by the separation of specification and implementation into a superclass and a number of subclasses (see Section ). Another software motivation is the use of inheritance for the incremental transfer and modification of properties from fixed class descriptions that cannot be changed in the source text. This is often the case in commercial class libraries. With a commercial library, if you want to change a property you often have no other way but subclassing to implement a change. In this way, you can implement changes even when the impact of such a change on client objects cannot be fully anticipated. In this case, you can encapsulate the change in a subclass, because dynamic binding lets you use both the instances of the new and the old class (polymorphic). Finally, the last of the uses of inheritance we consider acceptable and useful serves to abstract common properties from existing classes. You should always carefully make sure that these common properties are motivated from the domain view, rather than reusing existing code and extracting attributes for the sole reason that you have a piece of code available. In fact, by our definition, inheritance is not about the reuse of existing code but about the abstraction of a common behavior. This view also justifies our critique of “extracting” common attributes into superclasses. These superclasses are

Single and multiple inheritance

The EMS example

Using inheritance to build a hierarchy of terms Using inheritance for incremental modifications

Be careful when reusing existing code and extracting attributes

Zullqxd 20/8/04 AM Page 32

32

T H E T & M O B J E C T M E TA M O D E L

oriented to the internal structure, having not much to do with behavior-specific abstractions. Structure-oriented inheritance hierarchies are often found in projects based on “traditional” data modeling. In summary, our practical experience has shown that “artificial” superclasses oriented to code reuse and the internal structure tend to become hard to understand, thereby hindering further development of such a system.

Discussion: Role Relationships as an Alternative to Inheritance Roles as additional relationships between classes

As we have said, we use inheritance primarily for concept modeling. We interpret superclasses and subclasses in “Is-a” or “Seen-as” relationships. In this sense, a folder is a special form of a container. However, when developing large-scale application systems, we often incur a problem that cannot be elegantly solved in this way. In an organization with several departments or groups, each having a different view of the same work object in different contexts, you obviously have to deal with many different views that could be better modeled by different roles rather than by generalizing and specializing a term. A generalization relationship connects objects solely through their common abstraction. A folder is a container, and a file is a container; that’s the only thing these two objects have in common. A folder is not a file only because both objects are containers. Things are different with changing roles. For example, a customer of our ficticious bank can be both a debtor and a portfolio owner, depending on the situation. We say that the customer plays different roles. Depending on the role, the customer has a different meaning for the bank. We could say that the customer has a different behavior. Nevertheless, when mapping that customer and his or her roles onto the application system, we have to ensure the customer’s domain identity in each of his or her roles. We have developed our own role pattern (see Section ), because inheritance or use relationships won’t let us build these roles. This means that we add a role relationship to our application development process, in addition to specialization and generalization.

Definition: Use Relationships A use relationship corresponds to the traditional call relationship or module import. In fact, it is the classic form of connecting two program components. A use relationship realizes the relation between clients and service providers from the domain perspective. This relationship can be regulated by a contract (see Section ). In the software model, a use relationship interconnects both objects and classes. On the class level, the use relationship is expressed by a (static) type declaration. At runtime, operations of different objects of the same type or subtype can be called using one identifier, based on polymorphism. The EMS example

Let’s see what this looks like in our EMS example. Our device manager will occasionally want to copy the business card of an employee or a device identification card, for example, to use it as a template. He uses a photocopier for this purpose. To copy a business or identification card, we need a copy() operation. The photocopier is not interested in any other operation of the BusinessCard and DeviceCard

Zullqxd 20/8/04 AM Page 33

T H E O B J E C T M E TA M O D E L

33

classes. For this reason, we declared an identifier of the type copyable in the Copier class. At runtime, objects from both the type-confoming classes BusinessCard and DeviceCard are bound to this identifier.

Discussion: Use Relationships A lot of practical experience and knowledge about the meaningful use of this form of component relationship has been collected in the modularization camp. This appeared to have been forgotten in the initial euphoric phase in the advent of object-oriented programming. For example, many modern method and construction textbooks still discuss the pros and cons of inheritance relationships, totally ignoring the use relationship. In our approach, the use relationship between classes ranks high, and its methodological use will be discussed in Section In the object-oriented model, the use relationship is generally based on pointers or references, and a static type is declared for an identifier. At runtime, this identifier can be bound to pointers or references to instances of classes of a conforming type. The idea behind this concept is reference semantics, which is covered in the classic Smalltalk literature, for example, by Adele Goldberg and David Robson. However, you will note quickly that this concept cannot be maintained for (arithmetic) calculations, where we need values in the mathematical sense. Section discusses what all of this means for our object metamodel.

Modularization and the use relationship

Reference semantics

Definition: Polymorphism On a class level, the use relationship means that the class text includes a static definition of the relationships that are basically allowed between the objects of that class and other classes. The actual relationship between objects is then determined by the principle of polymorphism at runtime. The general meaning of polymorphism is the quality or state of being able to assume different forms. In object-oriented programs, polymorphism is the ability to bind objects of different types to an identifier at runtime. If the types of objects have a subtype relationship to the statically declared identifier type, then we speak of constrained or controlled polymorphism, while unrestrained polymorphism means that arbitrary objects can be bound to an identifier. Most statically typed languages use the inheritance relationship to control polymorphic binding. This means that objects of the declared class and all subclasses can be bound to an identifier. This polymorphism is typesafe, that is, all operations of the declared class can also be called in its subclasses as long as the relationship between the superclass and its subclasses is a type-subtype relationship. Dynamically typed languages like Smalltalk allow unrestrained polymorphism. This means that whether or not an operation is supported by an object can be decided not at compile time but only when that operation is called. If that object doesn’t support the called operation, then the system reports a runtime error. This means that programming conventions should be used to control unrestrained polymorphism. The reason is mainly that, unless you can tell from the identifier names, the class text tells you nothing about the objects that are actually bound at runtime.

Unrestrained polymorphism

Zullqxd 20/8/04 AM Page 34

34

T H E T & M O B J E C T M E TA M O D E L

Dynamic binding

The EMS example

Dynamic binding is the prerequisite for polymorphism in connection with redefining operations in subclasses. Dynamic binding means that the runtime environment decides what implemented operation will be executed when you call it. When you can bind different objects to one identifier at runtime, then these could have different implementations by the same operation names. It means that the static program text defines only the messages sent to an object. In our EMS example, we defined an aspect class, copyable, for the photocopier. At runtime, instances of the BusinessCard and DeviceCard classes can be bound to identifiers of this type. The message copy() is bound to the operation implemented in either the BusinessCard or the DeviceCard class, depending on the specific case.

Definition: Abstract Classes In object-oriented languages we often use their ability to separate classes by specification and implementation, for example: ●



A superclass contains the specification, that is, it specifies behavior on an abstract level. The subclasses of this superclass contain implementations, that is, the behavior specified in the superclass is implemented on a concrete level.

From the software view, we implement specifications either by abstract classes or by named interfaces, as in Java. ●





An abstract class is a class from which no instances can be created. They ususally contain at least one nonimplemented (i.e., abstract) operation. Abstract classes are used to specify a common interface and an abstract behavior for all subclasses that implement the concrete behavior. The abstract class itself can implement some operations, which will then be inherited.

We say that a class is abstract (or deferred) when at least one of its operations is abstract. Some object-oriented languages (e.g., Java and Eiffel) let you mark a class as an abstract class, even if it contains no abstract operations. In other languages, abstract classes have to be denoted as such by convention, or implicitly by a deferred method. Abstract classes are often more than pure interface specifications. The operations declared in an abstract class can be used right there in the abstract class. Using these abstract operations you can implement several operations. They can be called to serve as template operations or standard implementations by client classes. This technique is important for building frameworks. Ralph Johnson and Vince Russo distinguish three types of operations in abstract classes: ●



Abstract operations are not implemented, that is, their implementation is left to subclasses. But abstract operations specify an interface mandatory for all subclasses. An operation specifying only a default implementation but intended for redefinition in subclasses is often called a hook. Template methods implement an algorithm based on abstract operations. This algorithm is fully specified, but it lacks the implementations of the abstract operations to be actually executable.

Zullqxd 20/8/04 AM Page 35

T H E O B J E C T M E TA M O D E L

35

AbstractClass templateOperation()

baseOperation();

abstractOperation()

abstractOperation();

baseOperation()



SubClass abstractOperation()



FIGURE Specializing an abstract class.

Base operations are the operations already implemented in the abstract class in full and executable.

Figure shows an abstract class whose interface includes the following operations: templateOperation, abstractOperation, and baseOperation. Both baseOperation and abstractOperation were used to implement templateOperation, while abstractOperation itself will be implemented later in the inheriting class. The subclasses of abstract superclasses are normally used on the basis of polymorphism. However, we often have to expand or specialize an interface in subclasses for domain or software reasons. If we want to use the instances of subclasses both polymorphic and by their dynamic type, we will soon find that we need a metaobject protocol (see Section ).

Example

Discussion: Specification and Implementation An important way to use inheritance is to separate the specification from the implementation. A common superclass specifies the interface and the abstract behavior of all subclasses. The fact that no objects can be created from an abstract class tells us that we cannot use it directly. The subclasses are responsible for implementing the concrete behavior. On the other hand, it is normally sufficient for a client to know the abstract class with its abstract behavior. For example, you can hide an entire class tree “behind” the abstract superclass. With their interface and behavior specifications, abstract classes define how their subclasses can be handled, thus defining in certain limits the entire system design. Abstract classes with a hidden class tree form the basic idea for a fundamental design pattern, the so-called Family pattern of Erich Gamma,5 and expanded constructions like the Bridge pattern of Gamma et al. work similarly. The T&M design lets you implement aspects in this way (see Section ) by use of aspect classes.

Definition: Loose Coupling The use of abstract classes is one example of how you can develop systems with loosely coupled components. 5. E. Gamma: Objektorientierte Software-Entwicklung am Beispiel von ET++. Berlin, Heidelberg: SpringerVerlag,

Separating specification from implementation

Patterns with abstract classes

Zullqxd 20/8/04 AM Page 36

36

T H E T & M O B J E C T M E TA M O D E L

A component is loosely coupled to another component when the client does not know the entire interface of the provider but only a section of that interface (and its behavior). This part of the entire interface should be defined by a type and contain only operations actually needed by the client for this coupling. As a result of loose coupling, you can replace both individual classes in the program code and objects at runtime by appropriate components with the same interface and similar behavior but a different implementation.

Discussion: Loose Coupling

Loose coupling and object creation

Loose coupling was motivated by the discussion of modularization concepts (see Section ). These concepts say that components should have little dependencies to the outside while having a strong contextual coherence inside. One technique to achieve loosely coupled components addresses only the type or interface of other components when using these components, without knowing the concrete classes and their implementation (Gamma et al.: “Program to an interface, not an implementation” p. 18). We take this concept a step further, reducing loose coupling to the section of the interface, which is the minimum required for use. Section will discuss aspects for implementing loosely coupled tools and materials. When using loose coupling between a client class and the abstract superclass it uses, we have to solve a construction problem: The concrete subclass has to be known at the location where we actually create an object. Initially, this seems to conflict with our decoupling idea. A number of mechanisms have been proposed to be able to create concrete objects without losing the decoupling concept. Gamma et al. describe these mechanisms in the form of creational patterns. Section will introduce a creational pattern, the Product Trader, which is particularly useful for our T&M approach.

2 . 2 M O D U L A R I Z AT I O N Introduction Classes are traditional modularization units for object-oriented design. More recently, larger design and construction units, like design patterns or packages, have been proposed as modularization units. This section discusses the basic principles of modularization in view of using them in our object-oriented design.

Context: Modules and Object Orientation

Modules and classes

In the software model, you can think of classes as a further development of the modular concept. As Bertrand Meyer says, “Classes provide the basic form of module”. This means that basically the same principles of maximum cohesion and minimum coupling apply to both modularization and the use relationship. Unfortunately, these traditional modularization principles cannot simply be transposed to object orientation. First, classes or objects have a different granularity than common modules. Although it is customary to build an application system from far less than a hundred modules, the number of classes or objects can easily reach ten times that number in a moderately complex application. Each class includes a manageable number of operations.

Zullqxd 20/8/04 AM Page 37

M O D U L A R I Z AT I O N

If we think of objects and classes as the “atoms” of our object-oriented design, we obtain a totally different view. Obviously, we design and build our application in units or components, formed of more than one class or one object. Such a unit could be a container with a table of contents and markers or iterators (see Section ). To implement such a container, we need mutual-use relationships. Note that some successful patterns, such as those described by Gamma et al., for example, Visitor, Observer, or Mediator, are also based on mutual use. Recent discussion has led to the understanding that the conceptual design and construction units used in object orientation are often beyond a single class, and it has also led to the development of design patterns, clusters, subsystems, and frameworks. This means that the modularization principles in our object metamodel have to be reformulated in view of these design and construction units. We will attempt to reformulate them for the basic design units in Section and for frameworks in Section

37

Object-oriented design and construction units

Definition: Principles of Object-Oriented Modularization Maximum cohesion and minimum coupling are the fundamental factors for traditional modular design. Cohesion is the “inner connection” between the properties of a design or construction unit. The principle of maximum cohesion requires a strong bond within a design or construction unit. Coupling is the relationship between different design or construction units. Minimum coupling attempts to reduce the bond between units, particularly to avoid cyclic use. Bertrand Meyer proposed a list of criteria and rules to facilitate the transfer of the modular concept to object orientation. We will briefly introduce some of these criteria and rules below. One of the most important features of object orientation in this context is the open-close principle. Open-Close Principle: A design or construction unit is open if it can be extended. In contrast, a design or construction unit is closed if it can be used by clients in a stable way. A design and construction unit should meet the following important criteria: ●







Decomposability: A design problem should be decomposed in smaller and less complex partial problems, which are mapped to design and construction units. These units should form a simple and independent structure. Composability: Design and construction units should be composed by simply recombining them into new software systems in different application domains. Understandability: Each design and construction unit of a software system should be understood independently of the other units. Continuity: A change to the design problem resulting from the domain or software system context should lead to changes only in one or a few design and construction units.

Modularization criteria

Zullqxd 20/8/04 AM Page 38

38

T H E T & M O B J E C T M E TA M O D E L

Modularization rules

To meet these criteria, we have to observe the following rules: ●











Direct mapping: The structure of the software system should closely relate to the structures identified in the application domain. Few interfaces: Each design and construction unit should interact with as small a number of other units as possible. Small interfaces: When two design and construction units interact, then they should exchange as small an amount of information as possible. Explicit interfaces: When two design and construction units interact, then this exchange should be explicit. Information hiding: Clients should see and access only relevant properties of a design and construction unit. Open-closed principle: Design and construction units should be both open and closed.

THE CONTRACT MODEL Introduction We want to use an object-oriented approach to develop not only expandable, reusable, and modifiable but also correct and robust classes. We try to achieve robustness by modeling behavioral objects, that is, modeling objects characterized by their behavior and not by their inner structure—their attributes. We use the contract model to sketch a concept allowing us to specify the behavior of operations in a “semiformal” way. This contract model represents an important contribution to better software quality and should form the basis of each development project. It provides what Bertrand Meyer calls “contracting for software reliability.”

Definition: Contract Model We can define the essence of the contract model as follows: A contract model specifies the use relationship between classes as a relationship between service providers and clients, based on a formal contract. A contract specifies the pre-condition that a client must meet before the service provider supplies its service. The service supplied is specified in a post-condition. Contracts are described on the provider side; they have the form of assertions, that is, they are pre- and post-conditions as well as invariants.

Contracts are operation calls

The use relationship between classes is interpreted as a service relationship between a client and a provider (see Figure ). In this context, a class offers a service that another class, acting as the client, wants to use. These two classes enter a contract relationship, where the contract specifies all underlying assertions as well as the rights and obligations of both parties relating to that service. The contract model is implemented by pre- and post-conditions for operations as well as for class invariants, having the form of boolean expressions and residing in the provider class. Contracts established between classes always refer to operation calls, that is, requests for services. The pre-condition specified for a contract defines the rules that

Zullqxd 20/8/04 AM Page 39

THE CONTRACT MODEL

39

contract with assertions

Client

Supplier Service

Client



Service + serviceMethod1 (arg1) :returns1 + serviceMethod2 (arg2) :returns2

Supplier - attr1 - attr2 - + serviceMethod1 (arg1) :returns1 + serviceMethod2 (arg2) :returns2

have to be observed to be able to call an operation. The client is responsible for observing this pre-condition. More specifically, the client has to ensure that the specified conditions are met. In order for the client to meet this obligation, the predicates used as test questions in the pre-condition have to be accessible at the provider’s interface. Before calling an operation, the client can then test for observation of the pre-condition and establish the required state, if that pre-condition is not yet met. Once the pre-condition is in place, the requested operation is executed, and the provider declares that they guarantee the post-condition. This condition is also composed of boolean expressions and does not have to be tested by the client. The client can assume that the condition holds when the operation has terminated. An invariant is formulated for a class as an overall property of that class, which preserves its consistency. This holds true for each service provided, that is, its observance is tested upon each call.

FIGURE Service provider and client in the contract model.

Invariants

Discussion: The Contract Model By stating assertions within the interplay between clients and service providers, we can make a significant step towards the correctness and reliability of our software system. In this context, correctness refers to the conformity between specification and implementation. We want to use invariants and pre- and post-conditions to describe parts of a behavior specification contained in the class text and make them checkable. This means that the contract model helps us to ● ● ●

reduce design and construction errors; improve the understanding of our classes; and use an appropriate exception mechanism to catch runtime errors early.

Context: The Contract Model and Abstract Data Types From the software view, classes should be implementations of abstract data types. Using known language features available in most object-oriented programming languages we can only define operations and attributes. However, if we want to use types to model “a set of programming language objects with similar behavior,” we need an adequate means

Using classes as abstract data types

Zullqxd 20/8/04 AM Page 40

40

T H E T & M O B J E C T M E TA M O D E L

of expression. The reason is that the specification of abstract data types involves axiomatic semantics, which is normally expressed by axioms and equations. Objectoriented programming languages do not normally support such axiomatic semantics. We can use the contract model, which Bertrand Meyer describes as “design by contract,” to overcome the gap between specification and implementation of abstract data types.

T&M Design: The Contract Model

Contract violations

The contract model is currently supported only by Eiffel among the object-oriented languages, where assertions can be formulated as an independent sublanguage (see Figure ). However, it has proven useful in practical projects to try to transport the assertion concept to other programming languages. For example, our JWAM framework implements the assertion concept in Java. As in the case of a commercial contract, we have to check for the observance of a contract, and the violation of the contract has to have corresponding consequences. The contract model is more than a pure piece of documentation only if contract violations are sanctioned. For this reason, we should link assertions to an appropriate exception mechanism. An exception will then be thrown at the client’s end as soon as a pre-condition is violated, while a violation of post-conditions and invariants will lead to exceptions at the provider’s end.

T YPES Introduction Current object-oriented programming languages use classes and types interchangeably. Though this is practical, it blurs the conceptual differences we want to observe to FIGURE Example showing assertions in Eiffel.

class stack feature

pop is require not empty

Pre-condition

do number_of_elements := number_of_elements - 1; ensure not full



Post-condition

end;

invariant empty implies (number_of_elements = 0) end -- class Stack

Invariant

Zullqxd 20/8/04 AM Page 41

TYPES

ensure a clean software system. This holds true particularly when we use a dynamically typed programming language like Smalltalk, or when we have additional type definition options for interfaces, as in Java.

Definition: Types A type traditionally denotes a set of values and the admissible operations on these values. From the software view, a type is used to declare identifiers and parameters for a program to test its typesafe use. In the object-oriented world, a type specifies the behavior of objects in the sense of an abstract data type. A type specifies the syntax of an interface, that is, it names the operations you can use to call an instance of that type. In addition, a type can describe the behavior of objects in the sense of a protocol. In contrast to a class, a type does not include information as to how the state and implementation of operations should be represented. With this definition of type, we have determined at least the checkable interface used by instances of that type. This means that an identifier we declared to have that type can be bound only to objects that meet this interface. In other words: a type should be checked. For this reason, we like typed languages, because declared identifiers and parameters of our program can then be checked for typesafe use either statically (at compile time) or dynamically (at runtime). In addition, we want to specify potential limits for the behavior of these instances. As we saw in Section on the contract model, it is not easy to transfer the axiomatic semantics of abstract data types to an object-oriented construction. Nevertheless, we expect that instances of a specific type behave in a “semantically compliant” manner. Accordingly, assertions should also be included in the definition of a type. A type in the sense of an abstract data type does not tell us anything about the concrete implementation of the interface and its behavior. This means that implementations and information about the internal structure are not part of the definition of a type.

Context: The Theoretical Concept of Types The concept of types is primarily motivated by software-specific factors. We use types to specify our construction units. Following the general definition developed by Luca Cardelli and Peter Wegner, a type is a set of objects with similar behavior. In their formulation, Cardelli and Wegner didn’t focus on the object-oriented elements, that is, classes and objects, but generally refer to programming language objects. When we try to transfer this to object orientation, we could say that, for example, the two rooms, a and a, in Figure have the same interface and a similar behavior, so that we can use the type Room to describe them. Traditionally (e.g., by the definition of Hoare), an object of a programming language may have one and only one type. The object-oriented inheritance principle requires us to expand this concept of types. By this principle, an object is exactly the instance of a (creating) class, but it can have more than one type.

Type and behavior

41

Zullqxd 20/8/04 AM Page 42

42

T H E T & M O B J E C T M E TA M O D E L

Room

Room

aRoom

devices : DeviceList

devices : DeviceList

putBusinessCard() putDevice()

FIGURE From objects to the type.



putBusinessCard()

putDevice()

getDimensions() isConsistent()

getDimensions() isConsistent()

aRoom

devices : DeviceList



A type is characterized by the set of its properties. For example, an object x is of type T exactly when object x meets the properties characterized by type T. The following properties can be described by a type: ● ● ●

the class of an object; the names of operations or the entire signatures of an object; and the behavior of operations (e.g., pre- and post-conditions and invariants).

Real-world type systems normally offer only a fraction of these properties. Types can be organized in type hierarchies by forming subtypes. A type hierarchy according to Barbara Liskov consists of subtypes and supertypes. A subtype supports at least the operations specified in its supertype, with the following variants: ● ●

the operations have identical signatures; and the types of parameter and result objects can themselves be of a subtype or supertype of the original type (covariance and contravariance).

At runtime, an instance of a subtype must be able always to assume the place of an instance of the supertype, where either identical or similar behavior is required, that is: ●



an instance of a subtype does not cause any observable change to the program; and an instance of the subtype behaves similarly in that it produces the expected behavior and never a runtime error.

Conceptual methods used to specify the behavior of subtypes are discussed in the seminal work of Barbara Liskov and Jeannette Wing. The problem relating to the covariant redefinition of parameter types and a proposed solution are discussed by Bertrand Meyer.

Discussion: Types Building subtypes is primarily a specification concept that we can use to express that objects behave similarly. This concept reaches beyond the usual check for identical interface names. This means that it is not sufficient to simply be able to interpret the called operation by the object. The reason for this is that it only means that the call does not immediately cause a runtime error. What we normally need is a way to interpret all

Zullqxd 20/8/04 AM Page 43

CLASSES AND TYPES

43

operations specified by a type interpret, which leads us to the concept of similar behavior. Similar behavior is a much “softer” formulation than the identical behavior recommended by many computer scientists. Unfortunately, it is difficult to check it formally. In contrast, when we implement an object or redefine its properties, we expect it to behave both “in the sense of ” the specification and formally compliant with its type. Types and behavior specifications become increasingly important in the use of components. When components are shipped merely as binary units, then all that remains to evaluate their functionality is basically the interfaces and thus the type information. In that case, it is important to know what other characteristics are assigned to types, in addition to the signatures, for example, assertions of a contract model.

CLASSES AND T YPES Introduction In the advent of object-oriented programming, many developers used classes and types synonymously. The reason for this was that the construction of classes was the only way to introduce user-defined types. Over the course of time, object-oriented programming languages have been improved and expanded so that the typing concept is now more pronounced. For this reason, developers should understand the conceptual differences between classes and types.

Classes in Your Design From the domain-specific perspective, classes are our elementary design and construction units. In the design, we model the common features of similar objects in classes. These common features apply to objects in their behavior and state. In this context, class hierarchies should correspond to the domain-specific concept model. This means that they model the basic concepts or abstractions of your application domain. On the construction level, a class defines how its instances behave and how they are built. In this context, class hierarchies express the generalization or specialization of this behavior and construction. The compiler and the runtime system ensure that the correct instances are created based on a set of “complete” class descriptions.

Differences between Types and Classes Compared to a class, a type is primarily a specification concept that defines an “external” view of declared identifiers and program objects. Note that the emphasis is more on the software implementation rather than on the domain modeling and construction side. A type defines the syntactic and (to a limited extent) the semantic characteristics that can be guaranteed for the structure of the program. Let’s take a closer look at these differences. ●



Besides the interface, a class also defines the behavior and structure of its instances, that is, their internal state and the implementation of their operations. The type of an object refers intially only to its interface, that is, a set of messages to which the object can respond. The type of an identifier specifies what objects can be basically bound to it.

How classes and types differ

Zullqxd 20/8/04 AM Page 44

44

T H E T & M O B J E C T M E TA M O D E L ●









To be able to define the behavior of the instances of a type, in addition to the interface, we can implement types by classes. As long as the type hierarchy and the class hierarchy match, you can use assertions and controlled redefinitions to achieve a similar behavior of objects. Some languages (e.g., Java) can use named interfaces instead of classes to introduce user-defined types. Most object-oriented programming languages provide primitive data types (e.g., integer) that are not defined as classes. An object can have different types, and objects from different classes can have the same type. One part of the interface of an object can be characterized by a type, and other parts by other types. For two objects to be of the same type, it is sufficient that only part of their interfaces are equal.

Discussion: Classes versus Types Classes and types can be totally separate concepts if the type refers strictly to the interface definition. If a type represents only a named interface definition, then it merely guarantees that instances of that type recognize a certain set of messages. Each type names operations that have to be defined in some place of your program. A class can then declare the types it meets in the sense of named interfaces. The actual class that defines these operations is irrelevant and independent of the class hierarchy. Of course, if the programming language we use couples the class and type concepts, then there is a relation between class and type. In that case, the class defines a type. When we say that “an object is an instance of a class,” we imply that the object supports the interface defined by the class. A type-compliant call of a message requires the object to understand the message, in other words, that the object’s class implements the called operation. We can go one step further in coupling classes and types when we use the type definition to specify the behavior of instances. In this case, it appears to be meaningful to use an appropriate class to define the behavior of the instances of a type. If the type hierarchy and the class hierarchy match, then we can define and limit the concrete or abstract behavior of objects of a type by the class hierarchy. Appropriate means for this approach would be the contract model and the mapping of our concept model onto domain-specific class hierarchies, which are designed by the principles of generalization and specialization.

Background: Programming Languages and Types Popular object-oriented languages use different type and class concepts, for example: Java, Objective C: named interfaces



Java separates classes and types by introducing interfaces, as does Objective C with its protocols. In these languages, a class can declare, besides its superclass, which named interfaces it meets. Classes can be grouped by class hierarchies and by their interfaces. This means that classes can fall under a common named interface, even when there is no inheritance relationship between them.

Zullqxd 20/8/04 AM Page 45

VA L U E S A N D O B J E C T S ●



C and Eiffel use the class construct to define both the type of an object and its implementation. In addition, these languages let you write pure specification classes, from which no instances can be created. Similar to C, C also supports types that are not classes. In Smalltalk, there are no type declarations for identifiers and program units, that is, there is no type checking during compilation. Consequently, whether or not an object is called by the appropriate message through an identifier is not checked, so that a runtime error occurs if the object does not offer the called operation. The Smalltalk world works with message conformity rather than with type conformity, in other words, not a specific class or type relationship is in the foreground, but the question of whether or not an object understands a message.

T&M Design: Classes and Types In our T&M design, we need a clear understanding of the possibilities offered by classes and types as constructs, and which concepts we want to use in our applications. Do we want to separate a named interface from the definition of its behavior? Should there be a hierarchy of named interfaces, in addition to the class hierarchy, and what does this mean in our design? What kind of reliability would we like to have when calling messages, and when (at compile time or runtime) do we want to check this reliability? The answers to these questions determine whether or not we can easily deal with the constructs of a language, how we use that language, and whether or not we should add our own mechanisms, such as runtime type checks in Smalltalk. Some answers originate from practical experience with the T&M design. For example, type systems represent a major support for the save construction of software systems. Dynamically typed languages like Smalltalk offer more flexibility during the actual construction phase, compared to statically typed languages. However, it is often meaningful to design in Smalltalk as if that language were typed. To be on the safe side, we will add dynamic type checks at important points in our software system. Inheritance hierarchies should correspond to domain hierarchies, thus defining a similar behavior. This means that we normally work towards class hierarchies in the form of type hierarchies. In cases where we cannot or do not want to fall back on multiple inheritance to implement software architectures technically, named interfaces are a meaningful alternative. We then have to stick to design conventions to ensure similar use behavior.

2 . 6 VA L U E S A N D O B J E C T S Introduction Values and objects are two fundamental concepts for the development of interactive software. This section explains that the differentiation of values and objects is not a terminological trick, but important for the design and construction of software systems. We use the term domain values to introduce an important concept of the T&M approach. Domain values can be used as the “atomic” design and construction units for application-oriented software development.

45

C, Eiffel: classes act as types Smalltalk: no type declarations

Zullqxd 20/8/04 AM Page 46

46

T H E T & M O B J E C T M E TA M O D E L

Characteristics of Values and Objects To better understand the following discussion of the terms value and object, it appears meaningful to understand first where these two terms differ. The taxonomy in Figure is schematic and in no particular order, but shows the essential characteristics of values and objects. It is based on the seminal article by Bruce J. MacLennan. We will explain the differences listed in Figure in a moment. ●



A value has no temporal or spatial dimensions. This means that concepts like time, duration, and location are not applicable. Values have no beginning and no end, and they exist in no particular place. No values are created in expressions, and they are not consumed. For example, it wouldn’t make sense to talk about time in the equation 40  2  42, or about the fact that the addition “creates” a new value. And it would be equally useless to talk about “the 42 on top of this page” when referring to the value and not to its concrete representation in digits. In contrast, objects exist in time and space, and they have a beginning and an end. Any two objects can differ from one another merely because they reside in different locations. For example, you can create a folder. Two otherwise identical folders can be in different locations. It would make sense to talk about “the folder I used yesterday.”

Another difference between values and objects is that a value is abstract and has no identity. ●



FIGURE Characteristics of values and objects.

A value is an abstraction from all concrete contexts. It is not bound to the existence of concrete things. And because it has no identity—only equality—it wouldn’t make sense to talk about several instances of a value (although it would make sense to talk about its different representations). For example, $50 is a value. Though there are many bank notes representing this value, there is not more than one instance of the value itself. Also, it would only make sense to talk about whether or not a bank note is worth $ In contrast, objects are concrete instances of a generic concept (a class) that have an identity. There can be many equivalent but different instances of a class. For example, you can create several instances of an application form on your electronic desktop that differ in that they reside in different folders.

A value is: ● ● ● ● ● ●

timeless abstract immutable stateless unique spaceless

An object: ● ● ● ● ● ● ● ●

exists in time and space has identity is concrete can be instantiated is changing is stateful is created and destroyed can be used cooperatively

Zullqxd 20/8/04 AM Page 47

VA L U E S A N D O B J E C T S

Yet another difference is that a value is immutable or invariable. ●



Though you can calculate and relate values to other values, they won’t change. Values can be named. The value of a name or an identifier (of an “unknown quantity”) cannot yet be calculated or can be undefined. The same name can be bound to another value, depending on the context. For example, when looking at the equation 40  x  42; pi  , the idea that adding x would change the value of the number 40 to 42 is wrong. Also, x is not a variable, but has a calculable value. We can call the number by the name pi and use the same name to bind it to the value in another context. In contrast, an object can change over time, that is, its state can change without losing its identity. And this identity does not have to be linked to a specific name. For example, you can edit an application form that you created yesterday and sign it tomorrow. You could change the form’s name from “New application” to “Edited application” without risking that it might lose its identity.

Yet another difference relates to how you can use values and objects. ●



Considering that a value has no identify and no location, and that it is invariable, it would be hard to build communication and cooperation on the basis of values alone, because values cannot be exchanged or edited. In situations where you have to communicate and cooperate on the basis of values, you often use a specific value to “build” an identity. For example, an abstract value of $ won’t be of much use in the banking business. It will become useful only if it is connected with an account, and if this account is seen in its temporal change. Only then can you use that value for cooperative work. For instance, to build an account in a value-based database, you can use the account number for unique identification of all other values related to this account. In contrast, objects can be used jointly, if you can access them by references. Then they can be known by different names in different locations, and you can use them as a common work object. Unfortunately, there is an alias problem to be solved: An object can be changed in one context without another context taking notice of that change. For example, a form can be accessed by identifiers on two different electronic desktops. This means that two employees can use it for cooperative work and coordinate their work through this form. Problems will arise when one employee does not see that the other employee changed the form without prior agreement to do so.

Using Values When we think of using values, we probably first think of mathematics or engineering, where numerical analysis is of prime interest. For example, mathematical problems are solved by operations on numbers, a form of values. However, in our everyday lives, values and numbers have a much broader meaning. We use them to identify, characterize, count, or order things and eventually to represent them as measurable entities. We basically always use values when we model abstract entities and do not want to be distracted by concrete and objective characteristics. In doing this, we also abstract from the context of the thing represented by a value. In this sense, the authors of a popular textbook, Richard Bird and Philip Wadler, discussed functional programming

Using values

47

Zullqxd 20/8/04 AM Page 48

48

T H E T & M O B J E C T M E TA M O D E L

Whelp, I've gotten GCC and make and what not as recommended in previous posts on this thread. Ran make and it hit this snag.

arm-none-eabi-gcc -I. -Iusb -DMIST -MM Cstartup_SAM7.c -MT Cstartup_SAM7.d -MT Cstartup_SAM7.o -MF Cstartup_SAM7.d
arm-none-eabi-as -ahls -mapcs -o crt.o Cstartup.S > sprers.eu
arm-none-eabi-gcc -I. -Iusb -DMIST -c -fno-common -O2 --std=gnu99 -fsigned-char -DVDATE=\"`date +"%y%m%d"`\" -o Cstartup_SAM7.o -c Cstartup_SAM7.c
arm-none-eabi-gcc: error: +md`": Invalid argument
make: *** [Cstartup_SAM7.o] Error 1


So I checked the make file and realized the library directories need to be entered so did that and now I just get this

arm-none-eabi-gcc -I. -Iusb -DMIST -c -fno-common -O2 --std=gnu99 -fsigned-char -DVDATE=\"`date +"%y%m%d"`\" -o Cstartup_SAM7.o -c Cstartup_SAM7.c
arm-none-eabi-gcc: error: +md`": Invalid argument
make: *** [Cstartup_SAM7.o] Error 1

I have the arm-none-eabi files all together in the gnu directory with make and everything. I'm terrible at this. anyone have a compiler .zip? :P
ENG
- PANDA ANTIVIRUS 32 & 64 BIT
- PANDA ANTIVIRUS PLUS FIREWALL
- PANDA INTERNET SECURITY V
- PANDA INTERNET SECURITY
- PANORAMASTUDIO
- PAPER FOLDING 3D V
- PARAGON DRIVE BACKUP PROFESSIONAL EDITION + RECOVERY CD IMAGE
- PARAGON DRIVE BACKUP PROFESSIONAL / FULL
- PARAGON DRIVE BACKUP ENTERPRISE SERVER EDITION
- PARAGON DRIVE COPY VER. PROFESSIONAL
- PARAGON FOSI AIO
- PARAGON PARTITION MANAGER ENTERPRISE SERVER EDITION
- PARAGON PARTITION MANAGER PROFESSIONAL V
- PARAGON PARTITION MANAGER V ENTERPRISE
- PARALLELS WORKSTATION
- PARALLELS WORKSTATION
- PARALLELS WORKSTATION V
- PARENT CONTROL
- PARETOLOGIC ANTI-SPYWARE V
- PARETOLOGIC REGCURE
- PARTITION MAGIC
- PARTITION MAGIC V
- PARTITION MANAGER PRO 8 00 RECOVERY CD RETAIL
- PARTITION RECOVERY V
- PASSMARK PERFORMANCETEST V6 1
- PASSMARK WIRELESSMON PROFESSIONAL V BUILD
- PASSWARE KIT ENTERPRISE PORTABLE
- PASSWORDSPRO V
- PAY-PER-VIEW CHAT V W/FLASH SOURCE ($)
- PAYPAL SHOP BUILDER V
- PC CHAPERONE PROFESSIONAL V5
- PC CURRENCY CALCULATOR PRO V
- PC DJ RED V 5 3
- PC ICON EXTRACTOR V
- PC OPTIMIZER PRO V
- PC PITSTOP OPTIMIZE V COMPLETE
- PC REPAIR V
- PC SECURITY TWEAKER VER
- PC SYSTEM UTILITIES
- PC TOOLS - ALL PRODUCTS
- PC-CHECKUP
- PC-CHECKUP V RETAIL
- PC-CILLIN INTERNET SECURITY
- PC-CLEANER V
- PCSHOWBUZZ
- PCSHOWBUZZ V
- PCTV 4 ME
- PCTV4ME 2
- PDF CONVERTER PERSONAL EDITION
- PDF CONVERTER PROFESSIONAL 4
- PDF CREATOR PLUS V
- PDF PASSWORD REMOVER V
- PDF TO WORD V
- PDF TO WORD V WIN98 / ME / NT / / XP / / VISTA
- PDF TOOLS AIO 12 IN 1
- PDFFACTORY PRO V FULL
- PDFKEY PRO
- PDFPLUS
- PEPAKURA DESIGNER
- PERFECT KEYLOGGER
- PERSONAL MOTIVATION CALENDAR V
- PES 6 FULL
- PG CALCULATOR V
- PHANTOM CLOAKER PROFESSIONAL V
- PHONE EDITING TOOL
- PHOTO POS PRO V1 34
- PHOTO WALLPAPER MAKER V
- PHOTOBLENDER V MULTILINGUAL
- PHOTOCROPEDITOR V
- PHOTODENOISING VER
- PHOTODEX PROSHOW GOLD V3 0
- PHOTODEX PROSHOW GOLD V
- PHOTODEX PROSHOW PRODUCER
- PHOTODEX PROSHOW PRODUCER V
- PHOTOFRAME PRO V + LIBRARY + UPDATE
- PHOTOFRAME PRO V FOR ADOBE PHOTOSHOP
- PHOTOGRAPHIC ARTWORK
- PHOTOLIGHTNING V
- PHOTOPROTO V1 04 20 FOR ADOBE PHOTOSHOP
- PHOTOSHOP 1 CLICK WOW PRESETS
- PHOTOSHOP CS2 PORTABLE TURKCE & ENGILSH
- PHOTOSHOP BRUSH BROWSER - PORTABLE
- PHOTOSHOP CS2 TYPE EFFECT CD
- PHOTOSHOP CS3 EXTENDED FINAL
- PHOTOSHOP INTERFACE ASSISTANT V2
- sprers.euNA-AIO
- PHOTOWATERMARK PRO V RETAIL
- PHOTOZOOM PROFESSIONAL 2
- PHOTOZOOM PROFESSIONAL V
- PHP DESIGNER PROFESSIONAL V5 2 1
- PHP DESIGNER PROFESSIONAL V
- PHP DESIGNER PROFESSIONAL V
- PHP DESIGNER PROFESSIONAL
- PHP DESIGNER PROFESSIONAL V
- PHP FORM WIZARD V
- PHP REPORT MAKER
- PHPRUNNER
- PIANOFX STUDIO 4
- PICSPLORER
- PICTURE MERGE GENIUS
- PICTURESQUE V
- PICTURESTOEXE
- PICUTEL SMARTRESIZE FOR PHOTOSHOP
- PIE STUDIO
- PINNACLE AVID LIQUID V
- PINNACLE STUDIO
- PINNACLE STUDIO PLUS V11
- PINNACLE STUDIO ULTIMATE 11 + BONUS DVD + UPDATE
- PIONEER DJ SOFTWARE
- PIONEER DJ,S V
- PIRATE RADIO DESTINY BROADCASTER
- PIRATES WINDOWS VISTA SOFTWARE PACK
- PIXARRA TWISTED BRUSH
- PIXARRA TWISTEDBRUSH V
- PIXARRA TWISTEDBRUSH VER 11 8
- PIXEL LOGO
- PIXELGENIUS PHOTOKIT V
- PL/SQL DEVELOPER V
- PLATO DVD RIPPER V
- PLATO DVD RIPPER V
- PODCAST STATION V
- PORN TOOLS AIO
- PORTABLE !NTERNET EXPLORER V (12 MB ONLY)
- PORTABLE 7-ZIP
- PORTABLE 7ZIP VER.
- PORTABLE ABBYY FINEREADER PROFESSIONAL EDITION MULTILANGUAGE
- PORTABLE ACDSEE PRO
- PORTABLE ACRONIS TRUE IMAGE USB STICK EDITION
- PORTABLE AD-AWARE PRO
- PORTABLE AD-AWARE SE PROFESSIONAL MULTILANG
- PORTABLE ADOBE DREAMWEAVER CS3
- PORTABLE ADOBE DREAMWEAVER CS3 V9 BUILD
- PORTABLE ADOBE PHOTOSHOP 10 CS 3 (ENG)
- PORTABLE ADOBE PHOTOSHOP CS3 V
- PORTABLE ANYMP4 MEDIA CONVERTER
- PORTABLE ASHAMPOO PHOTO OPTIMIZER V
- PORTABLE ATOMIX VIRTUAL DJ PROFESSIONAL
- PORTABLE AUTOCAD
- PORTABLE AUTOCAD
- PORTABLE BEARDED FROG ENLARGER PRO V3 02
- PORTABLE BLAZE VIDEO MAGIC
- PORTABLE CAMTASIA STUDIO
- PORTABLE CLEANERZOOMER PROFESSIONAL V
- PORTABLE COLLECTION V
- PORTABLE COLOR SCHEMER STUDIO V
- PORTABLE COREL DRAW 11
- PORTABLE CYBERLINK POWERCINEMA
- PORTABLE DRIVER GENIUS PRO
- PORTABLE DVD DUMPER
- PORTABLE DVD-CLONER IV
- PORTABLE EMS MYSQL MANAGER PROFESSIONAL V
- PORTABLE ERROR DOCTOR
- PORTABLE ESET NOD32 V
- PORTABLE FIREFOX (ENG)
- PORTABLE FIREWORKS 8
- PORTABLE FLASH EFFECT MAKER PRO V ( TEMPLATES)
- PORTABLE FLASH PLAYER PRO
- PORTABLE FLASHGET
- PORTABLE FOX VIDEO CONVERTER
- PORTABLE GOOGLE EARTH V
- PORTABLE GUITAR PRO
- PORTABLE HTML TO PHP CONVERTER 4
- PORTABLE ICY RADIO V
- PORTABLE IMGBURN (VIRTUALIZED)
- PORTABLE IP SHIFTER V
- PORTABLE JASC PAINT SHOP PRO 9
- PORTABLE JASC PAINT SHOP PRO 9 (SINGLE VIRTUALIZED EXECUTABLE)
- PORTABLE JETAUDIO V7 PLUS
- PORTABLE KASPERSKY ANTIVIRUS
- PORTABLE KMPLAYER BETA
- PORTABLE LINKSTASH 1 7 2 0
- PORTABLE LUCIS PRO V5
- PORTABLE MAINCONCEPT MPEG ENCODER V1
- PORTABLE MEDIA CLASSIC PLAYER
- PORTABLE MEDIACODER 0 5 1
- PORTABLE MICROSOFT OFFICE
- PORTABLE MICROSOFT VISIO
- PORTABLE MIRC
- PORTABLE MS WORD
- PORTABLE MYPHONEEXPLORER
- PORTABLE NATURE ILLUSION STUDIO PRO
- PORTABLE NERO MULTI (23)LANG
- PORTABLE NERO LATEST EDITION
- PORTABLE NORTON ANTIVIRUS
- PORTABLE NORTON GHOST
- PORTABLE NORTON SYSTEMWORKS USB DRIVE EDITION
- PORTABLE NUCLEUS KERNEL FOR FAT AND NTFS
- PORTABLE OFFICE
- PORTABLE OPERA BUILD - FINAL (MULTILANG)
- PORTABLE OPERA MULTILANG
- PORTABLE PANDO EN-FR
- PORTABLE PANORAMA COMPOSER
- PORTABLE PC-CHECKUP V
- PORTABLE PIXRESIZER V
- PORTABLE PORNO LINKS
- PORTABLE PROGRAM KOLEKSIYONU
- PORTABLE PROSHOW PRODUCER $
- PORTABLE REAL PLAYER 10
- PORTABLE REVO UNINSTALLER
- PORTABLE SKYPE
- PORTABLE SNAGIT
- PORTABLE STEALTHDISK MOBILE
- PORTABLE SUBTITLE WORKSHOP
- PORTABLE SUPER INTERNET TV
- PORTABLE SUPER SCREEN CAPTURE PRO
- PORTABLE SWISH ZONE PROGRAMLARI
- PORTABLE TMPGENC MPEG EDITOR V
- PORTABLE TMPGENC XPRESS V
- PORTABLE TUNE UP UTILITIES
- PORTABLE TUNEUP UTILITIES
- PORTABLE ULEAD GIF ANIMATOR
- PORTABLE USB SAFELY REMOVE
- PORTABLE VISIO PROFESSIONAL
- PORTABLE VISUAL STUDIO PRO
- PORTABLE VLC MEDIA PLAYER
- PORTABLE VOPT
- PORTABLE VSO CONVERTXTODVD (VIRTUALIZED)
- PORTABLE WIN CLEANER
- PORTABLE WINCLEANER ONE CLICK 10 FULL
- PORTABLE WINDOWS LIVE MESSENGER V
- PORTABLE WINDOWS MEDIA PLAYER 11
- PORTABLE WINZIP PROFESSIONAL V
- PORTABLE YAHOO MESSENGER
- PORTABLE YOUTUBE FLV TO AVI SUITE PRO
- POS HTML IMAGE MAPPER V
- POSER
- POSER V FULL DVD
- POST YOU TUBE DOWNLOADER V
- POST-IT DIGITAL NOTES PROFESSIONAL
- POST-IT DIGITAL NOTES PROFESSIONAL V
- POSTER BUDDY
- POTENT PORTABLES LIVE AIO SERIES CD 1
- POTENT PORTABLES LIVE AIO SERIES CD 2
- POWER DVD V 7 20
- POWER SOFT POWER NOTES V
- POWER SPY V
- POWER SPY - CRACKED
- POWER TRANSLATOR 11 PROFESSIONAL MULTILANGUAGE
- POWER TRANSLATOR V11 GLOBAL
- POWERARCHIVER
- POWERARCHIVER V10 00 36 FINAL
- POWERCMD
- POWERCONVERTER
- POWERDVD ULTRA V
- POWERPOINT SLIDE SHOW CONVERTER
- POWERQUEST AIO
- PPT TO FLASH CONVERTER V
- PPT TO VIDEO SCOUT
- PRESENTATION TO VIDEO CONVERTER V
- PRISON TYCOON 3 LOCKDOWN
- PRO SHOW PRODUCER V PORTABLE
- PROCAD 2D DESIGNER
- PROCEVIRI INGILIZCEDEN TURKCEYE CUMLE CEVIRI
- PRODUCT KEY EXPLORER V
- PROFESSIONAL NUMEROLOGIST V
- PROFESSOR TEACHES HOW TO CREATE WEB PAGES
- PROGDVB V
- PROGRAM4PC DJ MUSIC MIXER
- PROPELLERHEAD REASON V (TESTED AND WORKING)
- PROPHET VERSION 2
- PROSHOW GOLD 3 0
- PROTEUS ENGINEERING RHINOMARINE
- PROXY SWITCHER PRO RETAIL V
- PROXY SWITCHER PRO V BUILD
- PROXY SWITCHER STANDARD V BUILD
- PROXY TOOLS AIO
- PROXYCOMMANDER V
- PROXYFIRE V
- PS3 VIDEO CONVERTER 3 1 21
- PSP 3 03 OE A RELEASED
- PSP SOFTWARE
- PSP VIDEO 9 (VIDEO CONVERTER FOR THE PSP)
- PTC MATHCAD V ISO + BONUS
- PUNCH HOME DESIGN ARCHITECTURAL SERIES V10 DVD
- PURE FXZ COMPLETE VISUAL STYLES FOR WINDOWS
- PURE SEO CMS VI
- QUARKXPRESS V VISTA READY
- QUICKTIME
- QUICKTIME
- R-STUDIO
- RADIOSPLITTER V
- RADIOTRACKER PLATINUM EDITION V
- RADIOTRACKER PLATINUM EDITION V
- RADIOTRACKER PLATINUM V
- sprers.euN.V
- RADMIN REMOTE CONTROL
- RADMIN REMOTE ADMINISTRATOR + PATCH
- RADMIN V REMOTE CONTROL
- RAIDENFTPD
- RAIDENMAILD
- RAIDENMAILD VER XP
- RAPGET - EASY DOWNLOAD FROM FREE HOSTS
- RAPGET + SSL LIBRARIES
- RAPGET V
- RAPID CSS
- RAPID CSS V
- RAPID FILE DEFRAGMENTOR BUILD BETA
- RAPID LEECH
- RAPID PHP V
- RAPID TOOLS ! (8 IN ONE)
- RAPID USDOWNLOADER V WITH FULL PLUGINS
- RAPIDFOLDERLINKGRABBER VERSION
- RAPIDHACKER FINAL 2 0
- RAPIDHACKER FINAL BUILD 2
- RAPIDHACKER FINAL BUILD
- RAPIDHACKER FINAL V
- RAPIDHARVEST V - NO PASSWORD
- RAPIDOWN V
- RAPIDSEEK .NET FREE EDITION + RAPGET
- RAPIDSHARE .COM .DE DIRECT LINK HELPER
- RAPIDSHARE PREMIUM PACK
- RAPIDSHARE AUTOMATIC DOWNLOADER
- RAPIDSHARE BLAST
- RAPIDSHARE BYPASS ALL DOWNLOAD LIMITS
- RAPIDSHARE DOWNLOADER PREMIUM MASTER
- RAPIDSH
/-\ /\/\ /-\
Se não achar o que procura aqui

Abraços: Lipe

1 - -OPERA BUILD FINAL--
2 - STRIKE LANSTATE VER
3 - DEVELOPPERS ICONS
4 - 15 ADOBE PHOTOSHOPCS2 ACTIONFX
5 - 18 BEST PASSWORD RECOVER
6 - 18 BEST PASSWORD RECOVER AIO
7 - 1CLICK DVD COPY V
8 - 1CLICK DVD MOVIE 3 0
9 - 1ST javascript EDITOR PRO V
10 - 22 CINEMA 4D PLUG INS
11 - 23 APEX VIDEO CONVERTERS
12 - PHOTOSHOP PLUG-INS
13 - 2D&3D SCREENSAVER MAKER V3
14 - 32 PIECE PORTABLE PROGRAMS
15 - 35 SPB POCKET PC SOFTWARE
16 - 3D ALBUM COMMERCIAL SUITE V
17 - 3D BRUSH
18 - 3D CANVAS 7
19 - 3D DRIVING SCHOOL
20 - 3D GOGO PLUGIN FOR WINAMP
21 - 3D HOME ARCHITECT DESIGN DELUXE 8
22 - 3D HOME ARCHITECT DESIGN SUITE DELUXE V
23 - 3D HUMAN MODELING AND ANIMATION CD AND BOOK
24 - 3D MAX 9 EXTENSION - PRODUCTIVITY BOOSTER 32BIT
25 - 3D MP3 SOUND RECORDER
26 - 3D MP3 SOUND RECORDER G2 4
27 - 3D PRODUCTBOX
28 - 3DCLINIC PROFESSIONAL
29 - 3DS MAX 9
30 - 3GP PLUGIN FOR WINDOWS MEDIA PLAYER
31 - 4MUSICS MULTIFORMAT CONVERTER
32 - 4MUSICS MULTIFORMAT CONVERTER MULTILANGUAGE
33 - 4U MP4 VIDEO CONVERTER V
34 - 5 STAR GAME COPY V
35 - 50 HIGH QUALITY PSD FILE FOR DESIGNERS
36 - OFFICE TEMPLATE
37 - 63 Ð ÑÅ&#;EMA K & W
38 - 7-ZIP (PORTABLE)
39 - 70 VISTA THEME FOR WIN, XP WITH INSTALLER
40 - 8 FLASH COMPONENT FROM FLASLOADED
41 - 86 SIDEBAR GADGETS FOR VISTA
42 - 95 DATALIFE ENGINE SKIN
43 - A-Z VIDEO CONVERTER ULTIMATE VER
44 - AAA LOGO + SERIAL
45 - ABBYY FINEREADER PROFESSIONAL EDITION V
46 - ABBYY PDF TRANSFORMER
47 - ABC AMBER LIT CONVERTER
48 - ABLE2EXTRACT PROFESSIONAL V
49 - ABLE2EXTRACT PROFESSIONAL V
50 - ABLETON LIVE TUTORIAL DVD
51 - ABLETON LIVE V
52 - ABR VIEWER
53 - ABROSOFT FANTAMORPH DELUXE EDITION V3
54 - ABRVIEWER V
55 - ABSOLUTE SOUND RECORDER VER
56 - ABSOLUTE SOUND RECORDER VER
57 - ABSOLUTE TELNET FINAL
58 - ABSOLUTE UNINSTALLER VER
59 - ABSOLUTE VIDEO CONVERTER V2 8 6
60 - ABSOLUTE VIDEO CONVERTER VER
61 - ABYSS MEDIA AUDIORETOUCHER V
62 - AC3 DECODER B
63 - AC3 FILTER B
64 - ACAJOOM PRO
65 - ACALA DVD COPY V2 4 4
66 - sprers.euV
67 - ACCESSORY MEDIA VIEWER V
68 - ACD FOTOSLATE 4 PHOTO PRINT STUDIO
69 - ACDSEE PRO
70 - ACDSEE PORTABLE
71 - ACDSEE PRO PUBLIC BETA
72 - ACDSEE SYSTEMS 9 + CRACK
73 - ACE MEGA CODECS PACK PRO
74 - ACE UTILITIES VER BUILD
75 - ACEBIT WISE-FTP V
76 - ACEHTML PRO
77 - ACKER DVD ALL PRODUCTS
78 - ACKER DVD ALL PRODUCTS
79 - ACME CAD CONVERTER V
80 - ACME WEB DESIGN 11 IN 1 (AIO)
81 - ACOUSTICA CD DVD LABEL MAKER 3 03
82 - ACOUSTICA MIXCRAFT
83 - ACOUSTICA PREMIUM EDITION
84 - ACOUSTICA PREMIUM EDITION V
85 - ACRONIS BOOT CD
86 - ACRONIS PRIVACY EXPERT CORPORATE BUILD
87 - ACRONIS SNAP DEPLOY V
88 - ACRONIS TRUE IMAGE BUILD HOME
89 - ACRONIS TRUE IMAGE BUILD HOME
90 - ACRONIS TRUE IMAGE HOME V
91 - ACRONIS UNIVERSAL RESTORE BOOTCD
92 - ACTION MOVIE ESSENTIALS ISO
93 - ACTIVE DESKTOP CALENDAR
94 - ACTIVE FILE RECOVERY ENTERPRISE V
95 - ACTIVE PASSWORD CHANGER PROFESSIONAL V
96 - ACTIVE SECURITY MONITOR 9
97 - [email protected] BOOT DISK PROFESSIONAL V
98 - ACTIVESTATE PERL DEV KIT V
99 - ACTUAL WINDOW MINIMIZER VER
- AD-AWARE FINAL
- AD-AWARE PRO
- AD-AWARE PROFESSIONAL EDITION V
- AD-AWARE PRO. V FULL
- AD-AWARE PROFESSIONAL V RETAIL
- AD-AWARE SE PROFESSIONAL AIO
- ADAWARE PRO PORTABLE
- ADG 3D TOOLS VER
- ADG PANORAMA TOOLS
- ADMIN PASSWORD HACK PORTABLE
- ADMINEASY
- ADOBE ACROBAT PRO
- ADOBE CAPTIVATE 2
- ADOBE CAPTIVATE V2 0 0 B
- ADOBE CAPTIVATE V
- ADOBE CREATIVE SUITE 3 WEB STANDARD
- ADOBE CREATIVE SUITE PREMIUM EDITION V2
- ADOBE CREATIVE SUITE PREMIUM RETAIL
- ADOBE CS3 MASTER COLLECTION - 4 DISKS
- ADOBE DREAMWEAVER CS3 (PORTABLE)
- ADOBE DREAMWEAVER CS3 VISTA READY
- ADOBE FIREWORKS CS3 (PORTABLE)
- ADOBE FIREWORKS CS3 (V.9)
- ADOBE FLASH CS3
- ADOBE FLASH CS3 (PORTABLE)
- ADOBE FRAMEMAKER VB
- ADOBE ILLUSTRATOR CS3
- ADOBE ILLUSTRATOR CS3 PORTABLE
- ADOBE MACROMEDIA PROGRAMS
- ADOBE ONLOCATION CS3
- ADOBE PAGE MAKER V PORTABLE
- ADOBE PAGEMAKER
- ADOBE PHOTODELUXE HOME EDITION
- ADOBE PHOTOSHOP ALBUM STARTER EDITION
- ADOBE PHOTOSHOP CS 3 VIDEO2BRAIN (DVD/GERMAN)
- ADOBE PHOTOSHOP CS3 ACTIVATOR
- ADOBE PHOTOSHOP CS3 EXTENDED (FULL) CRACK + SERIALS
- ADOBE PHOTOSHOP CS3 EXTENDED ORJINAL TURKCE
- ADOBE PHOTOSHOP CS3 FINAL (PORTABLE)
- ADOBE PHOTOSHOP CS3 PORTABLE EDITION
- ADOBE PHOTOSHOP CS3 WITH LIGHTROOM AIO
- ADOBE PHOTOSHOP ELEMENTS 6
- ADOBE PHOTOSHOP ELEMENTS V
- ADOBE PHOTOSHOP LIGHTROOM
- ADOBE PHOTOSHOP LIGHTROOM V1 0 FINAL CRACK
- ADOBE PHOTOSHOP LIGHTROOM V AIO
- ADOBE PHOTOSHOP LIGHTROOM V FINAL
- ADOBE PHOTOSHOP STYLES VOL 1
- ADOBE PREMIERE PRO
- ADOBE PREMIERE ELEMENTS
- ADOBE SOUNDBOOTH CS3 V
- ADOBE-CS3 MASTER COLLECTION
- sprers.eu3
- ADSENSE DECODED
- ADSENSELOG VER
- ADSL-KOTTA V
- ADVANCED MASS SENDER TOPLU MAIL PROGRAMI
- ADVANCED NET MONITOR FOR CLASSROOM PROFESSIONAL V
- ADVANCED SYSTEM ADMINISTRATION FOR THE SOLARIS 9 OPERATING SYSTEM
- ADVANCED UNINSTALLER PRO
- ADVANCED WINDOWSCARE V PRO
- ADWARE SPYWARE BE GONE
- AERO MAX GLASS BLUE STATUS BARS
- AGOGO VIDEO TO IPOD PSP 3GP XBOX PPC PDA MP4 V
- AGOGO VIDEO TO IPOD PSP CELL PHONE XBOX POCKET PC PDA MP4 V3
- AHA-SOFT ANY TO ICON 3 PORTABLE
- AHEAD NERO LINUX 3 FINAL ( 32 / 64 -BITS )
- AHEAD NERO PREMIUM EDITION V7 7 5 1
- AI ROBOFORM
- AI ROBOFORM PRO V
- AIKIDO 3D
- AIO 12 DIFFERENT RUNESCAPE CHEATING PROGRAMS
- AIO ANTIVIRUS COLLECTION
- AIO CRACK SEARCH 6 IN 1
- AIO DFX AUDIO ENHANCER
- AIO FLASH MIXER FINAL
- AIO FLASHGET
- AIO INTERNET EXPLORER
- AIO MESSENGER LIVE V8
- AIO PORTABLE TWEAKING COLLECTION
- AIO RAPIDSHARE PACK MAY
- AIO RAPIDSHARE PREMIUM PACK V4 43 IN 1
- AIO REGISTRY CLEANERS
- AIO WEBPAGE DESIGN
- AIR CONFLICTS GERMAN
- AIRMAGNET LAPTOP ANALYZER V BUILD
- AKINSOFT CAFEPLUS + FULL+SERIAL
- AKRAM MEDIA CREATOR V
- AKTI BLOG VER
- AKVIS AIO
- AKVIS JULY AIO FOR PHOTOSHOP
- AKVIS PLUG-IN PRODUCTS
- ALBUM COVER FINDER
- ALBUM CREATOR PRO V
- ALBUMWRAP V
- ALCATECH BPM STUDIO PROFESSIONAL
- ALCOHOL % V
- ALCOHOL AUDIO %
- ALCYONESOFT SKIN CLOCK V
- ALIAS MAYA 7 [PERSONAL LEARNING EDITION]
- ALIEN SKIN XENOFEX V2
- ALIENWARE DESKTOP ABDUCTION AIO
- ALIVE INTERNET ERASER
- ALL ADOBE CS3 PROGRAMS MULTILANGUAGE[TURKISH]
- ALL COFFECUP PRODUCTS
- ALL IN ONE CONVERTERS IN-1
- ALL MODEL PACKS 6 AND SOME EXTRAS FPS GAME CREATOR
- ALL MY MOVIES
- ALL MY MOVIES BUILD
- ALL MY MOVIES
- ALL STARDOCK PRODUCTS NEW
- ALL-IN-ONE BACKUP TOOLZ
- ALL-IN-ONE PASSWORD CRAKING
- ALL-IN-ONE WAREZ DOWNLOADER & PATCHER V
- ALL-IN-ONE WAREZ DOWNLOADER & PATCHER V - (IN-1)
- ALLOK 3GP PSP MP4 IPOD VIDEO CONVERTER V2 7 2
- ALLOK AVI TO DVD SVCD VCD CONVERTER V
- ALLOK RM RMVB TO AVI MPEG DVD CONVERTER 1 3 4
- ALLOK VIDEO TO 3GP CONVERTER V2 62
- ALLOK VIDEO TO MP4 CONVERTER V
- ALLWEBMENUS PRO V
- AMERICAN HERITAGE DICTIONARY OF ENGLISH LANGUAGE, 4TH EDITION
- AMOR SWF TO VIDEO CONVERTER
- ANAPOD EXPLORER V RETAIL
- ANGEL SOFTWARE RESIZE PICTURES PLUS V
- ANIM FX V
- ANIMATED GIF PRODUCER V
- ANIMATED POWERPOINT TEMPLATES
- ANIMATION PROGRAMS AIO
- ANIMATION SHOP3 - STANDALONE
- ANIME STUDIO PRO 5
- ANIME STUDIO PRO
- ANONYMOUS WEB SURFING V
- ANTAMEDIA INTERNET CAFFE SERVER + 50 CLIENTS
- ANTI MOSQUITO
- ANTI TRACKS
- ANTI VIRUS PROGRAMS AIO
- ANTI-PR0N V
- ANTI-RAPIDSHARE PROGRAMS
- ANTIPORN
- ANTIVIRUS - NEW - 10IN1 [MUST HAVE] (AIO)
- ANTIVIRUS
- ANVSOFT FLASH TO VIDEO CONVERTER V
- ANY READER FULL() FULL VERSION
- ANYDVD ANYDVD HD V6 1 3
- ANYDVD V
- ANYREADER
- ANYREADER V
- ANYREADER V
- AOA ADVANCED X VIDEO CONVERTER V
- APACHE V
- APEX AVI CONVERTER V
- APEX VIDEO CONVERTER SUPER V5
- APEX VIDEO CONVERTER SUPER V
- APEX WMV ASF CONVERTER V4 77
- APEXDC++ (PR4)
- APOLLO NO1 DVD RIPPER V
- APP HAVEN 2 - 49 IN 1 (AIO)
- APPLE SHAKE FOR WINDOWS (FINAL XP VERSION)
- ARC DVD COPY
- ARCHICAD V
- ARCHICAD V FINAL
- ARCSOFT MAGIC-I VER.
- ARCSOFT PANORAMA MAKER PORTABLE
- ARCSOFT PHOTOSTUDIO
- ARCSOFT SCRAPBOOK CREATOR MEMORIES EDITION VER.
- ARES
- ARIAL CD RIPPER V 1 9
- ARTCURSORS V
- ARTRAGE V
- ARTRAGE V RETAIL
- ASC TIMETABLES V
- ASHAMPOO - PRODUCTS
- ASHAMPOO ANTISPYWARE V
- ASHAMPOO ANTIVIRUS
- ASHAMPOO BURNING STUDIO 7
- ASHAMPOO BURNING STUDIO
- ASHAMPOO CLIP FINDER
- ASHAMPOO CLIPFISHER
- ASHAMPOO CLIPFISHER V
- ASHAMPOO FIREWALL PRO
- ASHAMPOO MAGICAL SNAP 2
- ASHAMPOO MAGICAL SNAP V1 20
- ASHAMPOO MAGICAL SNAP V MULTILINGUAL
- ASHAMPOO MOVIE SHRINK AND BURN V
- ASHAMPOO MUSIC STUDIO 3 PORTABLE
- ASHAMPOO MUSIC STUDIO V3
- ASHAMPOO MUSIC STUDIO V
- ASHAMPOO OFFICE
- ASHAMPOO PHOTO COMMANDER
- ASHAMPOO PHOTO OPTIMIZER
- ASHAMPOO POWERUP XP PLATINUM
- ASHAMPOO UNINSTALLER PLATINUM
- ASHAMPOO UNINSTALLER PLATINUM SUITE
- ASHAMPOO WINOPTIMIZER V
- sprers.euGUAL
- ASP EXPRESS V
- sprers.eu MAKER
- ASPRUNNER PRO
- ASTALAVISTA SECURITY TOOLBOX DVD V
- ASTERISK KEY
- ASTON XMAS EDITION
- ASTRO FLASH CREATOR V
- ATLANTIS WORD PROCESSOR V
- AUDIO EDITOR GOLD 9 2 6
- AUDIO FILE CUTTER V
- AUDIO ZONE TRIGGER V
- AUDIOBURST POWERFX FOR WINAMP
- AUDIOGRAIL K-MP3 V - TURKCE
- AUDIOLABEL CD DVD LABELER V4
- AURORA MEDIA WORKSHOP FULL
- AURORA MEDIA WORKSHOP
- AURORA MPEG TO DVD BURNER V4 9
- AUSLOGICS BOOSTSPEED
- AUSLOGICS BOOSTSPEED
- AUSTRALIA MAPS FOR SMARTST ()
- AUTO PLAY MEDIA STUDIO PORTABLE
- AUTOCAD TURKCE GORSEL EGITIM CD\'SI
- AUTOCAD ELECTRICAL -
- AUTOCAD ELECTRICAL V DVD-ISO
- AUTODESK 3D STUDIO MAX 9 RELEASE DVD
- AUTODESK 3D STUDIO MAX
- AUTODESK 3DS MAX 9
- AUTODESK 3DS MAX 9 SERVICE PACK 2
- AUTODESK 3DSMAX9 EXTENSION1 REV3 ISO
- AUTODESK ALIASSTUDIO STUDIOTOOLS V ISO
- AUTODESK AUTOCAD
- AUTODESK AUTOCAD ARCHITECTURE V
- AUTODESK AUTOCAD ELECTRICAL V
- AUTODESK AUTOCAD MAP 3D
- AUTODESK AUTOCAD MECHANICAL V
- AUTODESK AUTOCAD V 2CD
- AUTODESK CIVIL 3D V
- AUTODESK MAYA COMPLETE (WIN32BIT)
- AUTODESK MAYA SILVER MEMBERSHIP CONTENT DVD
- AUTODESK MAYA UNLIMITED V SP1
- AUTODESK MAYA V
- AUTODESK VIZ
- AUTOPLAY MEDIA STUDIO 6
- AUTOPLAY MEDIA STUDIO 6 0 5 0 MEGA CONTENT PACK
- AUTORUN DESIGN SPECIALTY V7
- AUTORUNS V
- AV BROS PUZZLE PRO V
- AV VOICE CHANGER DIAMOND 4 0 54
- AV VOICE CHANGER DIAMOND RETAIL
- AV VOICE CHANGER DIAMOND V
- AV VOICE CHANGER SOFTWARE DIAMOND EDITION
- AVAST ANTIVIRUS PROFESSIONAL VINCL KEYMAKER
- AVAST! 4 HOME EDITION
- AVATAR EDITOR
- AVG ANTI-MALWARE A
- AVG ANTI-SPYWARE PLUS
- AVG ANTI-SPYWARE V
- AVG ANTI-VIRUS PROFESSIONAL EDITION BUILD
- AVG ANTI-VIRUS PROFESSIONAL EDITION BUILD
- AVG ANTI-VIRUS PROFESSIONAL EDITION BUILD
- AVID SOFTIMAGE XSI ADVANCED V
- AVIRA ANTIVIR SECURITY SUITE (NEW FULL 5 YEAR LICENSE)
- AVIRA ANTIVIR SECURTY SUITE PREMIUM FULL
- AVIRA PREMIUM SECURITY SUITE
- AXIALIS ICONWORKSHOP CORP
- BABYLON PRO
- BABYLON PRO V
- BABYLON PRO V R8
- BACKDROP DESIGNER FOR ADOBE PHOTOSHOP
- BACKUP4ALL PROFESSIONAL
- BAD COPY PRO VER 3 80
- BANDWIDTH CONTROLLER ENTERPRISE
- BANDWIDTH CONTROLLER STANDARD V
- BANDWIDTH MONITOR V
- BAR CODE PRO V
- BATCH FILENAME EDITOR
- BATCH IMAGE RESIZER
- BATCH PHOTO FACTORY VER
- BAYGENIE EBAY AUCTION SNIPER PRO EDITION V
- BEARSHARE PRO 5
- BEARSHARE PRO 5 2 6 0
- BEARSHARE PRO
- BEAUTY WIZARD 3 0
- BELLTECH CAPTUREXT SCREEN CAPTURE V2
- BELLTECH CAPTUREXT SCREEN CAPTURE V
- BEST MEDIA PLAYER AND AUDIO CONVERTER
- BEST OF NETWORK TOOLS AIO
- BETTER JPEG V
- BETTER JPEG V PORTABLE
- BEYOND COMPARE BUILD FULL
- BIENNESOFT YOUTUBE DOWNLOADER
- BIG FILE SENDER ENTERPRISE EDITION V
- BILDSOFT SECUREDNA V
- BINARTS FIBER FACTORY IV V4
- BITCOMET
- BITDEFENDER ANTIVIRUS PLUS V10 -BUILD
- BITDEFENDER INTERNET SECURITY BUILD (32/64 BITS)
- BITDEFENDER TOTAL SECURITY BUILD
- BITDEFENDER TOTAL SECURITY BUILD (32/64 BITS)
- BLACK WIDOW MEDIA DESKTOP V5
- BLACKMAGIC V
- BLAZE DVD COPY V
- BLAZE MEDIA PRO V7
- BLAZE VIDEO MAGIC V
- BLAZEVIDEO HDTV PLAYER V
- BLAZINGTOOLS SECURE OFFICE V RC4
- BLUESOLEIL
- BLUETOOTH HACK TESTED ON N70 AND W8
- BLUETOOTH REMOTE CONTROL
- BLUETOOTH REMOTE CONTROL 3
- BLUETOOTH REMOTE CONTROL V RC1
- BLUMENTALS RAPID CSS V (RETAIL)
- BLUMENTALS RAPID CSS VRETAIL
- BLUMENTALS RAPID PHP VRETAIL
- BLUMENTALS RAPID PHP (RETAIL)
- BLUMENTALS WEBUILDER
- BODYTRANS V
- BOOK COLLECTOR PRO
- BOOK WRITER V
- BOOTABLE USB UNIT + MANY APPZ AIO
- BORLAND DELPHI WIN32
- BORLAND DEVELOPER STUDIO V ARCHITECT DVD ISO
- BPM STUDIO PROFESSIONAL
- BPS SPYWARE ADWARE REMOVER FINAL
- BREME WRITE RIGHT 2 5 5 3
- BRICOPACK VISTA INSPIRAT ULTIMATE 2
- BROADGUN PDFMACHINE ULTIMATE
- BS PLAYER PRO 2 14
- BS PLAYER PRO V MULTILANGUE VISTA
- BSPLAYER PRO V
- BT ENGINE (TO SPEED THE TORRNET)
- BUDDY ICON GRABBER
- BUSINESS PLAN PRO PREMIER EDITION V
- CA ETRUST INTERNET SECURITY +CRACK
- CA INTENET SECURITY RETAIL
- CAFEMANILA V
- CAFESUITE V
- CAKEWALK GUITAR TRACKS PRO 3
- CALENDAR PAD V
- CALORIEKING NUTRITION AND EXERCISE MANAGER V
- CAMEL AUDIO CAMEL PHAT VST V
- CAMEL AUDIO CAMEL SPACE VST V
- CAMFROG VIDEO CHAT
- CAMFROG VIDEO CHAT V BUILD
- CAMFROG VIDEO CHAT VER BUILD
- CAMTASIA STUDIO 3 PORTABLE
- CANOPUS EDIUS PRO V
- CANOPUS IMAGINATE V
- CANOPUS MPEGCRAFT 3 DVD V FULL (ORIGINAL PACKAGE)
- CANOPUS PROCODER
- CANOPUS PROCODER + QUICKTIME PRO AIO
- CANOPUS PROCODER
- CAPTURE WIZARD PRO V3.A0 + KEYGEN
- CARICATURE PHOTO TO CARTOON
- CARICATURE PHOTOS V3
- CARICATURE STUDIO V
- CARTOON MAKER
- CARTOON MAKER
- CARTOON SMART FLASH AND MYSQL PACKAGE DVD ISO
- CASPER (JULY )
- CD DVD IMAGES FILES TOOLS 5IN1 FULL (AIO)
- CD - DVD IMAGES FILES - TOOLS 5IN1 - FULL (AIO)
- CD CATALOG EXPERT V9 1 7
- CD CATALOG EXPERT V FULL
- CD-LOCK V
- CDCHECK V - FINAL (07/04/)
- CDDVD LABEL MAKER VER
- CDMENU PRO V + FULL
- CDROLLER 7 - VIRTUALIZED
- CDROLLER
- CEBAS PSD-MANAGER V UPDATED (32BIT/64BIT)
- CELL ILLUSTRATOR PRO V
- CFOSSPEED V
- CFOSSPEED VERSIYON X86
- CHARACTER STUDIO 4 FULL (INCLUDE 4CD)
- CHARACTER STUDIO MOTION CAPTURE COLLECTION
- CHATTERBLOCKER VER.
- CHICKEN SYSTEMS TRANSLATOR V2
- CHILD CONTROL VER
- CHILDREN CONTROL V 1 7
- CHILDREN\'S COLOURING BOOK MANY CARTOON AND FILM CHARACTERS
- CHINESE SYMBOL STUDIO V BUILD
- CHIPMUNK AV CONTROLLER V
- CIMATRONE V
- CINDERELLA
- CINEMA 4D STUDIO BUNDLE
- CINEMA 4D STUDIO BUNDLE FULL
- CINEMA CRAFT ENCODER SP2 1
- CINEMA CRAFT ENCODER SP2 (REGULAR+PORTABLE)
- CLASSIC MENU FOR OFFICE
- CLEAN DISK SECURITY
- CLEAN MEMXP V
- CLEAR WATER VISTA STYLE
- CLICKBANK ELITE
- CLICKSENSOR V2
- CLOCK TRAY SKINS V + CRACK
- CLONECD
- CLONEDVD V FINAL
- CLONEDVD V
- CLUBDJ PRO
- CODEWALLET PRO V
- COFFEECUP FIRESTARTER V RETAIL
- COFFEECUP FLASH FIRESTARTER V
- COLECTION 9 THEMS
- COLOR SCHEMER STUDIO
- COLOR7 DVD RIP FACTORY PRO
- COLOR7 IPOD PSP 3GP VIDEO CONVERTER
- COLOR7 IPOD PSP 3GP VIDEO CONVERTER V
- COLOR7 VIDEO STUDIO V
- COLORIMPACT BUILD
- COMFORT KEYS V
- COMODO FIREWALL PRO TURKCE
- COMPLETE HOME 3D DESIGN
- COMPLEX EVOLUTION
- COMPLEX EVOLUTION (BUILD )
- CONAITO POWERPOINT TO FLASH CONVERTER
- CONTEXTCONVERT PRO V
- COOL 3D WALLPAPERS
- COOL EASYCARD VALENTINES V
- COOL EDIT PRO VER 2 1
- COOL RECORD EDIT PRO V + CRACK
- COOL TYPE MASTER V1 6
- COOLCOLOR TEXT GENERATOR
- COOLCOLOR TEXT GENERATOR V
- COPY DVD GOLD VER 2 20
- COPY PROTECTION - 4IN1 (AIO)
- COPYPOD SUITE
- COREL GRAPHICS SUITE 11 PORTABLE
- COREL PAINT SHOP PRO PHOTO XI VER
- COREL PAINT SHOP PRO THE XI
- COREL PAINT SHOP PRO X PORTABLE
- COREL PAINT SHOP PRO X V PORTABLE
- COREL PAINTER ESSENTIALS
- COREL PAINTSHOP PRO PHOTO X2 WITH EXTRAS
- COREL SNAPFIRE PLUS V MULTILINGUAL
- CORELDRAW ESSENTIAL EDITION 3 V MULTILANGUAGE
- CORELDRAW_X3_GRAPHICS_SUITE
- CORPORATE IDENTITY CREATOR sprers.eu CREATOR V5 sprers.eu
- COUNTERSPY 2
- CPAC IMAGING
- CRACKDOWNLOADER
- CRAZY MACHINES - INVENTORS WORKSHOP
- CRAZY TALK VER 4 5
- CREAMAIL TOPLU E-POSTA GONDERIM PROGRAMI
- CREATIVE PAINTER V
- CREATURE CREATOR V
- CRYPTLOAD (RAPIDSHARE & MEGAUPLOAD DOWNLOADER)
- CRYSTAL PLAYER PROFESSIONAL V
- CRYSTAL REPORTS XI RELEASE 2 DEVELOPER EDITION
- CRYSTALGRAPHICS POWERPLUGS VIDEO BACKGROUNDS RELEASE
- CSS TAB DESIGNER
- CUCUSOFT SUITE VERSIYON
- CUE SPLITTER B
- CUSTOM FIRMWARE 3 10 OE-A
- CUTE FTP PROFESSIONAL
- CUTEFTP 8 0 4 BUILD 01 18 1 PROFESSIONAL EDITION
- CUTEFTP BUILD PROFESSIONAL EDITION
- CUTEFTP PROFESSIONAL EDITION [BUILD ]
- CUTEFTP PRO 8
- CUTEPAGE COOLBUTTON VER
- CYBER CAFE PRO V
- CYBERLINK DVD SUITE V PRO VISTA MULTILANGUAGE
- CYBERLINK MAKEDVD 2
- CYBERLINK MEDIA DELUXE V PRO MULTILANGUAGE ISO
- CYBERLINK MEDIASHOW
- CYBERLINK POWER2GO DELUXE
- CYBERLINK POWERBACKUP
- CYBERLINK POWERCINEMA V5
- CYBERLINK POWERDVD COPY
- CYBERLINK POWERVCR II
- CYBERLINK SOFTWARE 5 IN 1 DVD
- CYBERLINK STREAMAUTHOR
- CYBERSITTER
- CYBERSPACEHQ ADDWEB 8 DELUXE PLATINUM VER
- CYD GIF STUDIO PRO
- DAEMON TOOLS X86 LITE
- DAEMON TOOLS PRO V
- DAMEWARE NT UTILITIES
- DAMEWARE NT UTILITIES V
- DAMN SMALL LINUX
- DANCE EJAY 7
- DANCE EJAY 7 [2CD ISO]
- DAP V BUILD PREMIUM
- DATA RESTORE VER.
- DATABASE DESIGNER FOR MYSQL V
- DATABASE TOUR PRO V
- DATALIFE ENGINE VER. FINAL RELEASE
- DAYSMART VER
- DAZ - BRYCE VER. ISO
- DAZZLEE\'S XP ZONE EXTENDER EDITION
- DBPOWERAMP MUSIC CONVERTER V12
- DEEPFREEZE STANDARD V6
- DEEPFREEZE STANDARD V
- DELCAM ARTCAM
- DELORME STREET ATLAS USA PLUS - 2DVD
- DELPHI UPDATE 1
- DELPHI 7 PERSONAL 2CD ISO
- DELUXERAY COVER EXPERT V BUILD
- DENTIMAX
- DESKLOOPS
- DESKSHARE VIDEO EDIT MAGIC V
- DESKTOP AUTHOR V
- DESKTOP FLASH INTRO BUILDER V
- DESKTOP GRAFFITIST
- DESKTOPX + 3 THEMES
- DESKWARE PLAINSIGHT DESKTOP CALENDAR V
- DEVEXPRESS EXPRESSBARS SUITE VER. FOR DELPHI
- DFI BIOS FLASH AND UTILITIES [BOOTABLE CD] (AIO)
- DFX AUDIO ENHANCER
- DG FOTO ART VFAST & EASY DIGITAL ALBUM + THEME
- DIAGNOSISPRO 5 0
- DIARYONE 6
- DIARYONE 6 KISISEL GUNLUK
- DIGITAL AUDIO EDITOR 7 8 5 BUILD
- DIGITAL FILM TOOLS EZ MASK V1 01 FOR ADOBE PHOTOSHOP
- DIGITAL FILM TOOLS 55MM V7
- DIGITAL FILM TOOLS SNAP V2 0 FOR ADOBE PHOTOSHOP
- DIGITAL IMAGE PLUGINS FOR PHOTOSHOP AIO PACK
- DIGITAL MEDIARESCUE PRO V
- DIGITAL MEDIARESCUE PRO V
- DIRECTORY OPUS V (TESTED ON XP AND WORKING)
- DIRECTX 9 0C REDISTRIBUTABLE FEBRUARY
- DIRECTX END-USER RUNTIME JANUARY
- DISK DRIVE UTILITIES
- DISK PASSWORD PROTECTION V
- DISK SENTINEL
- DISKEEPER PRO PREMIER V
- DISKEEPER PRO 10
- DISKEEPER PRO PREMIER + sprers.eu & sprers.eu FIX
- DISKSHOP
- DISNEY DESKTOP SKIN SUITE
- DISNEY MAGIC ARTIST FEATURING ULEAD DVD PICTURESHOW
- DISNEY\'S CINDERELLAS DOLLSHOUSE
- DIVX CREATE BUNDLE V
- DIVX CREATE BUNDLE VER.
- DIVX PRO 6 BUNDLE
- DIVX SUBTITLE DISPLAYER
- DJ EJAY MIXSTATION 3
- DJ EJAY MIXSTATION 3
- DJ MUSIC MIXER V
- DOMAIN NAME FINDER V
- DONT PANIC
- DOREME MUSIC V
- DOSYA BOLUCU
- DOWNLOAD ACCELERATOR PLUS V BUILD
- DOWNLOAD ACCELERATOR PLUS V BUILD PREMIUM + CRACK
- DR. HARDWARE PREMIUM EDITION VE
- sprers.eu ANTI-VIRUS WITH ANTISPAM
- DRAGON NATURALLY SPEAKING 9
- DRAGON NATURALLYSPEAKING 9 PREFERRED SPEECH RECOGNITION
- DREAMSUITE SERIES
- DREAMWEAVER PRO:PORTABLE
- DREAMWEAVER CS3 FULL FINAL + TURKCE YAMA
- DREAMWEAVER JOOMLA EXTENSION
- sprers.eu
- DRIVER sprers.eu
- DRIVER GENIUS PRO 6
- DRIVER GENIUS PRO
- DRIVER GENIUS PROFESSIONAL EDITION
- DRIVER GENIUS PROFESSIONAL EDITION V
- DRIVER GENIUS PROFESSIONAL EDITION V
- DRIVERMAX - BACKUP DRIVER
- DRIVING TEST SUCCESS PRACTICAL ISO
- DROPWATERMARK
- DROPWATERMARK V3 7
- DSL SPEED
- DSL SPEED V
- DUPLICATE FILE REMOVER [VISTA READY]
- DVD UTILITIES PLUS
- DVD ALBUM CREATOR
- DVD IDENTIFIER V
- DVD MENU DESIGNER
- DVD RIP FACTORY PRO V
- DVD TO POCKET PC 4
- DVD X PLAYER PRO
- DVD X STUDIOS CLONEDVD 4 0 12
- DVD X STUDIOS CLONEDVD V
- DVD X STUDIOS SUPER POWERPACK BY VIRUS/7
- DVD-CLONER IV BUILD
- DVDATE
- DVDFAB PLATINUM 3 0 8 0
- DVDFAB PLATINUM BETA
- DVDFAB PLATINUM V3 0 9 0 BETA
- DVDGHOST VER 2 5
- DVDGHOST VER
- DVDINFO PRO V
- DVDXSOFT ZUNE VIDEO CONVERTER V
- E-SOFT DJ STUDIO PRO V
- E-SPEAKING V3
- E-SPEAKING V
- EARMASTER PRO VS
- EASE VIDEO WATERMARKER V
- EASY DVD CD BURNER VER
- EASY SPYREMOVER V
- EASY WEB BUTTONS V
- EASY-HIDE-IP V
- EASYSNAP PRO V
- EASYTOOLS BATCH WATERMARK CREATOR V
- EASYWEBSAVE V
- EASYWIFI RADAR
- EFFECTIVE ENGLISH V
- EFFECTIVE JOURNAL VER
- EFFECTIVE PLANNER V
- EFFECTIVE SLIDESHOW V
- EGIRL
- EGIRL V
- EJAY TECHNO 4
- ELECARD MPEG PLAYER
- ELECARD XMUXER PRO V
- ELITE RHVAC V WITH MANUAL D
- ELTIMA SOFTWARE USB TO ETHERNET CONNECTOR V
- ELTIMA SWF VIDEO CONVERTER V
- EMEDITOR PROFESSIONAL
- EMEDITOR PROFESSIONAL + KEYGEN
- EMEDITOR PROFESSIONAL V
- EMERGENCY BOOT CD PLUS PE FINAL
- EMERGENCY BOOT CD-DVD ROM V FINAL RELEASE
- EMS ALL
- EMS DATA IMPORT FOR DB2 V
- EMS DATA IMPORT FOR INTERBASE FIREBIRD V
- EMS SQL MANAGER FOR SQL SERVER V
- EMS SQL MANAGER FOR MYSQL V
- EMULEPLUS A
- EMURASOFT EMFTP PROFESSIONAL V2
- ENCRYPT HTML PRO
- ENCYCLOPAEDIA BRITANNICA ULTIMATE REFERENCE SUITE DVD
- ENCYCLOPAEDIA BRITANNICA ULTIMATE
- ENCYCLOPEDIA BRITANNICA ULTIMATE REFERENCE SUITE
- ENGINSITE CSS EDITOR V
- EOVIA CARRARA PRO VE MANUAL
- ERGONOMICS SOFTWARE PACK 4IN1 (AIO)
- ERROR DOCTOR
- ERROR REPAIR PRO
- ESET NOD32 ANTIVIRUS WITH CRACK/FIX V
- ESET SMART SECURITY BETA 2 V. ES
- ESET SMART SECURITY SUITE V
- ESRI ARCGIS
- ESRI ARCGIS + SERVICE PACKS 2 + EXTENSIONS
- EUSOFTWARE WIZARDBRUSH V
- EVEREST CORPORATE EDITION V
- EVEREST ULTIMATE EDITION
- EVEREST ULTIMATE EDITION V
- EVIL MSN
- EXAMXML
- EXIMIOUSSOFT GIF CREATOR
- EXTENSIS MASK PRO , PLUG-IN MASKING SOFTWARE
- EYEON FUSION V
- EYES HAVE IT - SYSTEM TOOLS - 14IN1
- EZGENERATOR WEBSTIE BUILDER V
- F-PROT ANTIVIRUS FOR WINDOWS
- F-PROT ANTIVIRUS V CORPORATE EDITION
- F-SECURE CLIENT SECURITY BUILD + KEYGEN
- F-SECURE CLIENT SECURITY BUILD FOR WINDOWS
- F-SECURE INTERNET SECURITY
- F-SECURE INTERNET SECURITY V BUILD
- FACE FILTER STUDIO V
- FACE ON BODY PRO
- FACEFILTER STUDIO EDITION (RUS)
- FACES MULTILANGUES
- FAMILY CYBER alert V
- FAMILY CYBER alert VER. dvdate3.3.4 error 8

Thematic video

Como Resolver o ERRO X3DAUDIO1_sprers.eu

0 Comments

Leave a Comment