{"id":371,"date":"2014-09-15T00:21:10","date_gmt":"2014-09-15T09:21:10","guid":{"rendered":"http:\/\/blog.box.kr\/?p=371"},"modified":"2014-09-15T00:21:10","modified_gmt":"2014-09-15T09:21:10","slug":"clojure-vs-scala","status":"publish","type":"post","link":"https:\/\/blog.box.kr\/?p=371","title":{"rendered":"Clojure vs Scala"},"content":{"rendered":"
http:\/\/programming-puzzler.blogspot.kr\/2013\/12\/clojure-vs-scala.html<\/a><\/address>\n
\n
\n

Clojure vs Scala<\/h3>\n
\n<\/div>\n
Last week, someone posted a question on the Clojure group asking for a comparison between Clojure and Scala. Since my most popular blog post, by far, is my\u00a0<\/span>Racket vs Clojure<\/a>\u00a0<\/span>post from three years ago, I thought it would be good to post my response here.Ten years ago, I would have said that my ideal dream language is one that provides the flexibility to program in any style. I want to be able to choose object-oriented or functional, immutable or mutable, high-level abstractions or low-level speed. With respect to this ideal, Scala clearly wins, supporting more programming styles than Clojure.<\/p>\n

I’ve definitely changed my tune, though, and now I actually prefer the way that Clojure constrains and shapes my thinking. I argue that even though Scala may provide me with more options on how to tackle a given programming problem, Clojure guides me towards a simpler solution. If this intrigues you, read on…<\/p>\n

The following text is only slightly paraphrased from what I posted to the group:<\/p>\n

All or nearly all of the functional aspects of Clojure have counterparts in Scala. On top of that, Scala provides mutable flavors of everything, so you can pick and choose your approach. So that makes Scala better, right?But the difference between Clojure and Scala is bigger than a feature-to-feature comparison — they have very different philosophies, and programs developed in Clojure consequently have a very different feel to them than those developed in Scala. I find Clojure programs to be dramatically simpler.<\/p>\n

Just as one example, consider modeling a deck of cards. In Clojure, you’d be more likely to come up with a simple representation for a card, perhaps: [10 :spades]. Depending on the card game, you might choose to represent a face card as [:king :clubs] or [13 :clubs]. A deck would likely be modeled as just a sequence of cards, and all the built-in sequence functions would apply, for example, shuffle, take, drop, etc. Serializing the data (for example, if you want to keep a database tracking all the shuffled decks you’ve ever used in a given game) comes for free.<\/p>\n

On the other hand, in Scala, you’d be more likely to create a card Class with a rank and suit field. The Suit class would be comprised of four case classes, because the philosophy is to enumerate all the possible suits as separate entities — there’s nothing in Scala like Clojure’s convenient keywords. For the rank, you’d be steered towards representing all the ranks as integers. The possibility of representing face cards with a name would likely never occur to you, because it would be too complicated to go through the effort of defining the type of a rank to be a “integer or a class comprised of four case classes — jack,queen,king,ace”. For modeling the deck, you probably wouldn’t say a Deck\u00a0<\/span>is-a<\/em><\/i>\u00a0<\/span>sequence, because composition is favored over inheritance. So you’d probably have a Deck class which would\u00a0<\/span>contain<\/em><\/i>\u00a0<\/span>a sequence of cards. This means that you’d have to reimplement methods like shuffle, take, and drop on your Deck class to turn around and dispatch those methods to the underlying sequence of cards. If you’re not careful, years of object-oriented training might kick in and before you know it, you’re representing the deck as a class where methods like shuffle, take, and drop destructively update the underlying sequence — it feels so natural to do that once you’ve encapsulated the underlying sequence of cards in a class. If you want to serialize a deck, that’s more code to write (although general “pickling” of a Scala object is an active area of research).<\/p>\n

This example pretty much sums up what I prefer about Clojure. I like to tell people that a big part of what makes Clojure special is its philosophy of\u00a0<\/span>lightweight data modeling<\/em><\/i>. It leads to delightfully simple systems. Scala remains deeply rooted in the OO philosophy, which all too often leads to an over-engineered muddle.<\/blockquote>\n

Further thoughts<\/h2>\n

After posting the above message, a couple people pointed out that Scala doesn’t force you to build the more complicated model. That’s absolutely true. But due to its highly detailed static type system, Scala attracts the kind of programmers that like to carefully categorize and enumerate all the possible data structures that will occur in their programs. Sure, you could eschew objects in Scala and mimic Clojure by using generic maps\/vectors\/lists\/sets for all your structured data needs, but that’s clearly not how Scala is meant to be used, and numerous little details of the language psychologically steer you towards developing a more rigorous type taxonomy.In my post, I mentioned\u00a0<\/span>lightweight data modeling<\/i>. I can’t stress this term enough. I’d like to see it become the new catchphrase for Clojure. When I used to give my “elevator pitch” for Clojure, I’d talk about how it was a functional programming language, a dialect of Lisp on the JVM, with some interesting concurrency constructs. I’d get a lot of blank stares. Most people don’t know what it means to be functional, and many don’t know about Lisp. But once I started talking about\u00a0<\/span>lightweight data modeling<\/i>, people’s interest perked up. People get it, or think they get it, or at least get it enough to be curious to ask for more details.<\/p>\n

At that point, I often say something like, “Do you know JSON?” After getting acknowledgment, I continue with, “Well, imagine if you could represent all your data as JSON, rather than a complex hierarchy of objects and methods, and the language was designed around making that kind of data super-easy to work with.” I find I get a much more positive response from this kind of explanation. It gives a hint of what it feels like to work in Clojure and think in Clojure.<\/p>\n

I find it interesting that in Scala’s early days, Scala had a similar orientation. They proudly boasted that XML manipulation was going to be Scala’s killer feature. You could drop XML in your code as a data literal; the language was oriented around making XML easy to work with. Now, this has fallen by the wayside. Martin Odersky (the designer of Scala) has been quoted as saying, “Seemed a great idea at the time, now it sticks out like a sore thumb.”<\/p>\n

I admit, there are times where I’m envious of Scala’s versatility versus Clojure: the ease of using a mutable variable, the ease of working with Java primitives and arrays, the speed that comes from static typing, the richness of classes versus Clojure’s namespaces. (Actually, this last point is probably worthy of its own blog post — Clojure’s namespaces are quite limited in ways that frequently cause me pain). Whenever I run up against one of these rough spots in Clojure, I feel like an ascetic monk, suffering because I’ve chosen to deny myself the additional tools that Scala brings to the table. But overall, I feel happier programming in Clojure because the additional constraints imposed by Clojure guide me more quickly towards a simple design.<\/p>\n

\n<\/div>\n<\/div>\n
\n
Posted by\u00a0<\/span>Mark Engelberg\u00a0<\/span><\/a><\/span><\/span>at\u00a0<\/span>12:34 AM<\/abbr><\/a>\u00a0<\/span><\/span><\/p>\n
\n<\/div>\n<\/div>\n
\n<\/div>\n
\n<\/div>\n<\/div>\n<\/div>\n
<\/a><\/p>\n

22 comments:<\/h4>\n
\n
\n
\n
\n
\n
    \n
  1. \n
    \"\"\n<\/div>\n
  2. \n
    \"\"\n<\/div>\n
    \n
    phil<\/a><\/cite>December 24, 2013 at 4:35 AM<\/a><\/span>\n<\/div>\n

    In Scala I would model a card as an Int and a card type either Face or King, Jack, Queen, Ace. I would use case classes giving pattern matching, Scala picking gives serialisation for free and easy and type checking for the serialisation at compile time.\u00a0<\/span><\/p>\n

    trait CardType
    \ncase class FaceCard() extends CardType
    \ncase class QueenCard() extends CardType\u00a0<\/span>
    \ncase class… the other types continued… then
    \ncase class Card(cardValue: Int, cardType: CardType)<\/p>\n

    A deck of cards would be a single class which would contain a collection of cards, a List[Card], operations shuffle, etc, would be defined on the Deck class. Operations such as shuffle would produce a new immutable Card class instance, so there would be no mutable state, rely on the immutable List data structure.<\/p>\n

    In particular since the Deck class is immutable you could expose the internal list publicly so people could do any of the take drop operations on the internal list and still be assured that the code is safe, pure functional and immutable. There is no need to hide the internal list implementation, so all list operations are available.<\/p>\n

    I would say the main difference is that Scala doesn’t have some features baked into the language that Clojure has, however, those features are available if you bring in the right libraries. So the language grows by convention, by the libraries, rather than having those things in at the beginning.
    \nIt would be nice if those things were in at the beginning, but it would be a big job to put all of them in!<\/p>\n

    A good example is Picking, which is new, but it gives easy and fast serialisation of Scala objects, this is not a part of the language but a library which uses Scala macros to do type safe serialisation, ie, it gets type checked at compile time, and some runtime checks.<\/p>\n

    Reply<\/a><\/span>\n<\/div>\n

    \n
    <\/span>Replies<\/a><\/span><\/span><\/span><\/p>\n
    \n<\/div>\n
    \n<\/div>\n<\/div>\n<\/div>\n<\/li>\n
  3. \n
    \"\"\n<\/div>\n
  4. \n
    \"\"\n<\/div>\n
  5. \n
    \"\"\n<\/div>\n
  6. \n
    \"\"\n<\/div>\n
  7. \n
    \"\"\n<\/div>\n
  8. \n
    \"\"\n<\/div>\n
  9. \n
    \"\"\n<\/div>\n
  10. \n
    \"\"\n<\/div>\n
  11. \n
    \"\"\n<\/div>\n
  12. \n
  13. \n
    \"\"\n<\/div>\n
  14. \n
    \"\"\n<\/div>\n
  15. \n
    \"\"\n<\/div>\n
  16. \n
    \"\"\n<\/div>\n
  17. \n
    \"\"\n<\/div>\n
  18. \n
    \"\"\n<\/div>\n
  19. \n
  20. \n
    \"\"\n<\/div>\n
  21. \n
    \"\"\n<\/div>\n
  22. \n
  23. \n
    \"\"\n<\/div>\n
    \n
    Unknown<\/a><\/cite>December 25, 2013 at 6:28 AM<\/a><\/span>\n<\/div>\n

    The problem is that both approaches have their pros and cons. The “clojure” approach is the dynamic approach. What a (good) python\/perl\/… programmer would do. The “scala” approach is the general approach a (good) Java\/C++\/… programmer would take. And you’re right, for simple operations the dynamic approach would be best, simply because lots of operations are loosely defined because you’re using very basic classes.<\/p>\n

    However when the data becomes more complex, all these functions start to have side effects. There are plenty of lists you can’t “take” from random places, shuffle may not be possible for the datastructure you’ve implemented. God forbid the list is a list that actually exists in a remote database.<\/p>\n

    So the problem here is small versus large programs. The dynamic approach you describe is unbeatable for small programs, and a complete disaster for large ones. You implicitly apply a large, very-high-up class to your data and lots of stuff just works.<\/p>\n

    When your program grows you’re going to find that it doesn’t always do the right thing and you need to either:<\/p>\n

    1) reimplement the semantic equivalents of take, shuffle, and give them some weird name. Then live with the fact that anybody in your team can just call the wrong functions and you’d never find it.<\/p>\n

    2) switch to the Scala static approach.<\/p>\n

    Reply<\/a><\/span>\n<\/div>\n

    \n
    <\/span>Replies<\/a><\/span><\/span><\/span><\/p>\n
    \n<\/div>\n
    \n<\/div>\n<\/div>\n<\/div>\n<\/li>\n
  24. \n
    \"\"\n<\/div>\n
  25. \n
  26. \n
    \"\"\n<\/div>\n
    \n
    grant rettke<\/a><\/cite>March 23, 2014 at 10:35 AM<\/a><\/span>\n<\/div>\n

    Integers would be a great starting point and they could represent everything that you need as long as you are OK with codifying the constraints in a function.<\/p>\n

    Reply<\/a><\/span>\n<\/div>\n

    \n<\/div>\n
    \n<\/div>\n<\/li>\n<\/ol>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/address>\n","protected":false},"excerpt":{"rendered":"

    http:\/\/programming-puzzler.blogspot.kr\/2013\/12\/clojure-vs-scala.html Clojure vs Scala Last week, someone posted a question on the Clojure group asking for a comparison between Clojure and Scala. Since my most popular blog post, by far, is my\u00a0Racket vs Clojure\u00a0post from three years ago, I thought it would be good to post my response here.Ten years ago, I would have said that my ideal dream language is one that provides the flexibility to program in any style. I want to be able to choose object-oriented or functional, immutable or mutable, high-level abstractions or low-level speed. With respect to this ideal, Scala clearly wins, supporting more programming styles than Clojure. I’ve definitely changed my tune, though, and now I actually prefer the way that Clojure constrains and shapes my thinking. I argue that even though Scala may provide me with more options on how to tackle a given programming problem, Clojure guides me towards a simpler solution. If this intrigues you, read on… The following text is only slightly paraphrased from what I posted to the group: All or nearly all of the functional aspects of Clojure have counterparts in Scala. On top of that, Scala provides mutable flavors of everything, so you can pick and choose […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_mi_skip_tracking":false,"ngg_post_thumbnail":0,"spay_email":"","jetpack_publicize_message":"","jetpack_is_tweetstorm":false,"jetpack_publicize_feature_enabled":true},"categories":[7],"tags":[],"aioseo_notices":[],"jetpack_featured_media_url":"","jetpack_publicize_connections":[],"jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p5q9Zn-5Z","jetpack-related-posts":[{"id":369,"url":"https:\/\/blog.box.kr\/?p=369","url_meta":{"origin":371,"position":0},"title":"Scala, Clojure, Groovy \uadf8\ub9ac\uace0 \uac1c\ubc1c\uc790\uc758 \uc5b8\uc5b4","date":"2014-09-15","format":false,"excerpt":"http:\/\/www.okjsp.net\/seq\/216749 \u00a0 \u00a0 Scala, Clojure, Groovy \uadf8\ub9ac\uace0 \uac1c\ubc1c\uc790\uc758 \uc5b8\uc5b4 \uac1c\ubc1c\uc790\ub3c4 \uc138\ucee8\ub4dc \uc5b8\uc5b4 \ud639\uc740 \ud568\uc218\ud615 \uc5b8\uc5b4 \ud558\ub098\ucbe4\uc740 \ud574\uc57c \ud560 \uc2dc\uae30\uac00 \uc628\uac70 \uac19\uc2b5\ub2c8\ub2e4.\u00a0 \ubaa8\ubc14\uc77c\ub85c \uac08\uc544\ud0c0\uc9c0 \uc54a\ub294\ub2e4\uba74, \ud074\ub77c\uc6b0\ub4dc \ud658\uacbd, \uc5d4\ud130\ud504\ub77c\uc774\uc988 \ud658\uacbd\uc5d0\uc11c\ub294 \uc790\ubc14 \uc790\uccb4\ub9cc\uc73c\ub85c\ub294 \ud574\uacb0 \ud560 \uc218 \uc5c6\ub294 \uce21\uba74\ub4e4\uc774 \ub098\uc640\uc11c \uc138\ucee8\ub4dc \uc5b8\uc5b4\uc5d0 \ub300\ud55c \uc218\uc694\uac00 \uc810\uc9c4\uc801\uc73c\ub85c \uc0dd\uaca8\ub098\uc9c0 \uc54a\uc744\uae4c \ud558\ub294 \uc0dd\uac01\uc774 \ub9ce\uc774 \ub4dc\ub124\uc694.\u00a0 \ub300\ud45c\uc801\uc73c\ub85c\ub294, \uc678\uad6d \uc0ac\ub840\ub97c\u2026","rel":"","context":"In "\ucc38\uace0\ub97c \uc704\ud55c \uc800\uc7a5\ubb3c"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":367,"url":"https:\/\/blog.box.kr\/?p=367","url_meta":{"origin":371,"position":1},"title":"[\ud38c]Scala \uc2dc\uc791\ud558\uae30","date":"2014-09-15","format":false,"excerpt":"\u00a0 http:\/\/ppassa.wordpress.com\/2012\/02\/19\/getting_started_scala\/ Scala \uc2dc\uc791\ud558\uae30 \uc694\uc998 \ub4e4\uc5b4\uc11c\u00a0Scala\ub97c \uacf5\ubd80\ud558\uace0 \uc788\ub2e4. \uc544\uc9c1 \ub9ce\uc774 \ubd80\uc871\ud558\uc9c0\ub9cc, \uc9c0\uae08\uae4c\uc9c0 \ubc30\uc6b4 \uac83\ub4e4 \uae30\ub85d\ud574\ub450\uace0, \ub610 \ud639\uc2dc \uc870\uae08\uc774\ub77c\ub3c4 \ub3c4\uc6c0\uc774 \ub418\ub294 \ubd84\ub4e4\uc774 \uc788\uc744 \uc9c0 \ubab0\ub77c \uacf5\uc720\ud574\ubcf4\uace0\uc790 \ud55c\ub2e4. 1. \ub4e4\uc5b4\uac00\uba70 \ubb58 \ub610 \ubc30\uc6cc\uc57c \ud55c\ub2e8 \ub9d0\uc778\uac00? \uc774\ubbf8 C++, Java, Python, Ruby, JavaScript \ub4f1 \ub9ce\uc740 \ud504\ub85c\uadf8\ub798\ubc0d \uc5b8\uc5b4\ub4e4\uc774 \uc788\ub294\ub370, \uc65c \uc790\uafb8 \uc0c8\ub85c\uc6b4 \uc5b8\uc5b4\uac00 \ub098\uc624\uace0 \uc788\ub0d0?\u2026","rel":"","context":"In "\ucc38\uace0\ub97c \uc704\ud55c \uc800\uc7a5\ubb3c"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":242,"url":"https:\/\/blog.box.kr\/?p=242","url_meta":{"origin":371,"position":2},"title":"Intellij\uc5d0\uc11c Scala + akka \uc124\uc815","date":"2014-07-23","format":false,"excerpt":"Intellij 13 \ubc84\uc804 \uae30\uc900 \u00a0 1. Scala \uc124\uce58 2. SBT \uc124\uce58 3. Intellij\uc5d0\uc11c Scala\ub97c \uc0ac\uc6a9\ud558\uae30 \uc704\ud574\uc11c\ub294 \ud50c\ub7ec\uadf8\uc778\uc73c\ub85c Scala\uc640 sbt \ub458 \ub2e4 \ubaa8\ub450 \uc124\uce58\ud55c\ub2e4. - \uc124\uce58 \ud6c4 'Setting'\uc5d0\uc11c \uc704\uc5d0 \uc124\uce58\ud55c Scala\uc640 SBT\ub97c \uc124\uc815\ud55c\ub2e4. 4. sbt\ub97c \ud1b5\ud574 \ub77c\uc774\ube0c\ub7ec\ub9ac\ub97c \ub9cc\ub4e4\uae30 \uc704\ud574\uc11c\ub294 \ud504\ub85c\uc81d\ud2b8\uc5d0\uc11c sbt-module\ub97c \uc120\ud0dd\ud55c \ud6c4 build.sbt\uc5d0 \ud544\uc694\ud55c \ub77c\uc774\ube0c\ub7ec\ub9ac\ub97c \uc124\uc815\ud55c\ub2e4. \uc704\uc758 build.sbt\uc758 akka \uc124\uc815\uc740\u2026","rel":"","context":"In "JAVA"","img":{"alt_text":"","src":"http:\/\/cfile27.uf.tistory.com\/image\/2418E83652F07318013FE6","width":350,"height":200},"classes":[]},{"id":244,"url":"https:\/\/blog.box.kr\/?p=244","url_meta":{"origin":371,"position":3},"title":"\ud29c\ud1a0\ub9ac\uc5bc: \uc2a4\uce7c\ub77c(Scala), akka \ub85c scalable \ud558\uace0, fault-tolerant \ud55c \ub124\ud2b8\uc6cc\ud06c \ucc44\ud305 \uc11c\ubc84\uc640 \ud074\ub77c\uc774\uc5b8\ud2b8 \ub9cc\ub4e4\uae30","date":"2014-07-23","format":false,"excerpt":"\ud29c\ud1a0\ub9ac\uc5bc: \uc2a4\uce7c\ub77c(Scala), akka \ub85c scalable \ud558\uace0, fault-tolerant \ud55c \ub124\ud2b8\uc6cc\ud06c \ucc44\ud305 \uc11c\ubc84\uc640 \ud074\ub77c\uc774\uc5b8\ud2b8 \ub9cc\ub4e4\uae30 SW\uac1c\ubc1c \u00a0http:\/\/doc.akka.io\/docs\/akka\/1.3.1\/scala\/tutorial-chat-ser..","rel":"","context":"In "JAVA"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":364,"url":"https:\/\/blog.box.kr\/?p=364","url_meta":{"origin":371,"position":4},"title":"[\ud38c]\uac1d\uccb4\uc9c0\ud5a5+\ud568\uc218\ud615 \ud504\ub85c\uadf8\ub798\ubc0d \uc5b8\uc5b4 Scala","date":"2014-09-15","format":false,"excerpt":"\uac1d\uccb4\uc9c0\ud5a5+\ud568\uc218\ud615 \ud504\ub85c\uadf8\ub798\ubc0d \uc5b8\uc5b4 Scala \uc2a4\uce7c\ub77c(Scala)\ub294 \uac1d\uccb4\uc9c0\ud5a5 \uc5b8\uc5b4\uc774\uba74\uc11c \ub3d9\uc2dc\uc5d0 \ud568\uc218 \uc5b8\uc5b4\uc774\ub2e4. \uc2a4\uce7c\ub77c\ub294 \uc790\ubc14\uc640 \ub9c8\ucc2c\uac00\uc9c0\ub85c \uc790\ubc14\uac00\uc0c1\uba38\uc2e0(JVM) \uc704\uc5d0\uc11c \uc2e4\ud589\ub418\uba70 \uae30\uc874 \uc790\ubc14 \ub77c\uc774\ube0c\ub7ec\ub9ac\ub97c \uadf8\ub300\ub85c \uc0ac\uc6a9\ud560 \uc218 \uc788\ub2e4. \ubc18\ub300\ub85c \uc790\ubc14\ub85c \uc791\uc131\ub41c \ud504\ub85c\uadf8\ub7a8\uc5d0\uc11c \uc2a4\uce7c\ub77c\ub85c \uc791\uc131\ub41c \ub77c\uc774\ube0c\ub7ec\ub9ac\ub97c \uc0ac\uc6a9\ud560 \uc218\ub3c4 \uc788\ub2e4. \ub2e4\ub978 JVML(JVM \uc5b8\uc5b4)\uc778 JRuby, Jython\uacfc \ub9c8\ucc2c\uac00\uc9c0\ub85c \uc2a4\uce7c\ub77c\ub294 \uc790\ubc14\uc758 \ud55c\uacc4\ub97c \uadf9\ubcf5\ud558\uae30 \uc704\ud574 \ucd9c\ud604\ud588\ub2e4. \ud2b9\ud788, \uc774\ubbf8 \uc124\uacc4\ub41c \ucef4\ud3ec\ub10c\ud2b8 \ub2e8\uc704\uc758\u2026","rel":"","context":"In "\ucc38\uace0\ub97c \uc704\ud55c \uc800\uc7a5\ubb3c"","img":{"alt_text":"","src":"http:\/\/cfs14.tistory.com\/image\/18\/tistory\/2008\/12\/01\/00\/11\/4932ad2c8146f","width":350,"height":200},"classes":[]},{"id":847,"url":"https:\/\/blog.box.kr\/?p=847","url_meta":{"origin":371,"position":5},"title":"[scrap]Automated Testing of REST Services","date":"2015-05-20","format":false,"excerpt":"http:\/\/java.dzone.com\/articles\/automated-testing-rest?utm_content=buffer084c1&utm_medium=social&utm_source=facebook.com&utm_campaign=buffer \u00a0 Despite the fact that I\u2019m a Java and Scala developer I still passionate about testing software, to be more precise\u2013 web applications. It\u2019s really interesting to develop web app and be confident that the apps are of good quality. When I\u2019ve started a career the most popular web\u2026","rel":"","context":"In "\uae30\uc220"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]}],"_links":{"self":[{"href":"https:\/\/blog.box.kr\/index.php?rest_route=\/wp\/v2\/posts\/371"}],"collection":[{"href":"https:\/\/blog.box.kr\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.box.kr\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.box.kr\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.box.kr\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=371"}],"version-history":[{"count":0,"href":"https:\/\/blog.box.kr\/index.php?rest_route=\/wp\/v2\/posts\/371\/revisions"}],"wp:attachment":[{"href":"https:\/\/blog.box.kr\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=371"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.box.kr\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=371"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.box.kr\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=371"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}