CSC/ECE 517 Spring 2013/ch4b 1l dh: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
No edit summary
 
(101 intermediate revisions by the same user not shown)
Line 1: Line 1:
Hi there.
== CRC <ref name="aa"> http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_aa </ref> ==


Work in progress.
'''Class-Responsibility-Collaborator Cards (CRC)''' are a design and organization technique used to help discuss and outline [http://en.wikipedia.org/wiki/Object-oriented object-oriented] software.  It was initially proposed by [http://en.wikipedia.org/wiki/Kent_Beck Kent Beck] and [http://en.wikipedia.org/wiki/Ward_Cunningham Ward Cunningham] in 1989 ''"to document collaborative design decisions."'' <ref name="beck">[http://c2.com/doc/oopsla89/paper.html "A Laboratory For Teaching Object-Oriented Thinking"] by Beck and Cunningham</ref> This technique is a way to outline [http://en.wikipedia.org/wiki/Class_(computer_programming) classes], determine their responsibilities, and describe their relationships. CRC cards can be either physical (such as on [http://en.wikipedia.org/wiki/Index_card index cards]), or digital.  In either case the information for each [http://en.wikipedia.org/wiki/Class_(computer_programming) class] is written/displayed on separate cards.<ref name="lecnotes">Lecture Notes</ref>
 
[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_aa aa Fall 2011]
[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_sd sd Fall 2011]
[http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_js js Fall 2011]
 
== CRC ==
"'''CRC Card Design Tools"
 
 
'''Class-Responsibility-Collaborator Cards (CRC)''' were initially proposed by [http://en.wikipedia.org/wiki/Kent_Beck Kent Beck] and [http://en.wikipedia.org/wiki/Ward_Cunningham Ward Cunningham] in 1989 "to document collaborative design decisions."<ref name="beck">[http://c2.com/doc/oopsla89/paper.html "A Laboratory For Teaching Object-Oriented Thinking"] by Beck and Cunningham</ref> They are a way to discover classes, determine the responsibilities of each of those classes, and describe their relationships. The information for each class is written on a separate card.<ref name="lecnotes">Lecture Notes</ref> This article will discuss CRC cards and how they have been implemented in several modern software packages.




__TOC__
__TOC__


== Introduction ==
== Introduction <ref name="aa"/> <ref name="sd"> http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_sd </ref> ==
A CRC card is a notecard laid out in a particular fashion where one may define a [http://en.wikipedia.org/wiki/Class_(computer_programming) class], its responsibilities, and collaborators (see figures below). In this definition, a class refers to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] in the traditional object-oriented sense; responsibilities refers to the actions that the object must take and roles it must fill; and collaborators refers to the other objects with which the originally defined class must interact.<ref name="skrien">Skrien, Dale John. Object-oriented Design Using Java. Boston: McGraw-Hill Higher Education, 2009. Print.</ref> In other words, the class name of an object "creates a vocabulary for discussing a design," the responsibilities "identify problems to be solved," and collaborators are "objects which will send or be sent messages in the source satisfying responsibilities."<ref name="beck"/> For a complete set of CRC card content of an ATM system, refer to this example: [http://www.math-cs.gordon.edu/local/courses/cs211/ATMExample/CRCCards.html CRC Cards for ATM Example].
A CRC card is commonly a notecard laid out in a particular fashion where one may define a [http://en.wikipedia.org/wiki/Class_(computer_programming) class], its responsibilities, and [http://en.wikipedia.org/wiki/Collaboration collaborators] (see figures below). A class refers to an [http://en.wikipedia.org/wiki/Object_(computer_science) object] in the traditional object-oriented sense; responsibilities refers to the actions that the object must take and roles it must fill; and collaborators refers to the other objects with which the originally defined class must interact.<ref name="skrien">Skrien, Dale John. Object-oriented Design Using Java. Boston: McGraw-Hill Higher Education, 2009. Print.</ref> The class name of an object ''"creates a vocabulary for discussing a design,"'' the responsibilities ''"identify problems to be solved,"'' and collaborators are ''"objects which will send or be sent messages in the source satisfying responsibilities."''<ref name="beck"/> For a complete set of CRC card content of an ATM system, refer to this example: [http://www.math-cs.gordon.edu/local/courses/cs211/ATMExample/CRCCards.html CRC Cards for ATM Example].
   
   


{| style="margin: 1em auto 1em auto"
'''Generic Template'''
|+
{| class="wikitable hintergrundfarbe5" width="400"
! ||
! align="left" colspan="2" width="100%" | Class name
 
|-
|-
| [[File:CRCCardSample1.gif]] || [[File:CRCCardSample2.gif]]
| align="center" colspan="1" height="100px"| ''Responsibilities''
| align="center" colspan="1" height="100px"| ''Collaborators''
|}
|}


;Example
[[File:CRCCardSample2.gif]]


;Background
Class-Responsibility-Collaborator cards are an evolution of [http://en.wikipedia.org/wiki/Use_case use cases]. Use cases would use "actors" and then define a "story" of their actions. The nouns and verbs in these stories would be leveraged in an effort to help determine the relevant classes and [http://en.wikipedia.org/wiki/Method_(computer_programming) methods].<ref name="skrien"/> This method originally used 4"x6" index cards because they were "cheap, portable, readily available, and familiar."<ref name="beck"/>


Class-Responsibility-Collaborator cards are an evolution of simple [http://en.wikipedia.org/wiki/Use_case use cases]. In such use cases, "actors" would be defined and a "story" of their actions would be written. Extraction of the nouns and verbs in these stories would be leveraged in an effort to help determine the relevant classes and [http://en.wikipedia.org/wiki/Method_(computer_programming) methods].<ref name="skrien"/> The proponents of the method originally used 4"x6" index cards because they were "cheap, portable, readily available, and familiar."<ref name="beck"/> The process of designing a system via CRC cards starts with giving blank cards to the designing team. People in the team then start acting out the different use case scenarios. As the use cases are performed, classes and actions are written down and refined, ultimately resulting in a comprehensive class definition.
==Creating CRC Cards <ref name="sd"/>==
 
# Identify and assign candidate classes
# Determine a set of specific scenarios
# Walk through the scenario, naming cards and responsibilities
# Write the main responsibility for each class
# Identify the responsibilities for each class 
# Identify one or more collaborators for each class


This is how Beck and Cunningham describe the designing process, making the exception for specific details when needed<ref name="skrien"/>:
These index cards become your class diagram. In your class diagram, you create a class for each card that was used. The responsibilities on the card become the method of the class. All collaborators indicate that an association between the two classes must be drawn (and the class will need to have an instance of the collaborating classes). Finally, the data members on the back of the card become the [http://en.wikipedia.org/wiki/Attribute_(computing) attributes] of the class.
<blockquote>We start with only one or two obvious cards and start playing "what-if". If the situation calls for a responsibility not already covered by one of the objects we either add the responsibility to one of the objects, or create a new object to address that responsibility. If one of the object becomes too cluttered during this process we copy the information on its card to a new card, searching for more concise and powerful ways of saying what the object does. If it is not possible to shrink the information further, but the object is still too complex, we create a new object to assume some of the responsibilities. The goal of this exercise is to encourage designers to pick up the card whose role they are assuming while 'executing' a scenario and stress the importance of creating objects not to meet mythical future needs, but only under the demands of the moment. This ensures that a design contains only as much information as the designer has directly experienced, and avoids premature complexity.<ref name="beck"/></blockquote>


Beck and Cunningham describe the designing process:<ref name="skrien"/>:
<blockquote>''We start with only one or two obvious cards and start playing "what-if". If the situation calls for a responsibility not already covered by one of the objects we either add the responsibility to one of the objects, or create a new object to address that responsibility. If one of the object becomes too cluttered during this process we copy the information on its card to a new card, searching for more concise and powerful ways of saying what the object does. If it is not possible to shrink the information further, but the object is still too complex, we create a new object to assume some of the responsibilities. The goal of this exercise is to encourage designers to pick up the card whose role they are assuming while 'executing' a scenario and stress the importance of creating objects not to meet mythical future needs, but only under the demands of the moment. This ensures that a design contains only as much information as the designer has directly experienced, and avoids premature complexity.''<ref name="beck"/></blockquote>


The physical spacial arrangement of the cards can have informal meaning:
;Physical Arrangement
* When cards overlap it can mean that the objects represented by the cards are collaborating
* When cards overlap it can mean that the objects represented by the cards are collaborating
* A card placed above another card can mean that the object it represents is supervising the object represented by the card below
* A card placed above another card can mean that the object it represents is supervising the object represented by the card below
* Cards representing parts are usually placed below the card representing the whole
* Cards representing parts are usually placed below the card representing the whole
* "Refinements of an abstraction can be collected and handled as a single pile of cards with the most abstract card on top where it can represent the rest"<ref name="beck"/>
* ''"Refinements of an abstraction can be collected and handled as a single pile of cards with the most abstract card on top where it can represent the rest" ''<ref name="beck"/>
 


Beck and Cunningham noticed that "when designers pick up a card they seem to more readily identify with it, and are prepared to deal with the remainder of the design from its perspective. It is the value of this physical interaction that ... resist[s] a computerization of the cards."<ref name="beck"/>
==Tools <ref name="aa"/><ref name="sd"/><ref name="js"> http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_js </ref> ==
There are several CRC card tools available which are implemented in software.  They help ease the creation of CRC cards when many are necessary or a digital format is preferred.  A digital representation is easier to share, and modify in large numbers.


This article will perform a survey of the computerization of this design methodology, keeping in mind that these tools may not provide the same user experience and ultimately the same design results as when the design team is interacting via the use of physical cards. The main criteria for successful execution of computerization will be how well the application can mimic the actions of using physical cards.


==Tools==
===Stickies===
===Stickies===
Probably the simplest way to reproduce CRC cards on a computer is using applications like [http://www.youtube.com/watch?v=M1DscVsO2uE Stickies] on Mac OSX and [http://windows.microsoft.com/en-US/windows7/products/features/sticky-notes Sticky Notes] on Microsoft Windows 7. Both pieces of software can hold all the information that physical CRC cards contain.
[http://windows.microsoft.com/en-US/windows7/products/features/sticky-notes Sticky Notes] is a simplistic method to mimic physical CRC cards with software. It is available for [http://en.wikipedia.org/wiki/Microsoft Microsoft] [http://en.wikipedia.org/wiki/Windows_7 Windows 7] and [http://en.wikipedia.org/wiki/Windows_7 Windows 8].
 
 
{| style="margin: 1em auto 1em auto"
|+ '''Example of stickies'''
! ||
|-
| On Mac OSX|| On Windows 7
|-
| [[File:Stickies.png|x287px]] ||  [[File:Stickynotes.PNG|x287px]]
|}
 


{| class="wikitable" style="margin: 1em auto 1em auto"
;On Windows 7
|+ '''Mac OSX Stickies vs. Windows 7 Sticky Notes'''
[[File:Stickynotes.PNG|x287px]]
! Feature || Mac OSX || Windows 7
|- align="center"
| Change the background color of a note  || ✔ || ✔
|- align="center"
| Format text using different fonts and colors  || ✔ || ✔
|- align="center"
| Collapse and expand a note || ✔ ||
|- align="center"
| Insert images and videos into a note || ✔ ||
|- align="center"
| Make a note translucent || ✔ ||
|- align="center"
| Create a new note from the text selected in an application || ✔ ||
|- align="center"
| Import/export the content of a note || ✔ ||
|- align="center"
| Spell checker || ✔ ||
|- align="center"
| Add scrollbars to a note || ✔ || ✔
|- align="center"
| Support pen and touch input || || ✔
|}


===QuickCRC===
===QuickCRC===
[http://www.excelsoftware.com/quickcrcdownload.html QuickCRC] is a stand-alone application specifically designed to support CRC card diagrams.
[http://findfiles.com/14090/details-quickcrc-macosx.html QuickCRC] is a tool developed by [http://www.excelsoftware.com/ Excel Software] for responsibility driven design of object-oriented software using CRC cards. CRC cards are used to discover and document classes, responsibilities, attributes and collaborations between classes. Design scenarios can be identified and simulated. Complex designs can be partitioned into multiple diagrams with easy navigation through a contents view. The inheritance graph automatically shows the class structure of the evolving design. The user can assign the attribute access of each card responsibility and the tool presents an attribute access graph.<ref name="quickcrc1">[http://findfiles.com/14090/details-quickcrc-macosx.html QuickCRC Tool]</ref> This tool is available for both Windows and Mac OS X.


[[File:Quickcrc-1.PNG|400px|QuickCRC Tool]]
[[File:QuickCRC.gif|300px|CRCs Card drawn using QuickCRC]]


{| style="margin: 1em auto 1em auto"
The features of QuickCRC<ref name="quickcrc2">[http://www.excelsoftware.com/quickcrcwin.html QuickCRC by Excel Software]</ref> are:
|+ '''Example of a CRC card and of a scenario'''
*Cards and scenario objects can be drawn in the diagram workspace. Each card has a class name, description, superclasses, subclasses, attributes, responsibilities and collaborating objects.
! ||
*The card information is entered through a dialog or edit on-screen by dragging or renaming cards, attributes, responsibilities and collaborations.
|-
*Assign the attribute access of each card responsibility. Also shows an attribute access graph from the card information to help developers discover, refine and eliminate unnecessary card attributes.
| Front of the CRC card|| Back of the CRC card|| Scenario
*Scenarios can reference cards or other scenarios.
|-
*Cut and paste cards and scenarios between diagrams or projects.
| [[File:QuickCRCCardFront.png]] ||  [[File:QuickCRCCardBack.png]] || [[File:QuickCRCScenario.png]]
*Allows a designer to navigate between diagrams shown as folder icons that can be opened or closed. A card or scenario can be dragged between diagrams or double-clicked to edit its properties making it easy to locate and modify information as the model grows.
|}
*Provides active simulation of an evolving design.
*Maintains relationships between cards, scenarios and external agents as fluid design changes take place. If a card references undefined subclasses or superclasses, those cards are generated automatically.  
*Model other relationships between cards like aggregation and interface implementation.  
*Name changes and cross references between objects are instantly updated.  
*Has a rich search feature for locating design data within specific fields of any card or scenario in the project.


This software tool runs best on Windows XP, Vista or 7 with 1 GB RAM. The package includes both a Standard and Lite edition. The only difference between these two editions is the amount of data that a project can hold and the memory requirements of your machine.<ref name="quickcrc2" />


"A scenario describes what happens in the system from a high-level, user’s point of view. The goal of walking through scenarios is to discover where additional classes,
responsibilities and collaborations are required or where existing items have become redundant."<ref name="qcrcpdf">QuickCRC Tutorial PDF</ref>


For example, the above scenario says that in order to write a document out to disk the UI (<tt>AnyClient</tt>) calls the <tt>Write</tt> responsibility of the <tt>TDocument</tt> object. Then the <tt>TDocument</tt> calls the <tt>EachItemDo</tt> responsibility of the <tt>TList</tt> object to loop through all the shapes contained in the document and finally the <tt>TDocument</tt> calls the <tt>Write</tt> responsibility of each <tt>TShape</tt> object. If a step in a scenario is particularly complex it can be modeled and detailed by a subscenario.
===Software Ideas Modeler===
[http://www.softwareideas.net/ Software Ideas Modeler] is a lightweight and powerful [http://en.wikipedia.org/wiki/Computer-aided_software_engineering CASE] tool. It supports UML 2.2 diagrams. Software Ideas Modeler is [http://en.wikipedia.org/wiki/Freeware freeware]. <ref name="modeler">[http://www.softwareideas.net/ Software Ideas Modeler]</ref>


One can walk through a scenario mentally or can use a tool that ''plays'' the scenario step by step. At each step the tool reports who is calling who and all the descriptions associated to the sender, receiver and responsibility called. This can help identifying missing or redundant pieces in the design (classes, responsibilities, attributes).
{|
 
|[[File:Crccard-sim.PNG|500px|A sample CRC card in Software Ideas Modeler]]
In QuickCRC all the information in the cards can be dragged around into other cards and the tool takes care of establishing the appropriate relationship among the cards. For example if class <tt>TEventHandler</tt> is supposed to be the superclass of <tt>TWindow</tt>, one can drag the <tt>TEventHandler</tt> card name into the ''Superclasses:'' field of the <tt>TWindow</tt> card. Or if one needs to move a responsibility or an attribute from one class to another one can just drag the responsibility/attribute from the origin card to the recipient card. A class can inherit from multiple classes but the tool will not solve method name conflicts for the user.
|[[File:SM2.png|600x600px]]
 
|}
The tool can keep track of external agents like a user or other systems that typically drive or influence the functioning of the system being designed. If the system being designed is too large, the tool will allow the user to split the cards into multiple diagrams so that he or she can deal with only a manageable subset of cards at any time. The tool allows to arrange cards and scenarios based on different criteria, and the tool can generate graphs to show the inheritance structure of a card -- for example to show all the subclasses of a particular class.
 
Once the design reaches a point where implementation can start, the tool can generate a listing of all the classes in the system with relative attributes and responsibilities. This listing is then handed over to the programmers. The design can also be exported into a text file that can be imported by the QuickUML modeling tool. On the other hand the tool can import English text that describes the system one is trying to design and it will attempt to derive classes from nouns in the text, attributes from adjectives and responsibilities from verbs and it'll auto-generate cards accordingly.
 
If one is trying to reverse engineer existing source code, he or she can use tools like WinTranslator or MacTranslator to extract design information from the source code into a dictionary entries list that then can be imported into QuickCRC that will automatically populate a new project with cards that reflect the design information gathered by the other tools.


===Visual Paradigm for UML===
VP-UML is a [http://en.wikipedia.org/wiki/Computer-aided_software_engineering CASE] tool. It supports CRC card diagrams as part of the requirements management workflow. VP-UML provides tools to support many other workflows such as [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML] modeling, business process modeling, database modeling, UI modeling, reverse engineering and more.


{| style="margin: 1em auto 1em auto"
This tool is fairly simple to use and also allows the user to customize the card properties. It supports various types of automatic alignment for diagram elements.  It supports standard functions such as as undo/redo and copy paste with the clipboard. Diagram elements can be styled (background color, text color, fonts, border), grouped, placed in layers. The tool also provides an additional feature of including the subclasses and superclass of the class in discussion. Every field value can be modified and renamed inline. This tool also provides a feature of customizing the text and style based on the class. An interesting feature of this tool is that one can attach comments to a CRC card and also link the comments along with the comments.
|+ This is how CRC cards look in VP-UML:
! ||
|-
| [[File:VPCRC1.png]] || [[File:VPCRC2.png]]
|}


There is an export to raster image formats (BMP, GIF, JPG, PNG, TIFF), vector image formats (Windows Metafile, SVG) and PDF. There is also export to XML. There is an import from XML.<ref name="simwiki">[http://en.wikipedia.org/wiki/Software_Ideas_Modeler Software Ideas Modeler - Wikipedia]</ref> It also provides support for various languages. The diagrams can be exported to multiple image formats and [http://en.wikipedia.org/wiki/Vector_graphics vector formats] like WMF, EMF, SVG and bitmap format PNG. It has support for source code generation for languages like C#, VB.NET, SQL DDL.


The part of VP-UML that supports CRC card provides functionalities that are common to other tools but it has the following peculiarities:
===Visual Paradigm===
* It can generate UML class diagrams automatically out of the CRD cards.
[http://www.visual-paradigm.com/ Visual Paradigm] for UML (VP-UML) is a [http://en.wikipedia.org/wiki/Unified_Modeling_Language UML] [http://en.wikipedia.org/wiki/Computer-aided_software_engineering CASE] Tool supporting UML 2, SysML and Business Process Modeling Notation (BPMN) from the Object Management Group (OMG). In addition to modeling support, it provides report generation and code engineering capabilities including code generation. It can [http://en.wikipedia.org/wiki/Reverse_engineering reverse engineer] diagrams from code, and provide round-trip engineering for various programming languages.<ref name="visual">[http://en.wikipedia.org/wiki/Visual_Paradigm_for_UML Visual Paradigm for UML]</ref>
* A class diagram can also generate Java code for the classes directly inside Eclipse
* All properties in a CRC card must be edited inline. To edit, double click on the desired field, update its value, and click on the diagram background to confirm editing. (from [http://www.visual-paradigm.com/support/documents/vpumluserguide/1281/1289/6518_drawingcrcca.html here])
* Cannot drag and drop values from one card to the other.
* You can record audio to associate to a diagram.
* You can decide which portions of a CRC card are displayed (Responsibilities, Attributes etc.)


===Software Ideas Modeler===
[[File:Crc-visual.png|375px|Visual Paradigm Tool with a sample CRC Card]]
[http://www.softwareideas.net/ Software Ideas Modeler] is a "lightweight and powerful [http://en.wikipedia.org/wiki/Computer-aided_software_engineering CASE] tool" by Dušan Rodina. It can be used to create UML diagrams, manage tasks, reverse engineer, generate source code, and help to create other diagram types (including CRC cards). Below is an exported graphic of the software's capabilities in regards to working with CRC cards.
[[File:Edit description 9975.png|300px|CRC Card with inline editing]]


{| style="margin: 1em auto 1em auto"
Visual Paradigm for UML provides a CRC Card diagram for software team to brainstorm, records, analyze and maintain CRC cards in systematic and collaborative way.  It allows easy addition of responsibilities to a class. Along with this, all fields on a CRC card can be edited inline. The CRC diagrams in the tool are not linked to the sequence diagrams. This tool can be integrated with Eclipse/IBM WebSphere, Borland, JBuilder, NetBeans IDE, IntelliJ IDEA, Oracle JDeveloper and BEA WebLogic Workshop to support the implementation phase of software development. The transitions from analysis to design and then to implementation are seamlessly integrated within the CASE tool, thus significantly reducing efforts in all stages of the software development lifecycle.<ref name="tools">[http://www.visual-paradigm.com/ Visual Paradigm]</ref>
|+
! ||
|-
| [[File:SWIdeasModeler.png|x287px]]
|}


===CRC Design Assistant===
The CRC Design Assistant was first conceived to assist students in creating real-world software applications in the context of the software engineering course at [http://en.wikipedia.org/wiki/University_of_Texas_at_El_Paso UTEP]. This tool helps in visualizing the design, tracking design changes, maintaining the list of system responsibilities when classes are removed, revising documentation when designs change, and presenting a design to other team members and observers.<ref name="design">Steve Roach, Department of Computer Science, University of Texas at El Paso, Javier C Vásquez, Department of Computer Science, University of Texas at El Paso, "A Tool to Support the CRC Design Method", October 2004</ref>


On the core ideas of CRC card use, namely in specifying classes, responsibilities, and collaborators, SIM was very effective. The user interface was rather intuitive, and adding and removing entries was handled through a simple property page. Software Ideas Modeler enhanced the CRC card functionality by allowing entry of subclass and superclass information, which may or may not be "too much" information depending on one's opinion on the required elements of a CRC card.
[[File:Design1.png|400px|CRC Design Assistant Tool]]
[[File:Design cardview.png|500px|CRC Card View]]


One nice feature of SIM was the ability to attach "comment cards" to any item. This feature is the equivalent of adding a "Post-It" note to a card that contains any additional information about the items on the card. The software also has the ability to arrange the cards in a variety of different ways. Not only can cards be stacked, but they can be arranged in row, circle, cascade, and smart (grouped and routed by object type). Groups and even separate layers can be made to further enhance this arrangement functionality. Software Ideas Modeler additionally has the ability to export documentation sets into PDF format automatically.
The characteristics of this tool are:
*Supports the CRC design method and assist students in creating, modifying, and documenting
*Helps in creating object-oriented designs
*Helps maintain a class hierarchy of the different classes (cards) that are created for a subsystem
*Provides a drag and drop feature where the responsibilities could be selected and dragged in the subsystem or class list
*Draws lines to indicate collaborator classes making it visually easy to understand and correlate
*Supports a team environment and is accessible over the internet
*Allows the ability to track changes made by each team member
*Generates a design documentation in the form of [http://en.wikipedia.org/wiki/Rich_text_format RTF] files and diagrams
*Stores the entire design in a single database


===Hot Draw===
The tool is fairly simple and easy to maintain.


[http://c2.com/cgi/wiki?HotDraw Hot Draw] is a [http://en.wikipedia.org/wiki/Software_framework framework] for developing drawing programs (programs that allow users to create pictures and graphics). Toward that end, Hot Draw is not exactly a CRC card creation application but instead could be thought of the genesis for CRC card design in the first place.<ref name="neworleans">[http://c2.com/cgi/wiki?WardAndRalphInNewOrleans Ward and Ralph in New Orleans]</ref>  
===EasyCRC Tool===
The [https://sites.google.com/site/easycrc/ Easy CRC] tool makes use of the .NET Framework. This tool divides the task of making CRC cards into two stages. The first stage is identifying the objects from a definition which is a plain text and then identifying the responsibilities and collaborators for the identified responsibilities by simulating scenarios through sequence diagrams.<ref name="easy">[http://www.easycrc.com/ EasyCRC Tool]</ref>


{| style="margin: 1em auto 1em auto"
{|
|+
|[[File:easyCRC2.png|x300px]]
! ||  
|[[File:Easycrc.jpg|400px|Easy CRC Tool]]
|-
| [[File:JHotDraw.PNG|x287px]]
|}
|}


Editing the CRC cards using the CRC card editor can be done in different ways. One method is to enter all information manually - editing the different values through the property editor in the tool. Right-click the “CRC cards” node in the solution explorer; a sub menu will be displayed with an option to add an item to the sub tree below. In this manner the user can Assign Responsibilities, Add Attributes, Add Methods to responsibilities and set the different properties of the item. Another way is to create sequence diagrams and from them, the collaborators and
responsibilities of the CRC cards would be discovered automatically.<ref name="easypaper">"Easy CRC Tool - Description Paper"</ref> This tool also has an option to export the data to the XMI format so it can be imported to
visual paradigm and other tools.


As Hot Draw is a framework, an application needs to be built that actually utilizes it. One such application is [http://www.jhotdraw.org/ JHotDraw], developed in part by [http://en.wikipedia.org/wiki/Erich_Gamma Erich Gamma] of "[http://en.wikipedia.org/wiki/Design_Patterns Gang of Four]" fame. Originally started as an exercise in design pattern best-practices, this piece of software allows one to effectively create and organize CRC, at least in a rudimentary sense. As seen above, rectangles (cards) can be created, and the required lines and text can be filled in. To effectively move and group cards, all of the individual components (lines, texts, drawings) must be group. The software allows for color customization, but overall the software specialized application toward the creation of CRC cards is quite limited.
===Rose CRC===
Rose CRC<ref name="rosecrc">Wilkinson, N. Using CRC Cards, "An Informal Approach to Object-Oriented Development," SIGS, New York, 1995.</ref> is a tool that supports CRC card processes at various levels. This tool is used to record responsibilities of classes, their collaborators, and also maintain superclass/subclass relationships. It provides an option of flipping the card to mention the attributes, description and any comments for that class. It also provides an option of selecting from existing classes and their responsibilities, collaborators and superclass/subclass relationships by a drop down menu. A detailed view of responsibilities can be provided in a separate window.


==Conclusion==
[[File:Rosecrc.PNG|300px|Rose CRC Tool]]
All the tools that we analyzed in this article were able to simulate the basic usage of physical CRC cards; their core functionality is highlighted in the table below. They provide the ability to record on each card the name, the responsibilities, and the collaborators of an object or class. Many tools also provide additional features often related to the context they work in. For example, some of these tools are part of larger CASE systems or suites and therefore they expose functionalities to interact with other tools of the suite. All the tools we tested were pretty easy to use and understand. In the table below, the features that the different tools provide are contrasted. However, one aspect that none of the tools can replicate is the human interaction of people playing scenarios with real CRC cards. This interaction is difficult to replicate with computer programs and is the main limitation as mentioned at the beginning of the article.
The tool provides an option of viewing the cards in various ways, such as single card, all cards, in a browser window, and grouped by sub systems. These views are connected and thus easily navigable. Hierarchy graphs are possible for any class.


==Conclusion <ref name="aa"/> <ref name="sd"/> ==
CRC cards are used to give a useful and convincing experience with objects and the mechanisms of objects but do not yet see their value. Using CRC cards, one can speculate the designs, ensure that they are concrete and establish an explicit relationship between objects. This makes it easier to understand, evaluate, and modify a design. One of the major problem for using this is the integration of the cards with larger design methodologies and with particular language environments. The need to retain the value of physical interaction points to the need for a new kind of user interface and programming environment as far beyond what we have today as our current systems are beyond the tool-oriented environments of the past.


{| class="wikitable" style="margin: 1em auto 1em auto"
{| class="wikitable" style="margin: 1em auto 1em auto"
|+ '''Tools feature comparison'''
|+ '''Tools feature comparison'''
! Feature || QuickCRC || VP UML || SIM || HD || Stickies
! Feature || QuickCRC || Visual Paradigm || Software Ideas Modeler|| CRC Design Assistant|| Stickies || EasyCRC Tool || Rose CRC
|- align="center"
|- align="center"
| Model scenarios || ✔ || || ✔ || ||
| Model scenarios || ✔ || || ✔ || ✔ ||  || ✔ || ✔
|- align="center"
|- align="center"
| Drag values from card to card || ✔ || || || ✔ ||  
| Drag values from card to card || ✔ || || || ✔ ||  ||  ||
|- align="center"
|- align="center"
| Generate UML class diagrams  || ✔ || ✔ || ✔ ||  ||
| Generate UML class diagrams  || ✔ || ✔ || ✔ || ✔ ||  || ✔ || ✔
|- align="center"
|- align="center"
| Handle subdiagrams || ✔ || ✔ || ✔ ||  ||
| Handle subdiagrams || ✔ || ✔ || ✔ || ✔ ||  || ✔ || ✔
|- align="center"
|- align="center"
| Generate Java code ||  || ✔ || ✔ ||  ||
| Generate Java code ||  || ✔ || ✔ ||  ||  ||  ||
|- align="center"
|- align="center"
| Collapse/expand cards || ✔ ||  || ||  || ✔
| Collapse/expand cards || ✔ ||  || || ✔ || ✔ ||  || ✔
|- align="center"
|- align="center"
| Display/hide parts of a card ||  || ✔ || ||  ||
| Display/hide parts of a card ||  || ✔ || ||  ||  ||  ||
|- align="center"
|- align="center"
| Export/import card diagrams to/from text files || ✔ || ✔ || ✔ || ||
| Export/import card diagrams to/from text files || ✔ || ✔ || ✔ || ✔ ||  || ✔ ||  
|- align="center"
|- align="center"
| Arrange cards based on different criteria || ✔ ||  || ✔ || || ✔
| Arrange cards based on different criteria || ✔ ||  || ✔ ||   || ✔ ||  || ✔
|- align="center"
|- align="center"
| Analyze text to extract classes, responsibilities and attributes || ✔ || ✔ || ✔ ||  ||
| Analyze text to extract classes, responsibilities and attributes || ✔ || ✔ || ✔ ||  ||  ||  ||
|- align="center"
|- align="center"
| Reverse engineer existing source code || ✔ || ✔ || ✔ ||  ||
| Reverse engineer existing source code || ✔ || ✔ || ✔ ||  ||  ||  ||
|}
|}


In the table above, the features that the different tools provide are contrasted. However, one aspect that none of the tools can replicate is the human interaction of people playing scenarios with real CRC cards. This interaction is difficult to replicate with computer programs and is the main limitation of software based CRC creation.
==Pros / Cons of CRC Cards<ref name="sd"/>==
===Advantages===
*'''The experts do the analysis:''' The people who understand the problem domain, the business domain experts (BDEs) are the people who create the model.<ref name="advantages">Scott W. Ambler (November 29, 1998), "CRC Modeling: Bridging the Communication Gap Between Developers and Users", An AmbySoft Inc. White Paper</ref>
*'''User participation increased:''' Users are actively involved in defining the model and thus increases their participation in understanding the system and creating it.
*'''Breaks down communication barriers:''' Users and developers work togther side-by-side to create the CRC model.<ref name="advantages" />
*'''Simple and Straightforward:''' CRC cards are easy to fill out and provide the essence of the system in a simple and straightforward manner.
*'''Prototyping:''' CRC modeling and prototyping are both iterative processes in which users are greatly involved.  It is very common to draw rough sketches of screens and reports during CRC modeling sessions.<ref name="advantages" />
*'''Transition:''' CRC cards eases the transition from process orientation to object orientation.


Overall, CRC cards came about in the 90s when computer scientists Beck and Cunningham felt that "the need to retain the value of physical interaction points to the need for a new kind of user interface and programming environment as far beyond what we have today."<ref name="beck"/> In the present day, there are new kinds of user interfaces and programming environments that could be used to retain the value of physical interaction. For example, a mobile application could be implemented that allows people to play CRC cards on their smartphones or tablets as they were playing with real cards. With the addition of live video/audio connections those people could also physically be in different places while playing the scenarios together. However, no solution that implements this functionality is currently known.
===Disadvantages===
*'''Inefficient for larger systems:''' For a larger system, there are many classes and maintaining all of them becomes difficult especially if there are many dependencies. Hence, CRC cards tend to prove inefficient and time consuming while modelling larger systems.
*'''Limited Details:''' CRC cards provide limited details about the software elicitation because of the high level abstraction.<ref name="disadvantages">Mr. Sham-Ul-Arif, Mr. Qadeem Khan, S. A. K. Gahyyur, "Requirements Engineering Processes, Tools/Technologies, & Methodologies, International Journal of Reviews in Computing, ISSN: 2076‐3328 http://www.ijric.org/volumes/Vol2/6Vol2.pdf</ref> 
*'''Hard to get users together:''' To schedule people for CRC modelling is difficult.
*'''Time consuming:'''  Creating many cards manually can be a time consuming process.


==See also==
==See also==


* [http://www.runrev.com/home/ Revolution]
* [http://en.wikipedia.org/wiki/Unified_Modeling_Language Unified Modeling Language]
* [http://pythoncard.sourceforge.net/ PythonCard]
* [http://en.wikipedia.org/wiki/Responsibility-driven_design Responsibility-driven Design]
* [http://www.supercard.us/supercard/index.html SuperCard]
* [http://en.wikipedia.org/wiki/Object-oriented_design Object-Oriented Design]
* [http://c2.com/cgi/wiki?HyperCard HyperCard] and the [http://finance.groups.yahoo.com/group/HyperCard/ HyperCard Group]
* [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_aa ECE/CSC 517 Fall 2011 (aa)]
* [http://www.metacard.com/ MetaCard] and the [http://tech.groups.yahoo.com/group/MC_IDE/ MetaCard Group]
* [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_sd ECE/CSC 517 Fall 2011 (sd)]
* [http://freecard.sourceforge.net/website/ FreeCard] and the [http://tech.groups.yahoo.com/group/freegui/ FreeCard Group]
* [http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_js ECE/CSC 517 Fall 2011 (js)]


==References==
==References==
<references/>
<references/>
==Further Reading==
* [http://www.informit.com/articles/article.aspx?p=1391208&seqNum=1 CRC Cards: An Agile Thinking Tool]
* [http://en.wikipedia.org/wiki/Class-responsibility-collaboration_card CRC cards on Wikipedia]
* [http://www.macosxtips.co.uk/index_files/10-tips-for-stickies.php Stickies on Mac]
* [http://windows.microsoft.com/en-US/windows7/products/features/sticky-notes Sticky Notes on Windows 7]


==External Links==
==External Links==
 
* [http://windows.microsoft.com/en-US/windows7/products/features/sticky-notes Sticky Notes]
* [http://www.visual-paradigm.com/solution/freeumltool/?src=google&kw=UML&mt=b&net=g&plc=&gclid=COLtxZ3w4asCFYEj7Aod7g1iNA Visual Paradigm for UML]
* [http://findfiles.com/14090/details-quickcrc-macosx.html QuickCRC]
* [http://www.excelsoftware.com/quickcrcdownload.html QuickCRC]
* [http://www.softwareideas.net/ Software Ideas Modeler]
* [http://www.visual-paradigm.com/ Visual Paradigm]
* [https://sites.google.com/site/easycrc/ Easy CRC]
* [http://www.softwareideas.net/en/Default.aspx Software Ideas Modeler]
* [http://www.softwareideas.net/en/Default.aspx Software Ideas Modeler]
* [http://st-www.cs.illinois.edu/users/brant/HotDraw/HotDraw.html Hot Draw], implemented as [http://www.jhotdraw.org/ JHotDraw]
* [http://www.openloop.com/education/classes/umn_98/umn_cpp/crc.htm Introduction to CRC Cards]
* [http://sourceforge.net/projects/crccardeditor/ CRC Card Editor] ''unfinished CRC card editing tool''
* [http://www.agilemodeling.com/artifacts/crcModel.htm CRC Models]
* [http://www.c-jump.com/CIT73/Week09/lecture.html#W09_0160_crc CRC: Class Responsibility Collaboration cards]
* [http://www.math-cs.gordon.edu/courses/cs211/ATMExample/CRCCards.html CRC Cards for ATM example]
* [http://www.excelsoftware.com/quickcrcwin.html QuickCRC Tool by Excel Software]

Latest revision as of 02:37, 25 February 2013

CRC <ref name="aa"> http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_aa </ref>

Class-Responsibility-Collaborator Cards (CRC) are a design and organization technique used to help discuss and outline object-oriented software. It was initially proposed by Kent Beck and Ward Cunningham in 1989 "to document collaborative design decisions." <ref name="beck">"A Laboratory For Teaching Object-Oriented Thinking" by Beck and Cunningham</ref> This technique is a way to outline classes, determine their responsibilities, and describe their relationships. CRC cards can be either physical (such as on index cards), or digital. In either case the information for each class is written/displayed on separate cards.<ref name="lecnotes">Lecture Notes</ref>


Introduction <ref name="aa"/> <ref name="sd"> http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_sd </ref>

A CRC card is commonly a notecard laid out in a particular fashion where one may define a class, its responsibilities, and collaborators (see figures below). A class refers to an object in the traditional object-oriented sense; responsibilities refers to the actions that the object must take and roles it must fill; and collaborators refers to the other objects with which the originally defined class must interact.<ref name="skrien">Skrien, Dale John. Object-oriented Design Using Java. Boston: McGraw-Hill Higher Education, 2009. Print.</ref> The class name of an object "creates a vocabulary for discussing a design," the responsibilities "identify problems to be solved," and collaborators are "objects which will send or be sent messages in the source satisfying responsibilities."<ref name="beck"/> For a complete set of CRC card content of an ATM system, refer to this example: CRC Cards for ATM Example.


Generic Template

Class name
Responsibilities Collaborators
Example

Background

Class-Responsibility-Collaborator cards are an evolution of use cases. Use cases would use "actors" and then define a "story" of their actions. The nouns and verbs in these stories would be leveraged in an effort to help determine the relevant classes and methods.<ref name="skrien"/> This method originally used 4"x6" index cards because they were "cheap, portable, readily available, and familiar."<ref name="beck"/>

Creating CRC Cards <ref name="sd"/>

  1. Identify and assign candidate classes
  2. Determine a set of specific scenarios
  3. Walk through the scenario, naming cards and responsibilities
  4. Write the main responsibility for each class
  5. Identify the responsibilities for each class 
  6. Identify one or more collaborators for each class

These index cards become your class diagram. In your class diagram, you create a class for each card that was used. The responsibilities on the card become the method of the class. All collaborators indicate that an association between the two classes must be drawn (and the class will need to have an instance of the collaborating classes). Finally, the data members on the back of the card become the attributes of the class.

Beck and Cunningham describe the designing process:<ref name="skrien"/>:

We start with only one or two obvious cards and start playing "what-if". If the situation calls for a responsibility not already covered by one of the objects we either add the responsibility to one of the objects, or create a new object to address that responsibility. If one of the object becomes too cluttered during this process we copy the information on its card to a new card, searching for more concise and powerful ways of saying what the object does. If it is not possible to shrink the information further, but the object is still too complex, we create a new object to assume some of the responsibilities. The goal of this exercise is to encourage designers to pick up the card whose role they are assuming while 'executing' a scenario and stress the importance of creating objects not to meet mythical future needs, but only under the demands of the moment. This ensures that a design contains only as much information as the designer has directly experienced, and avoids premature complexity.<ref name="beck"/>

Physical Arrangement
  • When cards overlap it can mean that the objects represented by the cards are collaborating
  • A card placed above another card can mean that the object it represents is supervising the object represented by the card below
  • Cards representing parts are usually placed below the card representing the whole
  • "Refinements of an abstraction can be collected and handled as a single pile of cards with the most abstract card on top where it can represent the rest" <ref name="beck"/>

Tools <ref name="aa"/><ref name="sd"/><ref name="js"> http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Fall_2011/ch4_4i_js </ref>

There are several CRC card tools available which are implemented in software. They help ease the creation of CRC cards when many are necessary or a digital format is preferred. A digital representation is easier to share, and modify in large numbers.


Stickies

Sticky Notes is a simplistic method to mimic physical CRC cards with software. It is available for Microsoft Windows 7 and Windows 8.

On Windows 7

QuickCRC

QuickCRC is a tool developed by Excel Software for responsibility driven design of object-oriented software using CRC cards. CRC cards are used to discover and document classes, responsibilities, attributes and collaborations between classes. Design scenarios can be identified and simulated. Complex designs can be partitioned into multiple diagrams with easy navigation through a contents view. The inheritance graph automatically shows the class structure of the evolving design. The user can assign the attribute access of each card responsibility and the tool presents an attribute access graph.<ref name="quickcrc1">QuickCRC Tool</ref> This tool is available for both Windows and Mac OS X.

QuickCRC Tool CRCs Card drawn using QuickCRC

The features of QuickCRC<ref name="quickcrc2">QuickCRC by Excel Software</ref> are:

  • Cards and scenario objects can be drawn in the diagram workspace. Each card has a class name, description, superclasses, subclasses, attributes, responsibilities and collaborating objects.
  • The card information is entered through a dialog or edit on-screen by dragging or renaming cards, attributes, responsibilities and collaborations.
  • Assign the attribute access of each card responsibility. Also shows an attribute access graph from the card information to help developers discover, refine and eliminate unnecessary card attributes.
  • Scenarios can reference cards or other scenarios.
  • Cut and paste cards and scenarios between diagrams or projects.
  • Allows a designer to navigate between diagrams shown as folder icons that can be opened or closed. A card or scenario can be dragged between diagrams or double-clicked to edit its properties making it easy to locate and modify information as the model grows.
  • Provides active simulation of an evolving design.
  • Maintains relationships between cards, scenarios and external agents as fluid design changes take place. If a card references undefined subclasses or superclasses, those cards are generated automatically.
  • Model other relationships between cards like aggregation and interface implementation.
  • Name changes and cross references between objects are instantly updated.
  • Has a rich search feature for locating design data within specific fields of any card or scenario in the project.

This software tool runs best on Windows XP, Vista or 7 with 1 GB RAM. The package includes both a Standard and Lite edition. The only difference between these two editions is the amount of data that a project can hold and the memory requirements of your machine.<ref name="quickcrc2" />


Software Ideas Modeler

Software Ideas Modeler is a lightweight and powerful CASE tool. It supports UML 2.2 diagrams. Software Ideas Modeler is freeware. <ref name="modeler">Software Ideas Modeler</ref>

A sample CRC card in Software Ideas Modeler


This tool is fairly simple to use and also allows the user to customize the card properties. It supports various types of automatic alignment for diagram elements. It supports standard functions such as as undo/redo and copy paste with the clipboard. Diagram elements can be styled (background color, text color, fonts, border), grouped, placed in layers. The tool also provides an additional feature of including the subclasses and superclass of the class in discussion. Every field value can be modified and renamed inline. This tool also provides a feature of customizing the text and style based on the class. An interesting feature of this tool is that one can attach comments to a CRC card and also link the comments along with the comments.

There is an export to raster image formats (BMP, GIF, JPG, PNG, TIFF), vector image formats (Windows Metafile, SVG) and PDF. There is also export to XML. There is an import from XML.<ref name="simwiki">Software Ideas Modeler - Wikipedia</ref> It also provides support for various languages. The diagrams can be exported to multiple image formats and vector formats like WMF, EMF, SVG and bitmap format PNG. It has support for source code generation for languages like C#, VB.NET, SQL DDL.

Visual Paradigm

Visual Paradigm for UML (VP-UML) is a UML CASE Tool supporting UML 2, SysML and Business Process Modeling Notation (BPMN) from the Object Management Group (OMG). In addition to modeling support, it provides report generation and code engineering capabilities including code generation. It can reverse engineer diagrams from code, and provide round-trip engineering for various programming languages.<ref name="visual">Visual Paradigm for UML</ref>

Visual Paradigm Tool with a sample CRC Card CRC Card with inline editing

Visual Paradigm for UML provides a CRC Card diagram for software team to brainstorm, records, analyze and maintain CRC cards in systematic and collaborative way. It allows easy addition of responsibilities to a class. Along with this, all fields on a CRC card can be edited inline. The CRC diagrams in the tool are not linked to the sequence diagrams. This tool can be integrated with Eclipse/IBM WebSphere, Borland, JBuilder, NetBeans IDE, IntelliJ IDEA, Oracle JDeveloper and BEA WebLogic Workshop to support the implementation phase of software development. The transitions from analysis to design and then to implementation are seamlessly integrated within the CASE tool, thus significantly reducing efforts in all stages of the software development lifecycle.<ref name="tools">Visual Paradigm</ref>

CRC Design Assistant

The CRC Design Assistant was first conceived to assist students in creating real-world software applications in the context of the software engineering course at UTEP. This tool helps in visualizing the design, tracking design changes, maintaining the list of system responsibilities when classes are removed, revising documentation when designs change, and presenting a design to other team members and observers.<ref name="design">Steve Roach, Department of Computer Science, University of Texas at El Paso, Javier C Vásquez, Department of Computer Science, University of Texas at El Paso, "A Tool to Support the CRC Design Method", October 2004</ref>

CRC Design Assistant Tool CRC Card View

The characteristics of this tool are:

  • Supports the CRC design method and assist students in creating, modifying, and documenting
  • Helps in creating object-oriented designs
  • Helps maintain a class hierarchy of the different classes (cards) that are created for a subsystem
  • Provides a drag and drop feature where the responsibilities could be selected and dragged in the subsystem or class list
  • Draws lines to indicate collaborator classes making it visually easy to understand and correlate
  • Supports a team environment and is accessible over the internet
  • Allows the ability to track changes made by each team member
  • Generates a design documentation in the form of RTF files and diagrams
  • Stores the entire design in a single database

The tool is fairly simple and easy to maintain.

EasyCRC Tool

The Easy CRC tool makes use of the .NET Framework. This tool divides the task of making CRC cards into two stages. The first stage is identifying the objects from a definition which is a plain text and then identifying the responsibilities and collaborators for the identified responsibilities by simulating scenarios through sequence diagrams.<ref name="easy">EasyCRC Tool</ref>

Easy CRC Tool

Editing the CRC cards using the CRC card editor can be done in different ways. One method is to enter all information manually - editing the different values through the property editor in the tool. Right-click the “CRC cards” node in the solution explorer; a sub menu will be displayed with an option to add an item to the sub tree below. In this manner the user can Assign Responsibilities, Add Attributes, Add Methods to responsibilities and set the different properties of the item. Another way is to create sequence diagrams and from them, the collaborators and responsibilities of the CRC cards would be discovered automatically.<ref name="easypaper">"Easy CRC Tool - Description Paper"</ref> This tool also has an option to export the data to the XMI format so it can be imported to visual paradigm and other tools.

Rose CRC

Rose CRC<ref name="rosecrc">Wilkinson, N. Using CRC Cards, "An Informal Approach to Object-Oriented Development," SIGS, New York, 1995.</ref> is a tool that supports CRC card processes at various levels. This tool is used to record responsibilities of classes, their collaborators, and also maintain superclass/subclass relationships. It provides an option of flipping the card to mention the attributes, description and any comments for that class. It also provides an option of selecting from existing classes and their responsibilities, collaborators and superclass/subclass relationships by a drop down menu. A detailed view of responsibilities can be provided in a separate window.

Rose CRC Tool

The tool provides an option of viewing the cards in various ways, such as single card, all cards, in a browser window, and grouped by sub systems. These views are connected and thus easily navigable. Hierarchy graphs are possible for any class.

Conclusion <ref name="aa"/> <ref name="sd"/>

CRC cards are used to give a useful and convincing experience with objects and the mechanisms of objects but do not yet see their value. Using CRC cards, one can speculate the designs, ensure that they are concrete and establish an explicit relationship between objects. This makes it easier to understand, evaluate, and modify a design. One of the major problem for using this is the integration of the cards with larger design methodologies and with particular language environments. The need to retain the value of physical interaction points to the need for a new kind of user interface and programming environment as far beyond what we have today as our current systems are beyond the tool-oriented environments of the past.

Tools feature comparison
Feature QuickCRC Visual Paradigm Software Ideas Modeler CRC Design Assistant Stickies EasyCRC Tool Rose CRC
Model scenarios ✔ ✔ ✔ ✔ ✔
Drag values from card to card ✔ ✔
Generate UML class diagrams ✔ ✔ ✔ ✔ ✔ ✔
Handle subdiagrams ✔ ✔ ✔ ✔ ✔ ✔
Generate Java code ✔ ✔
Collapse/expand cards ✔ ✔ ✔ ✔
Display/hide parts of a card ✔
Export/import card diagrams to/from text files ✔ ✔ ✔ ✔ ✔
Arrange cards based on different criteria ✔ ✔ ✔ ✔
Analyze text to extract classes, responsibilities and attributes ✔ ✔ ✔
Reverse engineer existing source code ✔ ✔ ✔

In the table above, the features that the different tools provide are contrasted. However, one aspect that none of the tools can replicate is the human interaction of people playing scenarios with real CRC cards. This interaction is difficult to replicate with computer programs and is the main limitation of software based CRC creation.

Pros / Cons of CRC Cards<ref name="sd"/>

Advantages

  • The experts do the analysis: The people who understand the problem domain, the business domain experts (BDEs) are the people who create the model.<ref name="advantages">Scott W. Ambler (November 29, 1998), "CRC Modeling: Bridging the Communication Gap Between Developers and Users", An AmbySoft Inc. White Paper</ref>
  • User participation increased: Users are actively involved in defining the model and thus increases their participation in understanding the system and creating it.
  • Breaks down communication barriers: Users and developers work togther side-by-side to create the CRC model.<ref name="advantages" />
  • Simple and Straightforward: CRC cards are easy to fill out and provide the essence of the system in a simple and straightforward manner.
  • Prototyping: CRC modeling and prototyping are both iterative processes in which users are greatly involved. It is very common to draw rough sketches of screens and reports during CRC modeling sessions.<ref name="advantages" />
  • Transition: CRC cards eases the transition from process orientation to object orientation.

Disadvantages

  • Inefficient for larger systems: For a larger system, there are many classes and maintaining all of them becomes difficult especially if there are many dependencies. Hence, CRC cards tend to prove inefficient and time consuming while modelling larger systems.
  • Limited Details: CRC cards provide limited details about the software elicitation because of the high level abstraction.<ref name="disadvantages">Mr. Sham-Ul-Arif, Mr. Qadeem Khan, S. A. K. Gahyyur, "Requirements Engineering Processes, Tools/Technologies, & Methodologies, International Journal of Reviews in Computing, ISSN: 2076‐3328 http://www.ijric.org/volumes/Vol2/6Vol2.pdf</ref>
  • Hard to get users together: To schedule people for CRC modelling is difficult.
  • Time consuming: Creating many cards manually can be a time consuming process.

See also

References

<references/>

External Links

Retrieved from "https://wiki.expertiza.ncsu.edu/index.php?title=CSC/ECE_517_Spring_2013/ch4b_1l_dh&oldid=73649"