{"id":411,"date":"2017-09-26T08:24:27","date_gmt":"2017-09-26T15:24:27","guid":{"rendered":"http:\/\/blog.submain.com\/?p=411"},"modified":"2018-04-27T15:08:09","modified_gmt":"2018-04-27T22:08:09","slug":"code-documentation-code-comments","status":"publish","type":"post","link":"https:\/\/blog.submain.com\/code-documentation-code-comments\/","title":{"rendered":"Code Documentation and Code Comments Aren?t the Same Thing"},"content":{"rendered":"<p>Often, you hear &#8220;code comments&#8221; and &#8220;code documentation&#8221; used at least somewhat interchangeably. ?Perhaps the idea of code documentation has a little more formalism to it, in passing. ?And code comments may cover a bit less ground.<\/p>\n<p>But still, I hear the terms serve as synonyms for one another. ?And I hear this in particular when it comes to <a href=\"https:\/\/www.w3schools.com\/TAGs\/tag_comment.asp\">the actual construct of code comments<\/a> &#8212; meaning, literally, the feature of compilers and interpreters that allows you to say, &#8220;Disregard everything after these two slashes. I&#8217;m editorializing for the benefit of other humans.&#8221; ?&#8221;Comment your code&#8221; and &#8220;document your code&#8221; offer the same mandate.<\/p>\n<p>But I find that problematic. ?And it&#8217;s not just because I&#8217;m some kind of stickler for semantics. ?I think this causes us to have weird arguments, sometimes nonsensical and sometimes unnecessary.<\/p>\n<h3>Code Documentation vs Code Comments<\/h3>\n<p>To explain myself and my reasoning, I&#8217;ll offer definitions for both terms.<\/p>\n<ul>\n<li>Code comments: any meta text you put in source code.<\/li>\n<li>Code documentation: creating a conceptual maintenance manual for your source code (in <a href=\"https:\/\/www.merriam-webster.com\/dictionary\/documentation\">the dictionary sense of documentation<\/a>).<\/li>\n<\/ul>\n<p>Having established that, let me stave off some possible objections. ?First, you might ask, &#8220;Isn&#8217;t the entire point of code comments to help create that user manual?&#8221; ?In theory, maybe. ?But in practice, <a href=\"http:\/\/fuzzzyblog.blogspot.com\/2014\/09\/40-most-funny-code-comments.html\">come on, you know better<\/a>. ? People use comments to add legal boilerplate, express themselves with ASCII art, try their hand at comedy, and probably even to gossip.<\/p>\n<p>Secondly, maybe you&#8217;re someone that concedes that people do use comments this way, but you say that it&#8217;s abuse. ?In other words, sure, that happens &#8212; but it shouldn&#8217;t. ?If people did code comments right, they would all constitute code documentation. ?But I would still argue against this idea. ?Code comments can represent note-taking. ?&#8221;Note to self&#8221; and &#8220;note for later&#8221; both count.<\/p>\n<p>So let&#8217;s create a relationship definition. ?Code documentation means creating a maintenance manual for your code, and that manual may or may not use the code comment as a medium.<\/p>\n<p>I&#8217;ll also say that I think you should <em>document<\/em> your code, but it doesn&#8217;t matter terribly if you <em>comment<\/em> it.<\/p>\n<p><!--more--><\/p>\n<h3>Code Comment Origin Story<\/h3>\n<p>To understand why I make this distinction, let&#8217;s take a look at the <a href=\"http:\/\/www.gavilan.edu\/csis\/languages\/comments.html\">history of the code comment<\/a>. ?In early programming languages, you would write language instructions and then comments, often denoted with keywords such as REM (for REMarks) or the word &#8220;comment&#8221; itself.<\/p>\n<p>In early languages, these comments tended to play a more vital role in understanding than they might now. ?Disk space came at a premium, so people used terse variable names. ?Many of these languages featured jump instructions and constructs like &#8220;goto,&#8221; giving rise to <a href=\"https:\/\/en.wikipedia.org\/wiki\/Spaghetti_code\">the &#8220;spaghetti code&#8221; pejorative<\/a>. ?In short, you&#8217;d be relatively hard pressed to understand code without explanatory comments.<\/p>\n<p>Back then, programs tended to be less sprawling in terms of line of code. ?They also tended to be harder to read in and of themselves. ?So inline comments filled in the contextual blanks. ?They served as almost a part of the code.<\/p>\n<p>But over the years, languages evolved and moved to higher levels of abstraction. ?Structured programming and then object-oriented programming gained mindshare, and we also had steadily more disk space. ?This allowed software developers to create more and more expressive and organized code. ?Techniques like <a href=\"http:\/\/jakewharton.com\/just-say-no-to-hungarian-notation\/\">Hungarian notation<\/a> fell by the wayside.<\/p>\n<p>And the occasional inline code comment went from vital to&#8230;something else. ?I&#8217;ve already offered <a href=\"https:\/\/blog.submain.com\/comments-in-clean-code-think-documentation\/\">my take on the inline comment<\/a>, so I won&#8217;t do so here. ?But I think we can all agree that the ratio of comment to code characters necessary has decreased over the years.<\/p>\n<h3>The Evolution of Code Comments<\/h3>\n<p>There&#8217;s no doubt that this sort of thing has declined in our code over the years:<\/p>\n<pre class=\"lang:default decode:true\">x++; \/\/x is the number of orders -- increase it here at the end of the loop<\/pre>\n<p>We could just rename <em>x<\/em> to &#8220;orders&#8221; and extract the loop contents into a method to eliminate the need for scope reminders, not to mention that modern IDEs help us with these things anyway. ?Comments that might have proved invaluable 40 years ago just clutter our editors now.<\/p>\n<p>But that doesn&#8217;t mean, over the years, that the code comment lay idle. ?Far from it. ?Instead, it has emerged as a sort of data.<\/p>\n<p>As time moved forward, people got more and more formal with comments in code. ?<a href=\"http:\/\/pages.cs.wisc.edu\/~cs302\/resources\/guides\/commenting.html\">Techniques like this emerged<\/a>:<\/p>\n<pre class=\"lang:c decode:true\">\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/                   ALL STUDENTS COMPLETE THESE SECTIONS\n\/\/ Title:            (program's title)\n\/\/ Files:            (list of source files)\n\/\/ Semester:         (course)\n\/\/\n\/\/ Author:           (your name)\n\/\/ Email:            (your email address)\n\/\/ CS Login:         (your login name)\n\/\/ Lecturer's Name:  (name of your lecturer)\n\/\/ Lab Section:      (your lab section number)\n\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/ PAIR PROGRAMMERS COMPLETE THIS SECTION \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/<\/pre>\n<p>You&#8217;d have some pre-canned template that should go at the top of each code file. ?This one is clearly for students, but you might also find them with the name of a company or an open source project.<\/p>\n<p>From there, it was a pretty short jump to starting to treat code comments as first class data in their own right.<\/p>\n<h3>Intelligent Comments<\/h3>\n<p>I can still remember the first time I encountered intelligent comments. ?I&#8217;d been using templates like the one above for some time in C and C++ code that I wrote for Linux kernel modules. ?But then I switched over to doing some stuff in both Java and .NET, and I discovered something awesome.<\/p>\n<p>Instead of formats like the one above, you could write comments like this one, in C#.<\/p>\n<pre class=\"lang:default decode:true\">\/\/\/ &lt;summary&gt;\n\/\/\/ I like re-inventing wheels, so enjoy this Add method\n\/\/\/ &lt;\/summary&gt;\n\/\/\/ &lt;param name=\"x\"&gt;First number to add&lt;\/param&gt;\n\/\/\/ &lt;param name=\"y\"&gt;Second number to add&lt;\/param&gt;\n\/\/\/ &lt;returns&gt;The sum of the numbers&lt;\/returns&gt;\npublic string Add(int x, int y)\n{\n  return x + y;\n}<\/pre>\n<p>As far as the compiler was concerned, this was just any old comment one might write. ?But the IDE did something a lot cooler with it. ?If you wrote this style of comment above a method, and you used that fancy looking XML formatting, <a href=\"https:\/\/msdn.microsoft.com\/en-us\/library\/43f44291.aspx\">IntelliSense<\/a>?in the Visual Studio IDE would parse the comments and render them as meaningful data while you coded. ?This was <em>code intelligence<\/em>. ?With an instance of the parent class, call it Calculator, you could type &#8220;calculator&#8221; and then hit a period, and see that it offered the Add() method, exactly as described in the comments.<\/p>\n<p>Wow.<\/p>\n<p>Java offered a similar construct as well. ?And of course it did. ?This represented the future of the humble code comment. ?Treat them not as random text, but as proper data (or metadata, anyway).<\/p>\n<h3>The Shift to True Documentation<\/h3>\n<p>Why go through all of this history? ?Because I wanted to demonstrate how code comments evolved over the years. ?Originally, it represented the only reasonable means of deciphering terse and often confusing instructions. ?But as our languages grew more expressive and our collective mastery of them more ubiquitous, what we could express both with the language and with the comments around it improved.<\/p>\n<p>Software and the code that defines it have exploded in diversity, complexity, and scope over the decades. ?With so many more people maintaining so much more code, we&#8217;ve had to scramble to make maintenance even remotely sane. ?And we often fail, resulting in applications being wastefully rewritten whole cloth.<\/p>\n<p>But when we succeed, we do it by having a strategy for maintenance that involves true code documentation. ?This means a concerted effort to write a conceptual manual for maintainers. ?You could try to do this with code comments alone, but that&#8217;s unwieldy. ?Similarly, people have used things like Word documents, wikis and SharePoint sites over the years. ?But those get out of sync more easily, since they aren&#8217;t right inline.<\/p>\n<p>The true sweet spot lies in the judicious use of comments, and of turning those comments into the data that drives proper documentation. ?So sure, you can?<em>comment<\/em> your code as an understanding stopgap. ?But don&#8217;t stop there. ?Look for ways to turn your comments and code metadata into proper documentation. ?<em>Document<\/em> your code.<\/p>\n\n","protected":false},"excerpt":{"rendered":"<p>Often, you hear &#8220;code comments&#8221; and &#8220;code documentation&#8221; used at least somewhat interchangeably. ?Perhaps the idea of code documentation has a little more formalism to it, in passing. ?And code comments may cover a bit less ground. But still, I hear the terms serve as synonyms for one another. ?And I hear this in particular when it comes to the actual construct of code comments &#8212; meaning, literally, the feature of compilers and interpreters that allows you to say, &#8220;Disregard everything after these two slashes. I&#8217;m editorializing for the benefit of other humans.&#8221; ?&#8221;Comment your code&#8221; and &#8220;document your code&#8221; offer the same mandate. But I find that problematic. ?And it&#8217;s not just because I&#8217;m some kind of stickler for semantics. ?I think this causes us to have weird arguments, sometimes nonsensical and sometimes unnecessary. Code Documentation vs Code Comments To explain myself and my reasoning, I&#8217;ll offer definitions for&#8230;<\/p>\n","protected":false},"author":4,"featured_media":412,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[2,11],"tags":[],"class_list":["post-411","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-articles","category-documentation"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2017\/09\/A_Red_Apple_and_A_Green_Apple.jpg?fit=2724%2C1761&ssl=1","yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v15.0 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Code Documentation and Code Comments Aren&#039;t the Same Thing<\/title>\n<meta name=\"description\" content=\"You hear the terms code documentation and code comments tossed around somewhat interchangeably. But the difference between these concepts is important.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/blog.submain.com\/code-documentation-code-comments\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Code Documentation and Code Comments Aren&#039;t the Same Thing\" \/>\n<meta property=\"og:description\" content=\"You hear the terms code documentation and code comments tossed around somewhat interchangeably. But the difference between these concepts is important.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/blog.submain.com\/code-documentation-code-comments\/\" \/>\n<meta property=\"og:site_name\" content=\"Software Quality Blog - SubMain Software\" \/>\n<meta property=\"article:published_time\" content=\"2017-09-26T15:24:27+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2018-04-27T22:08:09+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2017\/09\/A_Red_Apple_and_A_Green_Apple.jpg?fit=2724%2C1761&#038;ssl=1\" \/>\n\t<meta property=\"og:image:width\" content=\"2724\" \/>\n\t<meta property=\"og:image:height\" content=\"1761\" \/>\n<meta name=\"twitter:card\" content=\"summary\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebSite\",\"@id\":\"https:\/\/blog.submain.com\/#website\",\"url\":\"https:\/\/blog.submain.com\/\",\"name\":\"Software Quality Blog - SubMain Software\",\"description\":\"Code Quality Tools, Automated Code Review and Refactoring\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":\"https:\/\/blog.submain.com\/?s={search_term_string}\",\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"ImageObject\",\"@id\":\"https:\/\/blog.submain.com\/code-documentation-code-comments\/#primaryimage\",\"inLanguage\":\"en-US\",\"url\":\"https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2017\/09\/A_Red_Apple_and_A_Green_Apple.jpg?fit=2724%2C1761&ssl=1\",\"width\":2724,\"height\":1761,\"caption\":\"Code documentation and code comments are different, like red and green apples.\"},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/blog.submain.com\/code-documentation-code-comments\/#webpage\",\"url\":\"https:\/\/blog.submain.com\/code-documentation-code-comments\/\",\"name\":\"Code Documentation and Code Comments Aren't the Same Thing\",\"isPartOf\":{\"@id\":\"https:\/\/blog.submain.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/blog.submain.com\/code-documentation-code-comments\/#primaryimage\"},\"datePublished\":\"2017-09-26T15:24:27+00:00\",\"dateModified\":\"2018-04-27T22:08:09+00:00\",\"author\":{\"@id\":\"https:\/\/blog.submain.com\/#\/schema\/person\/cb6edf23222435414660528ab7b2fcfa\"},\"description\":\"You hear the terms code documentation and code comments tossed around somewhat interchangeably. But the difference between these concepts is important.\",\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/blog.submain.com\/code-documentation-code-comments\/\"]}]},{\"@type\":\"Person\",\"@id\":\"https:\/\/blog.submain.com\/#\/schema\/person\/cb6edf23222435414660528ab7b2fcfa\",\"name\":\"Erik Dietrich\",\"image\":{\"@type\":\"ImageObject\",\"@id\":\"https:\/\/blog.submain.com\/#personlogo\",\"inLanguage\":\"en-US\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/691ca004bd18f464e9467b2f838e8fbc7a9a2c9eb8568b04a834ac653f3ab1d7?s=96&d=mm&r=g\",\"caption\":\"Erik Dietrich\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","jetpack_shortlink":"https:\/\/wp.me\/p8R7uj-6D","jetpack_sharing_enabled":true,"jetpack-related-posts":[{"id":595,"url":"https:\/\/blog.submain.com\/simplifying-code-documentation\/","url_meta":{"origin":411,"position":0},"title":"9 Tips for Simplifying Your Code Documentation","author":"Erik Dietrich","date":"May 1, 2018","format":false,"excerpt":"Documenting your code is important. It tells other developers what the code does, why it is constructed in a certain way, and how to use it. Good documentation saves them time when they are trying to perform a certain task that isn't straightforward. It will probably also save you time?because\u2026","rel":"","context":"In &quot;Articles&quot;","block_context":{"text":"Articles","link":"https:\/\/blog.submain.com\/category\/articles\/"},"img":{"alt_text":"Ignoring the maze","src":"https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2018\/04\/Ignoring-the-maze-e1524897871885.jpg?fit=1200%2C737&ssl=1&resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2018\/04\/Ignoring-the-maze-e1524897871885.jpg?fit=1200%2C737&ssl=1&resize=350%2C200 1x, https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2018\/04\/Ignoring-the-maze-e1524897871885.jpg?fit=1200%2C737&ssl=1&resize=525%2C300 1.5x, https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2018\/04\/Ignoring-the-maze-e1524897871885.jpg?fit=1200%2C737&ssl=1&resize=700%2C400 2x, https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2018\/04\/Ignoring-the-maze-e1524897871885.jpg?fit=1200%2C737&ssl=1&resize=1050%2C600 3x"},"classes":[]},{"id":168,"url":"https:\/\/blog.submain.com\/comments-in-clean-code-think-documentation\/","url_meta":{"origin":411,"position":1},"title":"Comments in Clean Code? Think Documentation","author":"Erik Dietrich","date":"August 18, 2016","format":false,"excerpt":"Notwithstanding some oddball calculator and hobby PC hacking, my first serious programming experience came in college.? A course called \"Intro to C++\" got us acquainted with arrays, loops, data structures and the like.? Given its introductory nature, this class did not pose a particularly serious challenge (that would come later).?\u2026","rel":"","context":"In &quot;Articles&quot;","block_context":{"text":"Articles","link":"https:\/\/blog.submain.com\/category\/articles\/"},"img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":837,"url":"https:\/\/blog.submain.com\/software-documentation\/","url_meta":{"origin":411,"position":2},"title":"Software Documentation: What You Need to Document and How","author":"Erik Dietrich","date":"February 19, 2019","format":false,"excerpt":"\u00a0 Software documentation is all about bringing clarity into a code baseline. It provides clues to clarify the meaning of certain code structures. For this purpose, we use best programming practices and tools to clarify our software.?When documenting software, we aim to minimize time spent hunting for meaning. We want\u2026","rel":"","context":"In &quot;Articles&quot;","block_context":{"text":"Articles","link":"https:\/\/blog.submain.com\/category\/articles\/"},"img":{"alt_text":"A hand writing software documentation on paper","src":"https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2019\/02\/A-hand-writing-software-documentation-on-paper-1024x912.jpg?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":905,"url":"https:\/\/blog.submain.com\/code-documentation-the-complete-beginners-guide\/","url_meta":{"origin":411,"position":3},"title":"Code Documentation: The Complete Beginner&#8217;s Guide","author":"Erik Dietrich","date":"June 11, 2019","format":false,"excerpt":"You're a little ways into your first programming job, and things are getting easier. At first, all the code you had to deal with might have overwhelmed and confused you, but you're starting to get the hang of it. That's great! Now you're wondering how to take the code you\u2026","rel":"","context":"In &quot;Articles&quot;","block_context":{"text":"Articles","link":"https:\/\/blog.submain.com\/category\/articles\/"},"img":{"alt_text":"Readme_book_signifying_code_documentation","src":"https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2019\/06\/Readme_book_signifying_code_documentation.jpg?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":844,"url":"https:\/\/blog.submain.com\/c-comments-complete-guide\/","url_meta":{"origin":411,"position":4},"title":"C# Comments: A Complete Guide, Including Examples","author":"Erik Dietrich","date":"March 5, 2019","format":false,"excerpt":"Time for another C#-related post. We've already covered a fair amount of the language's keywords, types, and concepts in previous posts. Today's post covers C# comments, a topic that you might think is trivial. My mission in this post is to convince you otherwise. True, comments are far from being\u2026","rel":"","context":"In &quot;Articles&quot;","block_context":{"text":"Articles","link":"https:\/\/blog.submain.com\/category\/articles\/"},"img":{"alt_text":"C_sharp_comments_sign_with_arrow","src":"https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2019\/03\/C_sharp_comments_sign_with_arrow-1013x1024.jpg?resize=350%2C200","width":350,"height":200},"classes":[]},{"id":815,"url":"https:\/\/blog.submain.com\/how-to-document-code\/","url_meta":{"origin":411,"position":5},"title":"How to Document Code: 5 Ways to Help Maintenance Programmers","author":"Erik Dietrich","date":"January 22, 2019","format":false,"excerpt":"Imagine you're a software developer working on a financial application. One day you're assigned (or, if you're agile, you pick yourself) to implement changes to the overtime computation logic so your company can sell the application in France. In France, the official work week has 35 hours (lucky them) instead\u2026","rel":"","context":"In &quot;Articles&quot;","block_context":{"text":"Articles","link":"https:\/\/blog.submain.com\/category\/articles\/"},"img":{"alt_text":"Maintenance_guy_with_how_to_manual","src":"https:\/\/i0.wp.com\/blog.submain.com\/wp-content\/uploads\/2019\/01\/Maintenance_guy_with_how_to_manual-838x1024.jpg?resize=350%2C200","width":350,"height":200},"classes":[]}],"_links":{"self":[{"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/posts\/411","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/comments?post=411"}],"version-history":[{"count":0,"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/posts\/411\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/media\/412"}],"wp:attachment":[{"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/media?parent=411"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/categories?post=411"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.submain.com\/wp-json\/wp\/v2\/tags?post=411"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}