Class-responsibility-collaboration card

Last updated

Class-responsibility-collaboration (CRC) cards are a brainstorming tool used in the design of object-oriented software. They were originally proposed by Ward Cunningham and Kent Beck as a teaching tool [1] but are also popular among expert designers [2] and recommended by extreme programming practitioners. [3] Author Martin Fowler has written that CRC cards may be a sensible means by which multiple alternative interactions may be quickly devised, as they avoid a great deal of drawing and erasing. CRC card sessions may be followed by the creation of sequence diagrams to capture interactions that are identified.

Contents

CRC cards are frequently employed during the design phase of system and software development to transition use-case descriptions into class diagrams, allowing a smoother transition with a greater overview and permitting developers to implement solutions with low binding and high cohesion.

CRC cards are usually created from index cards. Members of a brainstorming session will write one CRC card for each relevant class/object of their design. The card is partitioned into three areas: [1] [2]

  1. On top of the card, the class name
  2. On the left, the responsibilities of the class
  3. On the right, collaborators (other classes) with which the class interacts to fulfill its responsibilities

Using small cards minimizes the complexity of the design, reduces class responsibilities and keeps designers focused on the essentials of the classes without exploring implementation details. Because the cards are portable, they can easily be laid out on a table and rearranged while discussing a design.

Creating CRC cards

Creation of CRC cards normally begins with writing a scenario that identifies the major actors and actions. From the scenario, nouns should become classes, verbs become responsibilities and collaborators are the other cards with which the card will interact.

See also

Related Research Articles

<span class="mw-page-title-main">Kent Beck</span> American software engineer

Kent Beck is an American software engineer and the creator of extreme programming, a software development methodology that eschews rigid formal specification for a collaborative and iterative design process. Beck was one of the 17 original signatories of the Agile Manifesto, the founding document for agile software development. Extreme and Agile methods are closely associated with Test-Driven Development (TDD), of which Beck is perhaps the leading proponent.

<span class="mw-page-title-main">Martin Fowler (software engineer)</span> American software developer, author and international public speaker on software development

Martin Fowler is a British software developer, author and international public speaker on software development, specialising in object-oriented analysis and design, UML, patterns, and agile software development methodologies, including extreme programming.

<span class="mw-page-title-main">Unified Modeling Language</span> Software system design modeling tool

The Unified Modeling Language (UML) is a general-purpose, developmental modeling language in the field of software engineering that is intended to provide a standard way to visualize the design of a system.

<span class="mw-page-title-main">Ward Cunningham</span> American computer programmer who developed the first wiki (born 1949)

Howard G. Cunningham is an American computer programmer who developed the first wiki and was a co-author of the Manifesto for Agile Software Development. A pioneer in both design patterns and extreme programming, he started coding the WikiWikiWeb in 1994, and installed it on c2.com on March 25, 1995, as an add-on to the Portland Pattern Repository. He co-authored a book about wikis, entitled The Wiki Way, and invented the Framework for Integrated Tests.

In software engineering, a software design pattern is a general, reusable solution to a commonly occurring problem within a given context in software design. It is not a finished design that can be transformed directly into source or machine code. Rather, it is a description or template for how to solve a problem that can be used in many different situations. Design patterns are formalized best practices that the programmer can use to solve common problems when designing an application or system.

In computer programming, a code smell is any characteristic in the source code of a program that possibly indicates a deeper problem. Determining what is and is not a code smell is subjective, and varies by language, developer, and development methodology.

In software and systems engineering, the phrase use case is a polyseme with two senses:

  1. A usage scenario for a piece of software; often used in the plural to suggest situations where a piece of software may be useful.
  2. A potential scenario in which a system receives an external request and responds to it.
<span class="mw-page-title-main">IDEF</span> Family of modeling languages

IDEF, initially an abbreviation of ICAM Definition and renamed in 1999 as Integration Definition, is a family of modeling languages in the field of systems and software engineering. They cover a wide range of uses from functional modeling to data, simulation, object-oriented analysis and design, and knowledge acquisition. These definition languages were developed under funding from U.S. Air Force and, although still most commonly used by them and other military and United States Department of Defense (DoD) agencies, are in the public domain.

The Portland Pattern Repository (PPR) is a repository for computer programming software design patterns. It was accompanied by a companion website, WikiWikiWeb, which was the world's first wiki. The repository has an emphasis on Extreme Programming, and it is hosted by Cunningham & Cunningham (C2) of Portland, Oregon. The PPR's motto is "People, Projects & Patterns".

<span class="mw-page-title-main">Systems development life cycle</span> Systems engineering terms

In systems engineering, information systems and software engineering, the systems development life cycle (SDLC), also referred to as the application development life cycle, is a process for planning, creating, testing, and deploying an information system. The SDLC concept applies to a range of hardware and software configurations, as a system can be composed of hardware only, software only, or a combination of both. There are usually six stages in this cycle: requirement analysis, design, development and testing, implementation, documentation, and evaluation.

Object-oriented analysis and design (OOAD) is a technical approach for analyzing and designing an application, system, or business by applying object-oriented programming, as well as using visual modeling throughout the software development process to guide stakeholder communication and product quality.

Glossary of Unified Modeling Language (UML) terms provides a compilation of terminology used in all versions of UML, along with their definitions. Any notable distinctions that may exist between versions are noted with the individual entry it applies to.

Object-oriented design (OOD) is the process of planning a system of interacting objects for the purpose of solving a software problem. It is one approach to software design.

<span class="mw-page-title-main">Greenfoot</span>

Greenfoot is an integrated development environment using Java or Stride designed primarily for educational purposes at the high school and undergraduate level. It allows easy development of two-dimensional graphical applications, such as simulations and interactive games.

Organizational patterns are inspired in large part by the principles of the software pattern community, that in turn takes it cues from Christopher Alexander's work on patterns of the built world. Organizational patterns also have roots in Kroeber's classic anthropological texts on the patterns that underlie culture and society. They in turn have provided inspiration for the Agile software development movement, and for the creation of parts of Scrum and of Extreme Programming in particular.

<span class="mw-page-title-main">IDEF4</span>

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.

<span class="mw-page-title-main">The Hillside Group</span>

The Hillside Group is an educational nonprofit organization founded in August 1993 to help software developers analyze and document common development and design problems as software design patterns. The Hillside Group supports the patterns community through sponsorship of the Pattern Languages of Programs conferences.

Responsibility-driven design is a design technique in object-oriented programming, which improves encapsulation by using the client–server model. It focuses on the contract by considering the actions that the object is responsible for and the information that the object shares. It was proposed by Rebecca Wirfs-Brock and Brian Wilkerson.

<span class="mw-page-title-main">Extreme programming</span> Software development methodology

Extreme programming (XP) is a software development methodology intended to improve software quality and responsiveness to changing customer requirements. As a type of agile software development, it advocates frequent releases in short development cycles, intended to improve productivity and introduce checkpoints at which new customer requirements can be adopted.

Story-driven modeling is an object-oriented modeling technique. Other forms of object-oriented modeling focus on class diagrams. Class diagrams describe the static structure of a program, i.e. the building blocks of a program and how they relate to each other. Class diagrams also model data structures, but with an emphasis on rather abstract concepts like types and type features.

References

  1. 1 2 Beck, Kent; Cunningham, Ward (1986). "A Laboratory for Teaching Object Oriented Thinking". SIGPLAN Not. 24 (10): 1–6. doi:10.1145/74878.74879.
  2. 1 2 Martin Fowler, UML Distilled, chapter 4
  3. ↑ A concise introduction at extremeprogramming.org
This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.