{"id":809,"date":"2026-02-25T10:25:04","date_gmt":"2026-02-25T10:25:04","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/"},"modified":"2026-02-25T10:25:04","modified_gmt":"2026-02-25T10:25:04","slug":"legacy-modernization-dfd-uml","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/","title":{"rendered":"Legacy Modernization: DFD First, UML Second"},"content":{"rendered":"<p>Most teams attempting to modernize a legacy mainframe system begin by jumping straight into UML diagrams\u2014only to find themselves drowning in complexity, confusion, and misaligned stakeholder expectations. The root cause? They\u2019re treating a procedural data problem with an object-oriented lens before understanding the actual data flows.<\/p>\n<p>I\u2019ve seen this play out in financial institutions, healthcare providers, and government agencies. A team spent three months creating detailed class diagrams for a COBOL-based payroll system\u2014only to realize they had no idea how the data actually flowed through the batch jobs. That\u2019s the trap: UML excels at modeling behavior, but it can obscure the very data transformations that define legacy systems.<\/p>\n<p>My approach, forged over two decades of working on mainframe migrations, is simple: start with DFDs to map the as-is state. Then, once the data flow is clear, use UML to model the to-be architecture. This two-phase strategy isn\u2019t just a best practice\u2014it\u2019s the only way to ensure that business logic, data lineage, and system boundaries are properly understood before designing new microservices or cloud-native components.<\/p>\n<p>You\u2019ll learn how to reverse engineer mainframe logic using DFDs, identify key transformation points, and then translate procedural processes into object collaborations. This chapter delivers practical, field-tested methods for bridging the gap between legacy procedural systems and modern object-oriented architecture\u2014without over-engineering the journey.<\/p>\n<h2>Why DFD First? The Power of Procedural Clarity<\/h2>\n<p>Legacy systems\u2014especially COBOL-based mainframes\u2014are built on data transformation, not object interaction. They process batches, move data between files, and execute sequential logic. DFDs are the ideal tool to capture this, because they focus on how data moves, changes, and is stored.<\/p>\n<p>When I began a modernization project at a major insurance provider, the first task wasn\u2019t to create a single class diagram. It was to map the entire claims processing cycle using DFD Level 0 and Level 1. The result? A clear, shared understanding of how data entered the system, passed through underwriting, validation, and payment stages, and exited as processed claims.<\/p>\n<p>This procedural clarity is essential. UML use case diagrams may show \u201cProcess Claim,\u201d but they don\u2019t reveal how data is split, aggregated, or validated. DFDs do.<\/p>\n<h3>Reverse Engineering Mainframes with DFDs<\/h3>\n<p>Start with the data sources: files, databases, and external systems. Identify every input and output file (often named in COBOL as FD or SD sections). Then, map the processes that read, transform, and write them.<\/p>\n<p>Use this simple checklist for mainframe reverse engineering:<\/p>\n<ul>\n<li>Extract file definitions from COBOL COPYbooks and FD\/SD entries.<\/li>\n<li>Trace each paragraph (PROCEDURE DIVISION) to identify data transformation logic.<\/li>\n<li>Map each data flow between files and processes using DFD symbols.<\/li>\n<li>Group related processes into higher-level functions (e.g., \u201cRun Batch Daily\u201d).<\/li>\n<li>Validate with business analysts\u2014focus on data, not object roles.<\/li>\n<\/ul>\n<p>This is where DFDs shine: they don\u2019t care about inheritance or encapsulation. They care about data movement.<\/p>\n<h2>From Procedural to Object-Oriented: UML as the Transition Tool<\/h2>\n<p>Once the DFDs are complete and validated, it\u2019s time to shift to UML. The goal isn\u2019t to replace the DFD, but to use it as a foundation for designing a new architecture\u2014especially when migrating to microservices or object-oriented systems.<\/p>\n<p>Here\u2019s how the mapping works:<\/p>\n<ul>\n<li><strong>DFD Process<\/strong> \u2192 <strong>UML Use Case or Activity<\/strong> (represents a transformation step)<\/li>\n<li><strong>DFD Data Store<\/strong> \u2192 <strong>UML Class (with persistence)<\/strong> (represents stateful data)<\/li>\n<li><strong>DFD Data Flow<\/strong> \u2192 <strong>UML Message or Attribute<\/strong> (represents data transfer)<\/li>\n<\/ul>\n<p>For example, a DFD process \u201cValidate Claim Data\u201d can become a UML use case \u201cValidateClaim\u201d with a sequence diagram showing interaction between a ClaimValidator service and a database repository.<\/p>\n<h3>COBOL to Microservices Modeling: A Practical Example<\/h3>\n<p>Consider a legacy COBOL program that processes customer account adjustments. The DFD reveals three key flows:<\/p>\n<ul>\n<li>Input: Account Adjustment File (from batch job)<\/li>\n<li>Process: Validate, calculate, apply adjustments<\/li>\n<li>Output: Adjusted Account File, Audit Log<\/li>\n<\/ul>\n<p>From this, we can derive a microservice architecture:<\/p>\n<ul>\n<li>Service: AccountAdjustmentService (represents the process)<\/li>\n<li>Input: AdjustmentRequest (DTO from file)<\/li>\n<li>Output: AdjustmentResult (with audit trail)<\/li>\n<li>Storage: AccountAdjustmentLog (represents the data store)<\/li>\n<\/ul>\n<p>Now the procedural logic has a clear object-oriented equivalent. The DFD ensures we didn\u2019t miss any data transformations. The UML ensures we design a maintainable, testable service.<\/p>\n<h2>Mapping Challenges: Bridging the Paradigm Gap<\/h2>\n<p>Not every DFD process maps cleanly to a UML use case. Some transform data in ways that don\u2019t fit traditional object behavior. That\u2019s where flexibility matters.<\/p>\n<p>Common mapping issues include:<\/p>\n<ul>\n<li><strong>Batch-Only Processes<\/strong>: A DFD process that runs once daily and updates 100,000 records isn\u2019t a \u201cuse case\u201d in the traditional sense. It may be better modeled as a UML activity or a scheduled job in a deployment diagram.<\/li>\n<li><strong>Non-Object Data<\/strong>: Files with flat records (e.g., COBOL records with fixed-length fields) don\u2019t map well to classes. Use value objects or DTOs instead of full entity models.<\/li>\n<li><strong>Stateless Transformations<\/strong>: If a process doesn\u2019t maintain state, don\u2019t model it as a class. Instead, model it as a function or service that takes input and returns output.<\/li>\n<\/ul>\n<p>Remember: the goal is not to force UML into legacy patterns. It\u2019s to let the DFD guide the design and use UML only where it adds value.<\/p>\n<h2>Best Practices for Legacy Modernization: The DFD\u2013UML Workflow<\/h2>\n<p>Follow this proven pattern for successful migration:<\/p>\n<ol>\n<li>Begin with a DFD Level 0 (context diagram) to define system boundaries and major data flows.<\/li>\n<li>Break down the system into DFD Level 1 processes, mapping each batch or function.<\/li>\n<li>Validate the DFD with business stakeholders\u2014focus on data, not objects.<\/li>\n<li>Use the DFD to identify key data stores and transformation rules.<\/li>\n<li>Design the target architecture using UML: packages, components, and sequence diagrams.<\/li>\n<li>Ensure every DFD process maps to a UML behavior (use case, activity, or service).<\/li>\n<li>Use DFDs for audit and compliance documentation\u2014proven to be more effective than UML for data lineage.<\/li>\n<\/ol>\n<p>This workflow ensures that modernization isn\u2019t just about technology\u2014it\u2019s about understanding what the system actually does.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>Why not start with UML when modernizing a legacy system?<\/h3>\n<p>Because UML models are often built on assumptions about objects, behavior, and relationships. In legacy systems, these assumptions are rarely accurate. Starting with DFDs ensures you capture the actual data flow before introducing object abstractions.<\/p>\n<h3>How do I handle a mainframe process that has no clear data output?<\/h3>\n<p>Such processes are rare but possible (e.g., logging, cleanup). In those cases, treat the output as a data flow to an audit log or error file. Map it in the DFD as a data store, and later model it as a service that emits logs via a messaging queue.<\/p>\n<h3>Can I use UML to reverse engineer COBOL code directly?<\/h3>\n<p>UML tools can generate class diagrams from code, but they often misrepresent procedural logic. They may create classes for each COBOL paragraph or file, leading to bloated, unusable models. Always use DFDs first to understand the system before generating any UML.<\/p>\n<h3>What if my business team doesn\u2019t understand DFDs?<\/h3>\n<p>Start with a simple DFD Level 0 context diagram. Show it as a box with inputs and outputs. Use real data examples: \u201cThis system receives customer payment files and outputs processed invoices.\u201d Once they grasp the flow, they\u2019ll see how DFDs reflect their real-world work.<\/p>\n<h3>Is DFD still relevant in the age of microservices?<\/h3>\n<p>Yes. Microservices are built on data flows. A DFD helps you identify where data enters, how it changes, and where it exits. This is critical for designing service boundaries, ensuring data consistency, and creating audit trails.<\/p>\n<h3>How do I keep DFDs and UML models in sync during migration?<\/h3>\n<p>Use traceability matrices. Each DFD process should reference its corresponding UML use case or activity. In tools like Visual Paradigm, link DFD processes to UML elements using cross-references. Update both models together during changes.<\/p>\n<p>By following this DFD-first, UML-second approach, you\u2019re not just modernizing code\u2014you\u2019re building a clear, auditable, and maintainable blueprint for the future. The legacy system isn\u2019t just being replaced. It\u2019s being understood.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Most teams attempting to modernize a legacy mainframe s [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":804,"menu_order":4,"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-809","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>Legacy Modernization: DFD First, UML Second<\/title>\n<meta name=\"description\" content=\"Master the proven DFD-first, UML-second approach to legacy modernization. Learn how to reverse engineer mainframes, map procedural flows to microservices, and successfully migrate COBOL systems using structured analysis and object modeling.\" \/>\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\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/\" \/>\n<meta property=\"og:locale\" content=\"zh_CN\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Legacy Modernization: DFD First, UML Second\" \/>\n<meta property=\"og:description\" content=\"Master the proven DFD-first, UML-second approach to legacy modernization. Learn how to reverse engineer mainframes, map procedural flows to microservices, and successfully migrate COBOL systems using structured analysis and object modeling.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 \u5206\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/\",\"name\":\"Legacy Modernization: DFD First, UML Second\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#website\"},\"datePublished\":\"2026-02-25T10:25:04+00:00\",\"description\":\"Master the proven DFD-first, UML-second approach to legacy modernization. Learn how to reverse engineer mainframes, map procedural flows to microservices, and successfully migrate COBOL systems using structured analysis and object modeling.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/#breadcrumb\"},\"inLanguage\":\"zh-Hans\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/cn\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Data Flow Diagrams vs. UML: When to Use Each\",\"item\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Industry and Domain-Specific Guidance\",\"item\":\"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Legacy Modernization: DFD First, UML Second\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/cn\/\",\"name\":\"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/cn\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"zh-Hans\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#organization\",\"name\":\"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587\",\"url\":\"https:\/\/skills.visual-paradigm.com\/cn\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"zh-Hans\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/cn\/wp-content\/uploads\/sites\/3\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/cn\/wp-content\/uploads\/sites\/3\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/cn\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Legacy Modernization: DFD First, UML Second","description":"Master the proven DFD-first, UML-second approach to legacy modernization. Learn how to reverse engineer mainframes, map procedural flows to microservices, and successfully migrate COBOL systems using structured analysis and object modeling.","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\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/","og_locale":"zh_CN","og_type":"article","og_title":"Legacy Modernization: DFD First, UML Second","og_description":"Master the proven DFD-first, UML-second approach to legacy modernization. Learn how to reverse engineer mainframes, map procedural flows to microservices, and successfully migrate COBOL systems using structured analysis and object modeling.","og_url":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/","og_site_name":"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587","twitter_card":"summary_large_image","twitter_misc":{"\u9884\u8ba1\u9605\u8bfb\u65f6\u95f4":"7 \u5206"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/","url":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/","name":"Legacy Modernization: DFD First, UML Second","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/cn\/#website"},"datePublished":"2026-02-25T10:25:04+00:00","description":"Master the proven DFD-first, UML-second approach to legacy modernization. Learn how to reverse engineer mainframes, map procedural flows to microservices, and successfully migrate COBOL systems using structured analysis and object modeling.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/#breadcrumb"},"inLanguage":"zh-Hans","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/legacy-modernization-dfd-uml\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/cn\/"},{"@type":"ListItem","position":2,"name":"Data Flow Diagrams vs. UML: When to Use Each","item":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/"},{"@type":"ListItem","position":3,"name":"Industry and Domain-Specific Guidance","item":"https:\/\/skills.visual-paradigm.com\/cn\/docs\/dfd-vs-uml-when-to-use-each\/dfd-vs-uml-by-industry\/"},{"@type":"ListItem","position":4,"name":"Legacy Modernization: DFD First, UML Second"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/cn\/#website","url":"https:\/\/skills.visual-paradigm.com\/cn\/","name":"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/cn\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/cn\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"zh-Hans"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/cn\/#organization","name":"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587","url":"https:\/\/skills.visual-paradigm.com\/cn\/","logo":{"@type":"ImageObject","inLanguage":"zh-Hans","@id":"https:\/\/skills.visual-paradigm.com\/cn\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/cn\/wp-content\/uploads\/sites\/3\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/cn\/wp-content\/uploads\/sites\/3\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills \u7b80\u4f53\u4e2d\u6587"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/cn\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/docs\/809","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/docs\/809\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/docs\/804"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/media?parent=809"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/cn\/wp-json\/wp\/v2\/doc_tag?post=809"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}