We judge an object by how well its name suits its role and how well its role suits its situation. Stereotyping a candidate’s role provides a handy means for quickly creating an image about an object’s intended use. When you find a candidate, name it and then characterize it as fitting one or more stereotypes. Each candidate could be a service provider, controller, coordinator, structurer, information holder, or interfacer. To be even more specific, you may want to distinguish between three different types of interfacers: user interfacers (objects that interface with users), external interfacers (objects that interface between your application and others) or intersystem interfacers (objects that bridge different parts of an application).
To be more explicit with your intentions, you can distinguish whether an object is designed to be passive and just hold on to related information (an information holder), or whether you expect it take a more active role in managing and maintaining that information (an information provider). If these finer distinctions seem too subtle, don’t fret about them. Don’t worry about giving an object the “right” stereotype. If your application is populated with objects that don’t seem to fit these predefined stereotypes, come up with your own stereotypes. Stereotyping is intended to help get you started thinking about your candidates, not to bog you down.
If you aren’t sure about the role your candidate will play, make an educated guess. Use its stereotype as a guide to build a simple definition. In that definition, explain what your candidate might do and list any traits that distinguish it from others. Write this brief definition on the unlined side of a CRC card (see Figure 3-1).
Figure 3-1. The unlined side of a CRC card is used to describe an object’s purpose and stereotypes. In this case, a RazzmaFrazzer has only one stereotype.
More generally, a pattern to follow when describing an object is as follows:
An object is a type of thing that does and knows certain things. Briefly, say what those things are. Then mention one or more interesting facts about the object, perhaps a detail about what it does or knows or who it works with, just to provide more context.
Service providers, controllers, and coordinators are distinguished by what they do. Here’s a simple way to describe these stereotypes:
A service provider (or controller or coordinator) is some kind of thing that does some kind of work. Briefly, describe this work. Then mention something about what is important or interesting about the work it performs or whom it interacts with.
If you are working on your own, you may feel less of an urge to write down these thoughts. After all, you know what you mean! Even so, it still can be helpful to jot down an abbreviated thought. You don’t want to forget what was so important about that darned RazzmaFrazzer by next Friday. Similarly, if you are working in a team, others likely won’t know what’s important about a candidate unless you tell them. Any description you can write about a candidate’s purpose and what you expect it to do will help.
Consider this definition:
A compiler is “a program that translates source code into machine language.”
Contrast it with this slightly abbreviated definition:
“A compiler translates source code into machine language.”
The two definitions are nearly identical. The first adds that a compiler is a software program. This seems nit-picky—as software designers, we all know that compilers are programs. But the first definition provides just enough context so that someone not on our same wavelength can relate a compiler to other computer programs. Whenever you can relate something to a widely understood concept (such as a computer program), its meaning will be clearer to all.
If you and your fellow designers eat, sleep, and breathe design 24 hours a day, a lot may remain unspoken and unwritten. You understand one another because you think alike. However, if there’s ever a question or disagreement about what a candidate is, it could be that you are making different assumptions. To make intentions clear, add enough detail to remove any doubt; then expect to have a discussion about whose ideas are better. Describe both what a candidate is and what it is not. Relate it to what’s familiar.
We provide even more context by giving examples of how a candidate will be used and a general discussion of its duties. This is particularly important when you are describing a role that can be assumed and extended by several different objects.
A FinancialTransaction represents a single accounting transaction performed by our online banking application. Successful transactions result in updates to a customer’s accounts. Specific FinancialTransactions communicate with the banking systems to perform the actual work. Examples are FundsTransferTransaction and MakePaymentTransaction.
If a common meaning suits a candidate, use it to form a basic definition. Don’t invent jargon for invention’s sake. In the case of alternative definitions, choose one that most closely matches your application’s themes. Start with a standard meaning, if it fits. Then describe what makes that object unique within your application.
The American Heritage Dictionary has six definitions for account:
A narrative or record of events
A reason given for a particular action
A formal banking, brokerage, or business relationship established to provide for regular services, dealings, and other financial transactions
A precise list or enumeration of financial transactions
Money deposited for checking, savings, or brokerage use
A customer having a business or credit relationship with a firm
It isn’t too much of a stretch to conceive of different candidates that reflect each of these definitions. In our online banking application, accounts most likely represent money (definition 5). Rules that govern access to and use of funds are important. Different types of accounts have different rules. Although it is conceivable that an account could also be “a precise list of financial transactions” (definition 4), we reject that usage as being too far off the mark. People in the banking business think about accounts as money, assets, or liabilities and not as a list of transactions. In the same fashion, we reject definition 6. It doesn’t specifically mention assets. We easily reject definitions 1 and 2 as describing something very different from our notion of accounts in banking. In banking, accounts represent money. We choose definition 5 because it is the most central concept to the world of banking:
An account is a record of money deposited at the bank for checking, savings, or other purposes.
Add application-specific facts to generic definitions. The preceding definition is OK, but it is too general for online banking. In the online banking application, users can perform certain transactions and view their balances and transaction histories. We add these application specifics to our original description:
An account is a record of money deposited at the bank for checking, savings, or other purposes. In the online banking system customers can access accounts to transfer funds, view account balances and transaction historical data, or make payments. A customer may have several bank accounts.
The more focused a candidate is, the better. Of course, a candidate may be suited to more than one use. Objects can be designed to fit into more than one application. A framework operates in many different contexts. A utilitarian object can be used in many cases. If you want your candidate to have a broader use, make this intent clear by writing the expected usage on the CRC card.
Distinguish candidates by how they behave in your application. If distinctions seem blurry in the world outside your software, it is especially important to clarify your software objects’ roles. Even if you can distinguish between a customer and an account, you still need to decide whether it is worth having two candidates or to have one merged idea. (Don’t expect the business experts to help make this decision. It is a purely “technical” modeling one.) A candidate that reflects something meaningful in the world outside your application’s borders may not be valuable to your design.
Let’s look at the sixth definition of account:
“An account is a customer having a business or credit relationship with a firm.”
What is the difference between a customer and an account? Are they the same? If we had chosen this definition, would we need both customer and account objects in our banking application?
When you discover overlapping candidates, refine their roles and make distinctions. Discard a candidate or merge it with another when its purpose seems too narrow (and could easily be subsumed by another candidate). When in doubt, keep both.
For both Customer and Account to survive candidacy and stick in a design, their roles must be distinct and add value to the application. We could conceive of a Customer as a structurer that manages one or more Account objects. And, in the online banking application, one or more users can be associated with a Customer. For example, the customer “Joe’s Trucking” might have four authorized users, each with different privileges and access rights to different accounts. Another option would be to give an Account responsibility for knowing the customer and users. We could then eliminate Customer. We decide to include both Customer and Account in our design because giving those responsibilities to Account objects doesn’t seem appropriate—we can envision customers and users sticking around even when their accounts are closed (and perhaps new accounts are opened). So customers are somewhat independent of accounts.
During exploratory design, expect a certain degree of ambiguity. You can always weed out undistinguished candidates when you find they don’t add any value. Put question marks by candidates that need more definition. A candidate is just that—a potential contributor.