Example of the IDEF4: An Behavior Diagram for methods Implementing Louder.

IDEF4, or Integrated DEFinition for Object-Oriented Design, is an object-oriented design modeling language for the design of component-based client/server systems. It has been designed to support smooth transition from the application domain and requirements analysis models to the design and to actual source code generation. It specifies design objects with sufficient detail to enable source code generation.[1]

This method is part of the IDEF family of modeling languages in the field of systems and software engineering.


IDEF4 method is a graphically oriented methodology for the design of object-oriented software systems. The object-oriented programming paradigm provides the developer with an abstract view of his program as composed of a set of state maintaining objects which define the behavior of the program by the protocol of their interactions. An object consists of a set of local state defining attributes and a set of methods (procedures) that define the behavior of that particular object and its relationship to the other objects that make up the system.[2]

The IDEF4 method multi-dimensional approach to object-oriented software system design consists of the following items:[1]


The development of IDEF4 came from the recognition that the modularity, maintainability and code reusability that results from the object-oriented programming paradigm can be realized in traditional data processing applications. The proven ability of the object-oriented programming paradigm to support data level integration in large complex distributed systems is also a major factor in the widespread interest in this technology from the traditional data processing community.[2]

IDEF4 was developed as a design tool for software designers who use object-oriented languages such as the Common Lisp Object System, Flavors, Smalltalk, Objective-C, C++ and others. Since effective usage of the object-oriented paradigm requires a different thought process than used with conventional procedural or database languages, standard methodologies such as structure charts, data flow diagrams, and traditional data design models (hierarchical, relational, and network) are not sufficient. IDEF4 seeks to provide the necessary facilities to support the object-oriented design decision making process.[2]

IDEF4 concepts

Dimensions of IDEF4 Design Objects

Dimensions of IDEF4 Design Objects.

IDEF4 uses an object-oriented design method or procedure that is very similar to Rumbaugh’s Object Method Technique[3] and Schlaer/Mellor’s Object-Oriented Analysis and Design (OOA/OOD) technique.[4] However, there are some crucial differences:

These extra dimensions are shown in the figure. The edges of the box show the progression of the design from start to finish elaborating each of these dimensions.

IDEF4 Design Activities

In IDEF4, a design starts with the analysis of requirements and takes as input the domain objects. These domain objects are encoded in their equivalent IDEF4 form and marked as domain objects. As computational objects are developed for these objects, they are marked as “transitional” and finally as “completed.” The level of completion of an IDEF4 design is determined by setting measures based on the status, level, and model dimensions of individual artifacts in the design.[1]

IDEF4 Design Activities.

The system-level design starts once the “raw material” (domain) objects have been collected. This develops the design context, ensures connectivity to legacy systems, and identifies the applications that must be built to satisfy the requirements. Static, dynamic, behavioral, and rationale models are built for the objects at the system level. These specifications become the requirements on the application level – the next level of design. The application level design identifies and specifies all of the software components (partitions) needed in the design. Static models, dynamic models, behavioral models, and the rationale component are built for the objects at the application level. These specifications become the requirements on the next level of design – the low-level design. Static Models, Dynamic Models, Behavioral Models, and the design rationale component are built for the low-level design objects. Sub-layers may be built within each layer to reduce complexity.[1]

IDEF4 is an iterative procedure involving partitioning, classification/specification, assembly, simulation, and re-partitioning activities, see figure. First the design is partitioned into objects, each of which is either classified against existing objects or for which an external specification is developed. The external specification enables the internal specification of the object to be delegated and performed concurrently. After classification/specification, the interfaces between the objects are specified in the assembly activity (i.e., static, dynamic, and behavioral models detailing different aspects of the interaction between objects are developed). While the models are developed, it is important to simulate use scenarios or cases [5] between objects to uncover design flaws. Based on these flaws the designer can then rearrange the existing models and simulate them until the designer is satisfied.[1]

IDEF4 Object-oriented Concepts

IDEF4’s defines a set of object oriented concepts:[1]

Object Class Identification

The five types of Object classes in IDEF4.

The IDEF4 Method assumes that the domain objects have been identified through Object-Oriented Domain Analysis. Methods such as IDEF1, IDEF5, IDEF3, SA/SD can be used to perform domain analysis.[6] However, IDEF4 practitioners should be aware of how objects are identified, as the design process may reveal deficiencies in the Object-Oriented Analysis. IDEF4 had defined five types of classes:[1]

IDEF4 Building blocks

Organization of the IDEF4 Building blocks.

IDEF4 Layers

IDEF4 users design in three distinct layers:[1]

  1. system design,
  2. application design, and
  3. low-level design.

This three layered organization reduces the complexity of the design. The system design layer ensures connectivity to other systems in the design context. The application layer depicts the interfaces between the components of the system being designed. These components include commercial applications, previously designed and implemented applications, and applications to be designed. The low-level design layer represents the foundation objects of the system.

IDEF4 Artifact Status

IDEF4 distinguishes between IDEF4 artifacts newly created from the application domain, artifacts in transition to design specification, and artifacts that have been specified that can be applied to create the design specification. Any design artifact in IDEF4 can be marked as domain, transition, or complete. This allows practitioners and reviewers to track the progress of the design toward completion.[1]

IDEF4 Design Models

Organization of the IDEF4 model.

IDEF4 uses three design models and a design rationale component:[1]

The design rationale component provides a top-down representation of the system, giving a broad view that encompasses the three design models and documents the rationale for major design evolutions.

Each model represents a different cross section of the design. The three design models capture all the information represented in a design project, and the design rationale documents the reasoning behind the design. Each model is supported by a graphical syntax that highlights the design decisions that must be made and their impact on other perspectives of the design. To facilitate use, the graphical syntax is identical among the three models.[1]

Design Features

IDEF4 provides a broad range of design features – from generic to specific. This range enables deferred decision making by allowing the designer to first capture design features in general terms and later to refine them. This significantly reduces the burden on designers by allowing them to immediately capture new design concepts with IDEF4 design features, even if these design concepts have not yet been explored in detail.[1]


  1. 1 2 3 4 5 6 7 8 9 10 11 12 Richard J. Mayer et al. (1995). IDEF4 Object-Oriented Design Method Report Version 2.0. Jan 1995.
  2. 1 2 3 Patricia Griffith Friel and Thomas M. Blinn (1989). "Automated IDEF3 and IDEF4 Systems Design Specification Document". Technical report. NASA Johnson Space Center.
  3. James Rumbaugh (1991). Object-Oriented Modeling and Design. Englewood Cliffs, NJ: Prentice Hall.
  4. Sally Shlaer and Stephen J. Mellor (1988) Object-Oriented Systems Analysis: Modeling The Real World in Data. Englewood Cliffs, NJ: Prentice Hall.
  5. Ivar Jacobson (1994). Object-Oriented Software Engineering: A Use Case Driven Approach. Reading, MA: Addison-Wesley.
  6. Edward Yourdon, and Larry Constantine (1979). Structured design: Fundamentals of a discipline of computer program and systems design. Englewood Cliffs, NJ: Prentice-Hall.

Further reading

Wikimedia Commons has media related to IDEF4.
This article is issued from Wikipedia - version of the 2/7/2013. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.