{"id":938,"date":"2026-02-25T10:32:32","date_gmt":"2026-02-25T10:32:32","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/"},"modified":"2026-02-25T10:32:32","modified_gmt":"2026-02-25T10:32:32","slug":"crc-collaboration-mapping-uml-associations-dependencies","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/","title":{"rendered":"Modeling Collaborations as Associations and Dependencies"},"content":{"rendered":"<p>Most beginners start with UML diagrams as if they\u2019re the first step in design. But that\u2019s a misunderstanding. The real beginning lies in CRC cards\u2014simple, collaborative, and deeply rooted in team discussion. UML is not a starting tool; it\u2019s a documentation language. When you rush into formal notation too early, you risk losing the shared understanding CRC fosters. The moment you start drawing lines and arrows without a firm grasp of who does what, you\u2019re modeling form, not function.<\/p>\n<p>My advice? Let CRC cards lead. They\u2019re not just sticky notes with responsibilities\u2014they\u2019re conversations captured in real time. Once your team has explored roles, interactions, and responsibilities, you\u2019re ready to translate those insights into structure. This chapter guides you through the critical step: turning CRC collaborations into precise UML associations and dependencies. You\u2019ll learn how to interpret intent, assign cardinality, and decide when a link is a dependency instead of a full association. It\u2019s not about rules\u2014it\u2019s about patterns, clarity, and consistency.<\/p>\n<h2>From Collaboration to Connection: Understanding the Intent<\/h2>\n<p>Every CRC collaboration is a promise: \u201cThis class needs to work with that one.\u201d But not all promises are equal. Some are strong, persistent relationships\u2014like a <code>Customer<\/code> owning <code>Orders<\/code>. Others are fleeting, task-based\u2014like a <code>PaymentProcessor<\/code> calling a <code>BankService<\/code> during checkout.<\/p>\n<p>These distinctions are where your skill as a designer shines. The key is to ask: Is this relationship essential for the class\u2019s identity? If yes, it\u2019s likely an association. If it\u2019s temporary or conditional, it might be a dependency.<\/p>\n<ul>\n<li>Ask: Does the class need to hold a reference to the other?<\/li>\n<li>Ask: Is the relationship stable across multiple operations?<\/li>\n<li>Ask: Would the class fail if the other object disappeared?<\/li>\n<\/ul>\n<p>If two or more of these questions are yes, proceed to model as an association. If only one or none, consider a dependency.<\/p>\n<h3>Recognizing the Difference: Association vs. Dependency<\/h3>\n<p>Confusion often arises between these two. Let me clarify with a concrete example: in a banking system, a <code>LoanApplication<\/code> class may <strong>use<\/strong> a <code>CreditScoreService<\/code> to check eligibility. That\u2019s not ownership\u2014it\u2019s a short-term need. This is a <strong>dependency<\/strong>.<\/p>\n<p>But if <code>Customer<\/code> has a list of <code>Accounts<\/code>, and those accounts are part of the customer\u2019s state, that\u2019s a full <strong>association<\/strong>. The customer is responsible for the life cycle of its accounts.<\/p>\n<p>Use this decision tree:<\/p>\n<ol>\n<li>Does the class hold a reference to the other? \u2192 Association<\/li>\n<li>Is the relationship only for a single method call? \u2192 Dependency<\/li>\n<li>Is it optional or temporary? \u2192 Dependency<\/li>\n<li>Is it part of the class\u2019s state? \u2192 Association<\/li>\n<\/ol>\n<p>When in doubt, ask: &#8220;Would this class make sense without the other?&#8221; If yes, it\u2019s likely a dependency. If no, it\u2019s an association.<\/p>\n<h2>Modeling Associations: Cardinality, Navigation, and Roles<\/h2>\n<p>Once you confirm an association, the next step is precision. UML isn\u2019t just about lines\u2014it\u2019s about meaning. Each end of the line carries cardinality, role name, and navigation direction.<\/p>\n<p>Naming roles clearly is critical. Instead of just \u201cCustomer\u201d and \u201cOrder,\u201d use \u201c<em>has<\/em>\u201d or \u201c<em>manages<\/em>\u201d to clarify intent. For example:<\/p>\n<ul>\n<li><code>Customer<\/code> \u2014 <em>has<\/em> <code>Order<\/code><\/li>\n<li><code>Order<\/code> \u2014 <em>contains<\/em> <code>LineItem<\/code><\/li>\n<\/ul>\n<p>Cardinality defines how many instances can exist at each end. Here\u2019s a quick guide to common patterns:<\/p>\n<table>\n<tbody>\n<tr>\n<th>Cardinality<\/th>\n<th>Meaning<\/th>\n<th>Example<\/th>\n<\/tr>\n<tr>\n<td>1<\/td>\n<td>Exactly one<\/td>\n<td>Each <code>Order<\/code> has exactly one <code>Customer<\/code><\/td>\n<\/tr>\n<tr>\n<td>0..1<\/td>\n<td>Zero or one<\/td>\n<td>A <code>Loan<\/code> may have a <code>Guarantor<\/code><\/td>\n<\/tr>\n<tr>\n<td>1..*<\/td>\n<td>One or more<\/td>\n<td>A <code>Customer<\/code> has at least one <code>Order<\/code><\/td>\n<\/tr>\n<tr>\n<td>0..*<\/td>\n<td>Zero or more<\/td>\n<td>A <code>Product<\/code> can be in zero or more <code>Orders<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Navigation direction\u2014indicated by an arrow\u2014tells you which class owns the reference. If <code>Customer<\/code> has a list of <code>Orders<\/code>, the arrow points from <code>Customer<\/code> to <code>Order<\/code>. If <code>Order<\/code> has a reference to <code>Customer<\/code>, the arrow goes the other way.<\/p>\n<p>Always validate: Can the relationship be traversed in both directions? If not, mark it accordingly. Don\u2019t assume bidirectional navigation unless it\u2019s truly needed.<\/p>\n<h2>Modeling Dependencies: The Invisible but Essential Links<!--2--><\/p>\n<p>Dependencies are the \u201cI use you\u201d relationships. They\u2019re not part of a class\u2019s state but are critical for behavior. The most common forms are:<\/p>\n<ul>\n<li>Method parameters<\/li>\n<li>Return types<\/li>\n<li>Local variables<\/li>\n<li>Class instantiation<\/li>\n<\/ul>\n<p>For example, if a <code>ReportGenerator<\/code> uses a <code>DatabaseConnection<\/code> object only within one method, that\u2019s a dependency. It doesn\u2019t own the connection\u2014just uses it temporarily.<\/p>\n<p>UML represents dependencies with a dashed line and an arrowhead. The arrow points from the dependent to the supplier.<\/p>\n<pre><code>ReportGenerator --&gt; DatabaseConnection\n<\/code><\/pre>\n<p>When modeling dependencies, be concise. Don\u2019t overuse them. If you find yourself drawing too many dashed lines, ask: \u201cIs this really a temporary need, or am I missing a deeper association?\u201d<\/p>\n<p>Here\u2019s a checklist for when to use a dependency:<\/p>\n<ul>\n<li>The relationship exists only within a single method<\/li>\n<li>The object is created on the fly<\/li>\n<li>The relationship is optional or conditional<\/li>\n<li>One class is passed in as a parameter or return value<\/li>\n<\/ul>\n<p>If all apply, a dependency is correct. If not, reconsider whether an association is more appropriate.<\/p>\n<\/h2>\n<h2>Practical Tips: Avoiding Common Pitfalls<\/h2>\n<p>I\u2019ve seen teams overuse associations\u2014every class connected to every other. That creates a tangled web that\u2019s impossible to maintain. The key is to ask: \u201cDoes this relationship reflect real behavior, or just convenience?\u201d<\/p>\n<p>Here are three pitfalls to avoid:<\/p>\n<ol>\n<li><strong>Over-associating:<\/strong> Don\u2019t model every relationship as an association. If it\u2019s not part of the class\u2019s state or responsibility, it\u2019s likely a dependency.<\/li>\n<li><strong>Ignoring navigation:<\/strong> Always decide direction. A <code>Student<\/code> enrolling in a <code>Course<\/code> doesn\u2019t mean the course owns the student. Navigation affects code generation and maintenance.<\/li>\n<li><strong>Confusing dependency with inheritance:<\/strong> Inheritance implies \u201cis-a,\u201d while dependency implies \u201cuses.\u201d Never confuse a <code>Car<\/code> using a <code>Engine<\/code> with a <code>Car<\/code> being an <code>Engine<\/code>.<\/li>\n<\/ol>\n<p>Remember: clarity beats completeness. A clean, simple model is better than a complex one that no one can read.<\/p>\n<h2>From CRC to UML: A Real-World Example<\/h2>\n<p>Let\u2019s say your team modeled a simple inventory system using CRC cards. One card says:<\/p>\n<ul>\n<li><strong>Class:<\/strong> <code>InventoryManager<\/code><\/li>\n<li><strong>Responsibility:<\/strong> Update stock levels based on order<\/li>\n<li><strong>Collaboration:<\/strong> Works with <code>Order<\/code> and <code>Product<\/code><\/li>\n<\/ul>\n<p>Now, analyze the collaborations.<\/p>\n<p>First, <code>InventoryManager<\/code> and <code>Order<\/code>: The manager updates stock after an order is placed. The manager doesn\u2019t store orders, but it needs to access order data. This is a <strong>dependency<\/strong>. The manager uses the order to calculate stock changes.<\/p>\n<p>Second, <code>InventoryManager<\/code> and <code>Product<\/code>: The manager modifies product stock levels. It may maintain a list of products or access them via a repository. If the manager holds or manages products, this is an <strong>association<\/strong>.<\/p>\n<p>So the correct mapping:<\/p>\n<ul>\n<li><code>InventoryManager<\/code> \u2014 <em>uses<\/em> <code>Order<\/code> \u2192 dependency<\/li>\n<li><code>InventoryManager<\/code> \u2014 <em>manages<\/em> <code>Product<\/code> \u2192 association<\/li>\n<\/ul>\n<p>Cardinality: <code>InventoryManager<\/code> manages 0..* <code>Products<\/code>. A <code>Product<\/code> can be managed by exactly one <code>InventoryManager<\/code>.<\/p>\n<p>Now you\u2019ve translated CRC collaboration into precise UML.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>What\u2019s the best way to determine whether a CRC collaboration should be an association or dependency?<\/h3>\n<p>Ask: \u201cWould this class still function without the other object?\u201d If yes, it\u2019s likely a dependency. If no, and it holds a reference or manages the object, it\u2019s an association. Focus on state and ownership, not just interaction.<\/p>\n<h3>Can a class have both associations and dependencies with the same partner?<\/h3>\n<p>Yes. A class might hold a reference to another (association) but still need to call a method on it in a temporary way (dependency). For example, a <code>CustomerService<\/code> may maintain a list of <code>Customers<\/code> (association) but use a <code>NotificationService<\/code> only during a specific operation (dependency).<\/p>\n<h3>How do I choose the cardinality in a UML association?<\/h3>\n<p>Base it on real-world constraints. Ask: \u201cHow many instances can exist at each end?\u201d Use 0..1 for optional, 1 for mandatory, and 0..* or 1..* for collections. Never guess\u2014validate with your domain experts.<\/p>\n<h3>What if I\u2019m not sure about navigation direction?<\/h3>\n<p>Ask: \u201cWhich class is responsible for the relationship?\u201d The class that owns or controls the reference should be the source. If a <code>Teacher<\/code> assigns a <code>Class<\/code>, the class doesn\u2019t own the teacher\u2014so the arrow points from <code>Class<\/code> to <code>Teacher<\/code>.<\/p>\n<h3>How does CRC collaboration mapping improve team communication?<\/h3>\n<p>CRC cards force shared understanding through discussion. When you map collaborations to UML, you\u2019re not just drawing diagrams\u2014you\u2019re validating team consensus. It reduces miscommunication and ensures that every team member sees the same structure.<\/p>\n<h3>Can I use CRC collaboration mapping in agile environments?<\/h3>\n<p>Absolutely. CRC cards are ideal for sprint planning and refinement. Use them to explore interactions before writing code. Then map to UML during design reviews. It\u2019s a lightweight, repeatable workflow that scales well with agile teams.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Most beginners start with UML diagrams as if they\u2019re the first step in design. But that\u2019s a misunderstanding. The real beginning lies in CRC cards\u2014simple, collaborative, and deeply rooted in team discussion. UML is not a starting tool; it\u2019s a documentation language. When you rush into formal notation too early, you risk losing the shared [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":935,"menu_order":2,"template":"","meta":{"_acf_changed":false,"inline_featured_image":false,"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"doc_tag":[],"class_list":["post-938","docs","type-docs","status-publish","hentry"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.2 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>CRC Collaboration Mapping: UML Associations &amp; Dependencies<\/title>\n<meta name=\"description\" content=\"Master CRC collaboration mapping by converting CRC cards to UML associations and dependencies. Learn cardinality, navigation, and relationship semantics with real-world examples and best practices for clean, maintainable designs.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/\" \/>\n<meta property=\"og:locale\" content=\"id_ID\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"CRC Collaboration Mapping: UML Associations &amp; Dependencies\" \/>\n<meta property=\"og:description\" content=\"Master CRC collaboration mapping by converting CRC cards to UML associations and dependencies. Learn cardinality, navigation, and relationship semantics with real-world examples and best practices for clean, maintainable designs.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Indonesia\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Estimasi waktu membaca\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 menit\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/\",\"name\":\"CRC Collaboration Mapping: UML Associations & Dependencies\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#website\"},\"datePublished\":\"2026-02-25T10:32:32+00:00\",\"description\":\"Master CRC collaboration mapping by converting CRC cards to UML associations and dependencies. Learn cardinality, navigation, and relationship semantics with real-world examples and best practices for clean, maintainable designs.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/#breadcrumb\"},\"inLanguage\":\"id\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/id\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"From CRC Cards to Class Diagrams\",\"item\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Mapping CRC Elements to Class Diagram Components\",\"item\":\"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Modeling Collaborations as Associations and Dependencies\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/id\/\",\"name\":\"Visual Paradigm Skills Indonesia\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/id\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"id\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#organization\",\"name\":\"Visual Paradigm Skills Indonesia\",\"url\":\"https:\/\/skills.visual-paradigm.com\/id\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"id\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/id\/wp-content\/uploads\/sites\/7\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/id\/wp-content\/uploads\/sites\/7\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Indonesia\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/id\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"CRC Collaboration Mapping: UML Associations & Dependencies","description":"Master CRC collaboration mapping by converting CRC cards to UML associations and dependencies. Learn cardinality, navigation, and relationship semantics with real-world examples and best practices for clean, maintainable designs.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/","og_locale":"id_ID","og_type":"article","og_title":"CRC Collaboration Mapping: UML Associations & Dependencies","og_description":"Master CRC collaboration mapping by converting CRC cards to UML associations and dependencies. Learn cardinality, navigation, and relationship semantics with real-world examples and best practices for clean, maintainable designs.","og_url":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/","og_site_name":"Visual Paradigm Skills Indonesia","twitter_card":"summary_large_image","twitter_misc":{"Estimasi waktu membaca":"7 menit"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/","url":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/","name":"CRC Collaboration Mapping: UML Associations & Dependencies","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/#website"},"datePublished":"2026-02-25T10:32:32+00:00","description":"Master CRC collaboration mapping by converting CRC cards to UML associations and dependencies. Learn cardinality, navigation, and relationship semantics with real-world examples and best practices for clean, maintainable designs.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/#breadcrumb"},"inLanguage":"id","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/crc-collaboration-mapping-uml-associations-dependencies\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/id\/"},{"@type":"ListItem","position":2,"name":"From CRC Cards to Class Diagrams","item":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/"},{"@type":"ListItem","position":3,"name":"Mapping CRC Elements to Class Diagram Components","item":"https:\/\/skills.visual-paradigm.com\/id\/docs\/crc-cards-to-class-diagrams\/crc-to-uml-mapping\/"},{"@type":"ListItem","position":4,"name":"Modeling Collaborations as Associations and Dependencies"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/id\/#website","url":"https:\/\/skills.visual-paradigm.com\/id\/","name":"Visual Paradigm Skills Indonesia","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/id\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"id"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/id\/#organization","name":"Visual Paradigm Skills Indonesia","url":"https:\/\/skills.visual-paradigm.com\/id\/","logo":{"@type":"ImageObject","inLanguage":"id","@id":"https:\/\/skills.visual-paradigm.com\/id\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/id\/wp-content\/uploads\/sites\/7\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/id\/wp-content\/uploads\/sites\/7\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Indonesia"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/id\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/docs\/938","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/docs\/938\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/docs\/935"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/media?parent=938"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/id\/wp-json\/wp\/v2\/doc_tag?post=938"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}