Designing Customizable Methodologies
Have you ever chosen a development process, customized it to fit your organization, culture, and problem domain and then later faced a number of problems to which your method did not fit? Instead of specifying a firm development method, it might help to describe a process framework and customize it to fit each specific development problem. I describe a framework for specification of development processes that considers management and software development artifacts as objects, and evolution as collaborations between them. Such an OO process definition can manage the complexity of a development process in a better way than a description based on workflow. I discuss process-framework features with an eye toward approaches such as Fusion, Rational Unified Process, Catalysis, and Extreme Programming.
I describe a framework for specification of development processes that allows a development process to be represented at a level of accuracy that is necessary, and to be customized to fit specific development problems. The framework is an OO specification of a development process. An OO framework can manage the complexity of a development process in a better way than the traditional specification based on activities, tasks, and deliverables.
This article is structured as follows: The first section explains the need for a design method that is detailed, precise, and can be customized to fit different types of problems without losing accuracy. The second section explains the traditional specification of software processes and its drawbacks. The next four sections explain the main ideas of an OO process specification. The structure of an OO framework is outlined in The Complete Methodological Framework section.
Managing complexity is a major issue in the specification of software development processes. Currently, over 50 OO methodologies have been published1 that emphasize various aspects of software design issues and describe software development processes from various perspectives. The astonishing number of different approaches illustrates a common problem of the traditional process specification: The process specification can be broadly applicable, providing that it is quite abstract and contains only general mechanisms. If the specification contains a large number of details, the process specification is too rigid, and is applicable only to a restricted set of situations.
A process specification must contain a sufficient level of detail to be useful. To be applicable in more than one concrete situation, it has to be customized for various organizational cultures. The common characteristic of methods such as the Rational Unified Process and Fusion is that the customization process takes place before the method is adopted and used. During the customization, a certain subset of the best practices is identified and adopted for use within the organization. This approach of applying the customization process once generally cannot solve the problem. It does not make the process more versatile.
I describe a process specification framework that contains exactly the number of details that are useful and that can be customized on demand to fit every problem being solved. Moreover, it is possible to save every customization for future use so that the organization can maintain a repository of its best practices.
TRADITIONAL SPECIFICATION OF SOFTWARE DEVELOPMENT PROCESSES
The traditional specification of a development process is typically illustrated with a graph of software development and management artifacts. Software development artifacts are intermediate or final products resulting from software development that describe a software product, e.g., a use-case model, a class model, or source code. Management artifacts are products such as tasks, activities, and project plans. Tasks are small behavioral units that usually result in a software development artifact. Examples of tasks are construction of a use-case model, construction of a class model, and writing of code. Activities (as described here) are units that are larger than task units. Activities typically include several tasks and software development artifacts. Examples of activities are requirement analysis, logical design, and implementation.
In general, the traditional specification of a development process cannot cover all the possible combinations of tasks, activities, and software development artifacts without becoming overly complex. I show that in the specification of development processes, an OO approach deals with the complexity of a development process better than the traditional approach illustrated in Figure 1. This is similar to software development experience, where an OO approach can deal with the complexity of large software solutions better than the traditional structured approach.
Figure 1. Traditional specification of a development process. It can be compared with the OO specification illustrated in Figures 10 and 12 (according to "The Object Model..."2).
BASIC FEATURES OF THE METHODOLOGICAL FRAMEWORK
Software development and management artifacts produced during a software development process are considered objects with various methods and attributes. Evolution during software development is represented as collaborations between software development artifacts, management artifacts, and participants in the development process, such as developers and customers.
An OO specification of a development process distinguishes between the artifact type and the artifact instance. Types of artifacts specify properties, attributes, and methods of various types of software development and management artifacts. Instances of artifacts are concrete software development and management products produced during software development. An example of a software development artifact type is a use-case model. An example of a software development artifact instance is a concrete set of use cases, actors, and their relationships represented by a use-case diagram.
Artifact types have two types of methods:
- constructors, which are methods describing how to create an artifact, and
- quality-assurance methods, such as completeness and consistency checks.
Artifacts have instance-specific attributes, such as name, version, and representation, which typically contain a diagram, a table, or a text; status, such as draft, completed, and tested; references to other software development and management artifacts; and attributes, such as who created and modified the artifact, and when. In addition, artifact types have type-specific attributes: the purpose, the recommended representation, and the owner of the artifact type. Artifacts may have other additional attributes and methods than those previously mentioned. Figure 2 illustrates the OO specification of a software development artifact type with attributes and methods.
Figure 2. Specification of the artifact type object interactions.
Consistency check, process phase, or technique, for example, are not called software development or management artifacts here because they do not specify software or management products. Consistency checks are quality-assurance methods of software development artifacts. Process phases are determined by states of software development artifacts. Techniques are constructor methods of software development artifacts.
An OO specification of a software development process distinguishes between artifacts (information) and their representations (realizations).
- The software development artifact determines information about a software product. Examples of software development artifacts are use cases, software architecture, object collaborations, and class descriptions. The management artifact determines information about a management product, such as a task, project, and a team.
- The representation determines how the artifact is presented. For example, a use-case diagram represents a use-case model. A statechart diagram, an activity diagram, or a state transition table can represent a state model. A set of sequence diagrams or a set of collaboration diagrams can represent the object interactions artifact. Various design methods typically recommend a suitable representation of each software development artifact. However, the choice often depends on the concrete situation, and it is sometimes advisable to leave the final decision about the representation to a user of the method.
A typical representation of software development and management artifacts is illustrated in Figure 3.
Figure 3. A typical representation of software development and management artifacts.
STATIC PART OF THE METHODOLOGICAL FRAMEWORK
This section specifies the static relationships between software development and management artifacts. The static structure is based on the pattern for structuring project repositories with UML design artifacts.3 This section outlines how the pattern is applied to create a customizable static structure of a project repository.
A software system can be described at various levels of granularity and from various viewpoints. Examples of levels of granularity are the system level, the subsystem level, and the class level. Examples of views are the logical view, the use-case view, and the analysis, test, and pattern views. I use the term "views" to mean complete "slices" through a model of a software system across different levels of granularity from various viewpoints. This meaning is different from the term view, as used in The Rational Unified Process,4 where it means an incomplete set of significant elements.
At each level of granularity and from each view, four management and development artifact types can describe the software and management product: static relationships between classifiers, dynamic interactions between classifiers, classifier responsibilities, and classifier life cycles. In UML, classifiers are class, object, interface, datatype, use case, subsystem, component, and node. Management artifacts, such as team and project, are mapped to UML as stereotyped classes. This pattern is illustrated in Figure 4.
Figure 4. At each level of granularity and in each view, the software product can be described by four types of design artifacts (according to "Structuring Software..."3).
The artifact called classifier relationships specifies static relationships between classifiers. Examples are the class model, use-case model, and database schema. The artifact called classifier interactions specifies dynamic interactions between classifiers. Examples are any information represented by a UML sequence diagram or collaboration diagram. The classifier specifies classifier responsibilities, attributes, and static properties of classifier interfaces, e.g., a list of classifier operations with preconditions and postconditions. Examples are the CRC card and the vision of the system. The classifier life cycle specifies classifier state machine and dynamic properties of classifier interfaces, e.g., the allowable order operations and events. Examples are any information represented by a UML statechart and activity diagram.
Figure 5 specifies the static structure of software development artifact types at three levels of granularity, and in the logical and use-case views. The logical view describes the logical structure of the product in terms of subsystems and classes, and their responsibilities, relationships, and interactions. The use-case view identifies types of use cases with actors of the system, subsystems, classes, components, and nodes. The system level of granularity describes the context of the software system. The system level specifies responsibilities of the system being designed and responsibilities of the other systems that collaborate with it, as well as static relationships and dynamic interactions between the system being designed and the collaborating systems. The subsystem level of granularity describes subsystems, their static relationships, and dynamic interactions. The class level of granularity describes the detailed design of the subsystems in terms of classes and objects and their relationships and interactions.
Figure 5. Static structure of software development artifact types at the system, component, and class levels of granularity, and in the logical and use-case views.
Each software development artifact type specifies certain information about the software product. Semantics of the development artifacts are outlined, in "Structuring Software ..."3
Figure 6 illustrates the application of the pattern for structuring management artifacts. The pattern can be used to structure two types of management products: teams and projects. Management artifacts can be shown as stereotyped classes in UML, such as >, >, >, and >. The artifacts team relationships and role relationships specify the organizational structure at two levels of granularity. The artifact team specifies the responsibility of the team, and the artifact role specifies the role of the team member. Examples of roles are developer, program manager, product manager, user education, and logistics. The artifacts team interactions and role interactions specify scenarios, which are responses to various events. The artifacts project and task specify static properties of projects and tasks. The artifacts project relationships and task relationships specify static relationships between projects and tasks. These artifacts can be represented by a PERT chart. The PERT chart shows the task dependencies, which are the most important static relationships between tasks. The artifact task interactions specifies a project scenario in terms of starting and finishing tasks. Accordingly, the artifact project interactions specifies the project scenario in terms of starting and finishing projects. These artifacts are typically represented by Gantt charts but they might also be represented by UML sequence diagrams.
Figure 6. Static structure of management artifact types in the team and project views.
DYNAMIC PART OF THE METHODOLOGICAL FRAMEWORK
In the described methodological framework, evolution is seen as interactions between software development and management artifacts and interactions between these artifacts and members of a development team. Software development artifacts can be created and completed in various orders depending on the features of various methods. As illustrative examples, this section describes the Fusion method, the requirements, analysis, and design workflows of the Rational Unified Process, and the light process known as Extreme Programming.
The Fusion Method process
The OO specification of the Fusion method development process5 is illustrated in Figure 7. Figure 7 illustrates the Fusion development scenario in terms of interactions between software development artifacts, and between software development artifacts and the developer.
Figure 7. The design process of the Fusion method (according to "Framework..."6).
The Fusion method5 contains more details than the Rational Unified Process 5.0.4 For the sake of comparison with the Rational Unified Process (and to keep Figures 7 and 8 at the same level of detail), Figure 7 shows only high-level interactions of the Fusion method. Note that this figure is meant as an illustration of the idea of using the dynamic part of the methodological framework, not as a detailed description of the entire Fusion method.
The Rational Unified Process
An OO specification of the Rational Unified Process4,7 is illustrated in Figure 8. Figure 8 illustrates the scenario of the requirements, analysis, and design workflows of the Rational Unified Process. Figure 8 shows the evolution of the software as a number of interactions between the worker (such as the system analyst, the use-case specifier, the architect, and the designer) and the software development artifacts of the Rational Unified Process.
Figure 8. The process of the requirements analysis and the design phase of the Rational Unified Process (according to "Framework..."6).
A worker who uses the Rational Unified Process is responsible for calling the constructors of the software development artifacts in the order illustrated in Figure 8. Constructors and quality-assurance methods generate various messages between the objects.
The Extreme Programming Process
An instance of the Extreme Programming process is illustrated in Figure 9. Extreme programming17 recognizes two major roles in a development team: customers and developers. Customers create and prioritize user stories, and, together with developers, create the release plan. Furthermore, customers create the acceptance tests with testers (specialized developers). Developers estimate user stories, creating the iteration plan consisting of estimated tasks. Developers create the unit tests and code. Extreme programming practices, such as metaphor, small releases, simple design, pair programming, collective code ownership, and coding standards, can be expressed as constructors and quality-assurance methods of the aforementioned software development and management artifacts.
Figure 9. The Extreme Programming Process.
THE COMPLETE METHODOLOGICAL FRAMEWORK
This section describes additional components of a framework using the pattern of four artifacts. The structure of this framework is illustrated in Figure 10.
Figure 10. An OO specification of development processes.
Artifact relationships specify the static relationships between software development and management artifacts. They can be represented by a UML static structure diagram, where classes and objects have stereotypes, such as >, >, >, and >. The artifact relationships are discussed in the Static Part of the Methodological Framework section. Artifact interactions specify the development scenario. They can be represented by a UML sequence diagram or a UML collaboration diagram. The artifact interactions are discussed in the Dynamic Part of the Methodological Framework section. Artifact type specifies the purpose, constructor, quality assurance, and specific attributes of software development and management artifacts. The artifact types are discussed in the Basic Features of the Methodological Framework section. Artifact life cycle specifies the artifact states and the events that change them such as creation, completion, and approval. The life cycle shown in Figure 10 is an example. Different software development and management artifacts have different and often more complex life cycles.
Process type specifies types of interactions between software development and management artifacts; i.e., the purposes, goals, preconditions, and postconditions of the processes, as well as the list of artifacts accessed and modified by these processes. In the Rational Unified Process, this artifact is called workflow. In the Catalysis method, this artifact is called process pattern. Process relationships specify relationships between process types. For example, processes can contain each other or use each other. Process interactions specify a development scenario expressed in terms of a sequence of processes. It can illustrate, for example, a typical roadmap through a development process. Process life cycle specifies the events significant for the process and consequences of the events. This artifact is often represented by a UML activity diagram or flowchart.
The next section describes how various development methods are specified in terms of a methodological framework (see Fig. 11).
Figure 11. Methodological framework and specifications of development methods.
The Rational Unified Process version 5.0,7 describes the development and management artifacts and their relationships. It also specifies process types (workflow descriptions) and process life cycles (activity diagrams associated with each workflow). The Rational Unified Process does not specify the life cycles of the development and management artifacts, interactions between artifacts, relationships between processes (workflows), and process interactions (sequences of workflows). The process life cycle shows activities within each workflow but does not show the software development artifacts that are modified or accessed during the workflow. The Rational Unified Process could visualize these software development artifacts if it would be specified by artifact interactions (the sequence diagrams shown earlier), rather than workflows.
The Catalysis method specifies development and management artifacts and process types called process patterns, and informally specifies relationships between them. Catalysis also specifies artifact interactions in the strategy section of each process pattern, and process interactions called development phases. Catalysis does not specify artifact life cycles and process life cycles.
The Extreme Programming process specifies development and management artifacts such as user stories, commitment schedules, unit and functional tests, and code. It also specifies interactions between artifacts and the process participants, e.g., the planning game.
The Fusion method specifies development artifacts, their relationships (dependencies), and interactions, i.e., a typical order in which they are created and modified. The Fusion method does not specify artifact life cycles and any of the process artifacts, because it consists of only one process.
USING THE FRAMEWORK—CREATING A CUSTOMIZED METHOD
The Dynamic Part of the Methodological Framework section specified four software development scenarios. However, in real-life development, the software development artifacts are typically not created in any of the described orders. For example, another process may start with the product vision, specified in the artifact system, followed by a number of prototypes. Later, developers may specify the hardware structure by creating the artifact node relationships. They may then continue by sketching the architecture specified in the component model and component interactions. While developing the code, developers may record important design decisions in several object interactions artifacts.
A software development process can have many different scenarios, and the traditional development process illustrated in Figure 1 cannot describe them all without becoming overly complex. The traditional specification of development process typically specifies only a single development scenario. If the scenario dictated by the traditional method does not fit the organization culture or the concrete problem, it is necessary to customize it. However, the customized method still describes a single modified scenario, which still might not fit some specific software development problems.
Using a process framework allows for different scenarios and patterns during software development. In other words, the appropriate software development and management artifacts are created on demand, depending only on the problem and the concrete situation (see Fig. 12). The selection of software development and management artifacts and the order in which they are created or completed can be adjusted during the project. The process, therefore, always fits the problem solved. If the project requires only a subset of the software development and management artifacts identified in the previous section, the quality-assurance methods guarantee consistency between them.
Figure 12. Creating specific development processes by instantiating the framework.
However, in certain cases, the constructors of the software development and management artifacts have preconditions that require that certain software development and management artifacts must exist before other software development and management artifacts are created. Preconditions therefore indirectly imply an order in which the software development and management artifacts may be created. For example, to create the class life cycle, the artifact class must be created first. However, the order required by preconditions of constructors and quality-assurance methods is much less restrictive than a specification given by traditional design methods.
COMPARISON TO OTHER METHODOLOGICAL FRAMEWORKS
This section compares the process framework with the OPEN process and several process definition standards.
OPEN is a process-focused OO framework for software development methods. OPEN provides a range of activities, tasks, and techniques that can be tailored specifically to each individual organization or project. The OPEN process is an OO framework that regards activities as objects and tasks as their methods. The execution of the objects (activities) is guarded by pre- and postconditions on their methods (tasks). The postconditions include testing requirements and deliverables. OPEN has a well-defined metamodel9–11 consisting of projects, activities, tasks, deliverables, techniques, and sequencing rules. OPEN addresses the same problem as the framework discussed here. Instead of specifying a single process, it specifies the process framework and instantiates it (i.e., it creates a concrete method) for specific situations. Although the aim is similar, both approaches differ in the following details:
- OPEN is a process-focused framework. I describe a product-focused framework. OPEN objects (the first class citizens in an OO process model) are activities. In contrast to this, objects of the framework discussed here are products.
- Modularity and encapsulation of OPEN are at the level of activities. For example, OPEN allows an activity to be outsourced to an external organization. The contract between activities becomes a business contract between two organizations.8 The modularity of the framework here is at the level of products (software development and management artifacts). The products can be obtained from an external organization, and the constructor and quality-assurance methods become a business contract between two organizations.
- Both OPEN and the framework discussed here can create specific methods by choosing the method components that meet specific demands in specific situations. A concrete method based on OPEN is created by selecting the activities (with tasks) necessary to perform the project. The framework discussed here is instantiated by selecting the software development and management artifacts (pieces of information) necessary to make a final product. If the situation requires artifacts not specified in the framework, the pattern discussed in the Basic Features of the Methodological Framework section guarantees that new artifacts are added in a consistent manner.
- OPEN can be transformed into the framework discussed here and vice-versa. Although the artifacts presented here are smaller than OPEN deliverables, each of the OPEN deliverables can be mapped to one or more software development or management artifacts, and all OPEN tasks and techniques can be expressed as the constructors of artifacts and quality-assurance methods. The OPEN activities can be mapped to process types, but this mapping is only possible in certain cases. That is because the links between OPEN objects and their methods are specified in terms of probabilities (deontic certainty factors) that allocate which tasks are needed for which activities.12 The framework discussed here does not require such a probabilistic mechanism. An artifact either does or does not have its attributes and methods. Therefore, the mapping between the process types and OPEN activities is only possible in cases where the values of the deontic factors change to a bimodal distribution (0 or 1).
Several standards related to process definition, such as the Capability Maturity Model,13 the ISO 9000, and the Alistair's Cockburn's VW-Staging14 define quality, criteria, and the key practices that concrete development processes should meet. An OO specification of a development process can be directly evaluated against these standards simply by comparing the quality-assurance methods of the software development and management artifacts with the key practices and quality criteria defined by the process definition standard. However, the process definition standards are not supported by any well-defined metamodel. The OMG Process Working Group White Paper1 suggests a metamodel using OMG Meta Object Facility but without regular structures and guidelines for specifications of the artifacts.
Unlike the OO framework presented here, none of the standards mentioned describe patterns for structuring the software development and management artifacts. A development process is therefore more difficult to reuse and extend in a consistent manner. The process instantiated from the metamodel in the OMG Process Working Group White Paper is customized offline by means of project profiles that reflect, for example, the organizational cultures, industry domains, and technology types. The idea of the profile is certainly useful. However, the OO framework discussed here allows for process customization at a much lower level of granularity. The processes can be customized on demand to fit various problems being solved.
The basic concept of an OO process framework was inspired by an idea of active software artifacts by Klaas van den Berg and Mehmet Aksit.2,15 In 1996, we implemented the Fusion method5 with UML notation in a development department at Navision Software. The basic features of the process framework crystallized during 1996–1997, to solve the problem of covering various processes such as Fusion, Objectory, and Microsoft Solutions Framework in a single process framework.16 The invention of the pattern of four artifacts3 allowed the formation of the process metamodel.
At the beginning, the framework contained software development deliverables adopted from the Fusion method,5 with minor modifications to match the UML notation. Later, we extended the framework to reflect specific needs of various projects. Particularly, to cover component-based design, we added software development artifacts such as collaboration, interface, and their life cycles at various levels of granularity. To comply with the Microsoft Solutions Framework, we added a number of specific management artifacts describing the team model. The OO framework guaranteed that such extensions were made in a consistent manner.
The advantage of this solution was its flexibility, both in the customizable notation (the notation was often UML but not always; thus, the artifacts always had the most suitable representation in a particular context) and in the possibilities provided for modifying the process according to the size and character of the project. We used the same framework in projects whose complexity ranged from planning an architecture of our new product (estimated time horizon: four years), to regular releases of our current product (time horizon: six months), prototypes, small fixes, and functionality improvements (time horizon: one month).
The benefit of the described solution is its flexibility, both in the customizable notation (artifacts can have the most suitable representation in a particular context) and in terms of customization of the process. The benefits of an OO specification of the software development process are:
- The process is flexible, and the same framework is applicable to a wide range of projects. By simply defining or redefining the methods and attributes of the artifact types, the process can be easily adapted for use with different types of projects.
- It is robust and efficient. Small increments typically result in a subset of artifact types: system, plan, tasks, source code, and user documentation. With larger increments, the number of types of artifacts increases so that the size of the design specification always reflects the size of the project. The process does not force developers to create artifacts they don't need. The design specification is often not entirely complete but it is consistent, and developers are aware of the pragmatic incompleteness because of the quality-assurance methods of each artifact. Moreover, the quality-assurance methods give a good overview of how complete the specification is.
- The process is consistent. In the traditional specification of a development process, an activity, software development, or management artifact might be omitted during project planning. In an OO specification, the software development and management artifacts that are necessary for the development cannot be omitted because of the constructor and quality-assurance methods of related artifacts.
It should be noted that the framework described here is not a so-called document-based process.
The document-based processes focus on the documents delivered. The documents often have a form that is well-defined by templates and checklists. Document-based processes have a bad reputation because the success of a project has often been measured in terms of the documents being delivered on time. For software projects, this encouraged problems such as bureaucracy, slow delivery, and requirements drift.
The framework specified here can be characterized as product focused, rather than document focused. Software development and management artifacts are essentially products, i.e., pieces of information (see the artifact definition in the Basic Features of the Methodological Framework section). The framework strictly distinguishes between the information itself (called software development or management artifacts here) and its physical representation (called deliverable or document in the traditional approach). Sometimes the information is not represented physically and might exist only as a mental model. Even for such artifacts, the framework concepts can be applied.
Many software development and management artifacts in the framework, such as class life cycle, are too small to be useful documents delivered separately, for example, at a project milestone. For pragmatic reasons, software development and management artifacts can be combined together to make useful documents. Examples of such aggregated software development artifacts can be found in "The Object-Oriented Process..."16
I discussed an OO framework for specification of software development processes. The software development and management artifacts are modeled as objects with constructors and quality-assurance methods, and a number of specific attributes. An OO specification of a development process is simpler, more consistent, and easier to customize than the traditional specification based on deliverables and tasks.
- OMG White Paper on Analysis & Design Process Engineering, Process Working Group, Analysis and Design Platform Task Force, OMG document ad/98-07-12, July 1998.
- Hruby, P. "The Object Model for a Product-Based Development Process," ECOOP 97, Workshop on Modeling Software Processes and Artifacts, Jyväskylä, Finland, June 9–13, 1997.
- Hruby, P. "Structuring Software Development Design Artifacts with UML," JOOP, 12(9): 22–33, Feb. 2000.
- Kruchten, P. The Rational Unified Process, Addison–Wesley, Reading, MA, 1998.
- Coleman, D. et al. Object-Oriented Development: The Fusion Method, Prentice Hall, Englewood Cliffs, NJ, 1994.
- Hruby, P. "Framework for Describing UML Compatible Development Processes," >'99, Fort Collins, CO, Oct. 28–30, 1999.
- Rational Unified Process 5.0, Rational Corporation, 1999.
- Graham, I., B. Henderson-Sellers, and H. Younessi. The OPEN Process Specification, ACM Press, NY, 1997.
- Henderson-Sellers, B. "A Methodological Metamodel of Process," JOOP, 11(9): 56–58, 63, Feb. 1999.
- Henderson-Sellers, B. et al. "Instantiating the Process Metamodel," JOOP, 12(3): 51–57, June 1999.
- Firesmith, D. and B. Henderson-Sellers. "Improvements to the OPEN Process Metamodel," JOOP 12(7): 30–35, Nov./Dec. 1999.
- Graham, I. "Message in the mailing list OTUG," Subject: RE: (OTUG) Unified Process, September 17, 1998, 01:09 GMT.
- Paulk, M. C. et al. Capability Maturity Model for Software version 1.1, CMU/SEI-93-TR-024.
- Cockburn, A. "Using 'V-W' Staging to Clarify Spiral Development," available at: http://members.aol.com/acockburn/papers/vwstage.htm.
- Van den Berg, K. and M. Aksit. "Workshop on Modeling Software Processes and Artifacts, Call for participation," ECOOP'97, Jyväskylä, Finland, June 9–13, 1997.
- Hruby, P. "The Object-Oriented Process for a Development Method," OOPSLA 97, Atlanta, GA, 1997.
- Beck, K. Extreme Programming Explained, Addison Wesley Longman, Reading, MA, 1999.