{"action":"created","comment":{"url":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/comments/59441977","id":59441977,"diff_hunk":"@@ -0,0 +1,366 @@\n+{:title \"The approach to state management in Clojure\"\n+:description  \"Intro to mutable state in Clojure. Greg the llama show you an effective way how to manage state, and you'll find out that llamas love candies too :)\"\n+:layout :post\n+:tags  [\"Clojure\" \"ClojureScript\" \"Fundamentals\"]\n+:toc false\n+:author \"Dajana Štiberová\"\n+:image \"\"}\n+\n+Long time ago, during one interview, I was asked to describe the difference between `vars` and `atoms`.\n+It was a pretty simple question, but at that time it was not so easy to describe this difference for me.\n+Now I'm more skilled in Clojure but I still think that it was an interesting question and when\n+I was looking for a topic for the blog post, I decided to use this one.\n+\n+So if you want to read something about state management, or you want to know how to dance like Greg the llama, this post is for you :)\n+\n+## States and Identities\n+\n+We need to know that in Clojure there is a difference between state and identity.\n+\n+`States` are an immutable data.\n+A state is the value an identity points to at a particular time. State never changes.\n+\n+`Identities` unify different values over the time.\n+Identity types are mutable references to immutable values,\n+and can be modelled by using one of the four references types (`Var`s, `Atom`s, `Agent`s, `Ref`s)\n+\n+\n+### *Example*\n+\n+Our example is the best llama on earth, Greg the llama.\n+Greg is an identity.\n+Greg wants to go to the party with Gregorina. He is a good dancer, and he wants to teach us how to dance.\n+\n+So, Greg is dancing and every snapshot of this action is one state.\n+\n+Greg has a series of different values (moves) over time (states 1-4).\n+We need to realize, that we can transition the state but it is not possible to change or modify the previous state.\n+The identity (Greg) can be modelled by using some reference type pointing to the value,\n+and subsequently calling appropriate functions to create new states.\n+\n+NOTE:\n+\n+If you don't have any knowledge about threads in Clojure, you should read about [threads](http://blog.clojuregirl.com/clojure_threads.html) first.\n+\n+## How we can manage states (or how the data might change over time)\n+\n+There are four ways how to model an identity (manage states).\n+Using reference types: `Vars` , `Atoms` , `Refs` , `Agents` .\n+\n+Greg has a girlfriend Gregorina and they go to the party. It's halloween party and\n+there are a lot of sweets everywhere. Llamas love candies and as we know, \n+favourite candies for llamas are yummy marshmallows and gummy bears.\n+\n+![marshmallow](../img/marshmallow.png \"Marshmallow\")\n+\n+### Vars\n+\n+We can create a `Var` using `def`.\n+In our example we create a `Var` named `marshmallows-in-the-bag` `(def marshmallows-in-the-bag)`\n+and this `Var` will be reference for amount of the marshmallows in one bag.\n+\n+If we define `Var` as a `^:dynamic` (adding the `:^dynamic` metadata part).\n+\n+```clojure\n+(def ^:dynamic marshmallows-in-the-bag 30)\n+```\n+\n+`Var` can be rebound in different context and the rebinding is available only within it's dynamic scope.\n+\n+We will look what the dynamic scope is, and on the difference between Lexical and Dynamic scope.\n+\n+### Difference between the lexical and the dynamic scope\n+\n+What's the scope \n+\n+Simply, the `scope` is a context created to summarize symbols. Without this scope all the symbols would be global.\n+\n+Let's start with the lexical scope\n+\n+### Lexical Scope\n+\n+Is the code block, where we define the symbol. This symbol is valid inside the code block where is defined (including any nested forms).\n+The lexical scope can be defined for example by the `let` block.\n+\n+In the bag there are 30 marshmallows. So we will define `marshmallows-in-the-bag` with a value `30`.\n+\n+```clojure\n+(def marshmallows-in-the-bag 30)\n+```\n+\n+Now we will define a function `marshmallows-left`. This function takes one argument `marshmallows-eaten`. \n+In a let block we will define the `new-amount-of-marshmallows` and the value of this Var is the difference between `marshmallows-in-the-bag`\n+and `marshmallows-eaten`. \n+As a last step in this function is the println `new-amount-of-marshmallows`.\n+\n+```clojure\n+(defn marshmallows-left [marshmallows-eaten]\n+  (let [new-amount-of-marshmallows (- marshmallows-in-the-bag marshmallows-eaten)]\n+     (println (str \"Marshmallows in the bag: \" new-amount-of-marshmallows))))\n+```\n+\n+Calling our function `marshmallows-left` with 10 (because Greg ate 10 pieces of marshmallow)\n+\n+```Clojure\n+(marshmallows-left 10)\n+\n+;;=> Marshmallows in the bag: 20\n+\n+```\n+We found out that in the bag 20 marshmallows left.\n+\n+### Dynamic Scope\n+\n+In difference to `lexical scope`, the dynamic scope does  not depend on code block, but on the runtime call stack.\n+\n+The best way to understand the difference, is to look at the code bellow.\n+\n+```Clojure\n+(def ^:dynamic marshmallows-in-the-bag 30)\n+\n+(defn marshmallows-left []\n+  (println (str \"Marshmallows in the bag: \" marshmallows-in-the-bag)))\n+\n+(defn number-of-marshmallows-left [marshmallows-eaten]\n+  (binding [marshmallows-in-the-bag (- marshmallows-in-the-bag marshmallows-eaten)]\n+    (marshmallows-left)))\n+                    \n+```\n+We created a function `marshmallows-left`. This function prints the value of our Var `marshmallows-in-the-bag`. \n+And we have another function `number-of-marshmallows-left` with one argument `marshmallows-eaten`. \n+In this function we bind new value for `marshmallows-in-the-bag` (difference between `marshmallows-in-the-bag` and `marshmallows-eaten`).\n+\n+Now we call `number-of-marshmallows-left` with 10 as an argument (as we know, that Greg ate 10 marshmallows). \n+\n+```Clojure\n+(number-of-marshmallows-left 10)\n+\n+;;=> Marshmallows: 20\n+```\n+\n+To show the difference we'll do the same using `let block` (`lexical scope`) instead of `binding` (`dynamic scope`). \n+\n+```Clojure\n+(def ^:dynamic marshmallows-in-the-bag 30)\n+\n+(defn marshmallows-left []\n+  (println (str \"Marshmallows: \" marshmallows-in-the-bag)))\n+\n+(defn number-of-marshmallows-left [marshmallows-eaten]\n+  (let [marshmallows-in-the-bag (- marshmallows-in-the-bag marshmallows-eaten)]\n+    (marshmallows-left)))\n+```\n+\n+And if we call `numbers-of-marshmallows-left` with `10` as an argument, the result will be different as before.\n+\n+```Clojure\n+(number-of-marshmallows-left 10)\n+\n+;;=> Marshmallows: 30\n+```\n+\n+That's because we defined `marshmallows-in-the-bag` in the `let` code block and as we know the new value of the `marshmallows-in-the-bag` \n+is valid only within it's lexical scope. So for the `marshmallows-left` function its the value of the `marshmallows-in-the bag` still `30`. \n+\n+### Atoms\n+\n+Clojure's `atom` reference type is another way how we can manage state. \n+They are updated synchronously and they are ideal for managing the state of independend identities.\n+\n+We will use the same example as we used in `vars`. \n+In this case we will define `marshmallows-in-the-bag` as an atom.\n+\n+```clojure\n+(def marshmallows-in-the-bag (atom 30))\n+```\n+\n+To get the current state of the atom, we need to dereference it using `clojure.core/deref` or `@` reader macro.\n+\n+```clojure\n+@marshmallows-in-the-bag\n+\n+;;=> 30\n+```\n+\n+To update the atom value (change what the atom refers to), we will use `swap!`.\n+Remember that the value of the atom is not changed, the reference is updated and assigned the new value.\n+\n+How the `swap` behaves:\n+\n+1. Read the atom's current state.\n+2. Compare the current state of the `atom` and the state where the `swap` startet with transaction.\n+3. If there's difference, make the transaction retry.\n+4. If there's not difference, update the state.\n+\n+```clojure\n+(defn number-of-marshmallows-left [marshmallows-eaten]\n+  (swap! marshmallows-in-the-bag - marshmallows-eaten))\n+```\n+We created a `number-of-marshmalloes-left` function, which takes one argument `marshmallows-eaten`.\n+We passed `swap!` a function which will be called with `current-state` as an first argument. \n+This function subtracts `marshmallows-eaten` from the current state.\n+\n+```clojure\n+(number-of-marshmallows-left 10)\n+\n+;;=> 20\n+```\n+We can dereference the atom, and we will see that the `marshmallows-in-the-bag` value is updated\n+\n+```clojure\n+@marshmallows-in-the-bag\n+\n+;;=> 20\n+```\n+\n+## Agents\n+\n+`Agents` are similiar to `Atoms`, but in contrast with `atoms`, they are updated asynchronously.\n+\n+We need to keep in mind that the updates to agent will happen asynchronously and at unknown point in time, while updates in `atoms` will happened immediately.\n+The `agents` are good for functions you want to get done, but it doesn't matter when they happen. \n+\n+We will define `marshmallows-in-the-bag` as an agent.\n+\n+```clojure\n+(def marshmallows-in-the-bag (agent 30))\n+```\n+\n+To get the current value of the agent we will dereference it the same way as an `atom`. Using `clojure.core/deref` or `@` reader macro.\n+\n+```clojure\n+@marshmallows-in-the-bag\n+\n+;;=> 30\n+```\n+\n+To update the agent value (refers agent to the new state), we will use `send` or `send-off`.\n+\n+They are mostly similar, the difference is in how they're implemented.  \n+\n+If you send the actions to any agent using `send`, they run in a thread pool with a couple of more threads than the physical number of processors. \n+If you make 1000 calls using `send`, the call that can't be processed immediately just wait until the processor becomes available.\n+If they block then the thread pool can run dry.\n+\n+If you send the actions to any agent using `send-off`, a new thread is created for each call. \n+if you make 1000 calls using `send-off`, the call that can't be processed immediately still wait for the next available processor, \n+but they may incur the extra overhead of starting a thread if the send-off threadpool happens to be running low. \n+It's ok if the threads block because each task (potentially) gets a dedicated thread.\n+\n+```clojure\n+(defn number-of-marshmallows-left [marshmallows-eaten]\n+  (send marshmallows-in-the-bag #(- % marshmallows-eaten)))\n+```\n+\n+So if you call the `number-of-marshmallows-left` there's a possibility that the value is still not updated.\n+\n+```Clojure\n+@marshmallows-in-the-bag\n+\n+;;=> 30\n+```\n+Few seconds later\n+\n+```Clojure\n+@marshmallows-in-the-bag\n+\n+;;=> 20\n+```\n+\n+\n+## Refs\n+\n+Refs are ideal for managing states of more than one identity. \n+\n+For example on the llamas party there is one bag with gummy bears and one bag with marshmallows. \n+Greg and Gregorina are eating from the both bags. \n+So when the llama takes one candy, we need to update state of the llamas and state of the bag.\n+\n+How we can manage this states? We will use `refs`.\n+\n+First we need to define refs for `marshmallow`, `gummy-bears`, `greg` and `gregorina`.\n+\n+```Clojure\n+(def marshmallow (ref {:name \"marshmallow\"\n+                       :count-in-the-bag 30}))\n+                                \n+(def gummy-bears (ref {:name \"gummy bears\"\n+                       :count-in-the-bag 20}))\n+                                                                         \n+(def greg (ref {:candies-eaten 0}))\n+                                                                                  \n+(def gregorina (ref {:candies-eaten 0}))\n+```\n+\n+We can dereference refs the same way as we dereference atoms.\n+\n+```Clojue\n+@greg\n+\n+;;=> {:candies-eaten 0}\n+```\n+Now we are prepared for the transfer (move one candy from the bag to llama's stomach). \n+We need to modify `candy` ref to take one candy from the bag, and modify the `llama` ref to eat one candy.\n+We modify `refs` using `alter`, and we need to put all transaction operations into `dosync` \n+to initiate the transaction.\n+\n+```Clojure\n+(defn eat-candy [name candy]\n+  (if (> (:count-in-the-bag @candy) 0)\n+    (dosync","path":"resources/templates/md/posts/2016-04-04-state.md","position":310,"original_position":310,"commit_id":"ca2dff7aa35f9f8a4bd8556ac10cc4693a0cefb6","original_commit_id":"ca2dff7aa35f9f8a4bd8556ac10cc4693a0cefb6","user":{"login":"arichiardi","id":1724788,"avatar_url":"https://avatars.githubusercontent.com/u/1724788?v=3","gravatar_id":"","url":"https://api.github.com/users/arichiardi","html_url":"https://github.com/arichiardi","followers_url":"https://api.github.com/users/arichiardi/followers","following_url":"https://api.github.com/users/arichiardi/following{/other_user}","gists_url":"https://api.github.com/users/arichiardi/gists{/gist_id}","starred_url":"https://api.github.com/users/arichiardi/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/arichiardi/subscriptions","organizations_url":"https://api.github.com/users/arichiardi/orgs","repos_url":"https://api.github.com/users/arichiardi/repos","events_url":"https://api.github.com/users/arichiardi/events{/privacy}","received_events_url":"https://api.github.com/users/arichiardi/received_events","type":"User","site_admin":false},"body":"Agree with the above","created_at":"2016-04-12T19:53:58Z","updated_at":"2016-04-12T19:53:58Z","html_url":"https://github.com/Lambda-X/lambdax-blog/pull/72#discussion_r59441977","pull_request_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/72","_links":{"self":{"href":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/comments/59441977"},"html":{"href":"https://github.com/Lambda-X/lambdax-blog/pull/72#discussion_r59441977"},"pull_request":{"href":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/72"}}},"pull_request":{"url":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/72","id":66004665,"html_url":"https://github.com/Lambda-X/lambdax-blog/pull/72","diff_url":"https://github.com/Lambda-X/lambdax-blog/pull/72.diff","patch_url":"https://github.com/Lambda-X/lambdax-blog/pull/72.patch","issue_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues/72","number":72,"state":"open","locked":false,"title":"State management","user":{"login":"dstiberova","id":9211809,"avatar_url":"https://avatars.githubusercontent.com/u/9211809?v=3","gravatar_id":"","url":"https://api.github.com/users/dstiberova","html_url":"https://github.com/dstiberova","followers_url":"https://api.github.com/users/dstiberova/followers","following_url":"https://api.github.com/users/dstiberova/following{/other_user}","gists_url":"https://api.github.com/users/dstiberova/gists{/gist_id}","starred_url":"https://api.github.com/users/dstiberova/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/dstiberova/subscriptions","organizations_url":"https://api.github.com/users/dstiberova/orgs","repos_url":"https://api.github.com/users/dstiberova/repos","events_url":"https://api.github.com/users/dstiberova/events{/privacy}","received_events_url":"https://api.github.com/users/dstiberova/received_events","type":"User","site_admin":false},"body":"Please review","created_at":"2016-04-11T14:38:51Z","updated_at":"2016-04-12T19:53:58Z","closed_at":null,"merged_at":null,"merge_commit_sha":"5e9288ca4d69f693017426f9474e0ea654508fc2","assignee":null,"milestone":null,"commits_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/72/commits","review_comments_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/72/comments","review_comment_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/comments{/number}","comments_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues/72/comments","statuses_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/statuses/ca2dff7aa35f9f8a4bd8556ac10cc4693a0cefb6","head":{"label":"Lambda-X:state-management","ref":"state-management","sha":"ca2dff7aa35f9f8a4bd8556ac10cc4693a0cefb6","user":{"login":"Lambda-X","id":15338403,"avatar_url":"https://avatars.githubusercontent.com/u/15338403?v=3","gravatar_id":"","url":"https://api.github.com/users/Lambda-X","html_url":"https://github.com/Lambda-X","followers_url":"https://api.github.com/users/Lambda-X/followers","following_url":"https://api.github.com/users/Lambda-X/following{/other_user}","gists_url":"https://api.github.com/users/Lambda-X/gists{/gist_id}","starred_url":"https://api.github.com/users/Lambda-X/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/Lambda-X/subscriptions","organizations_url":"https://api.github.com/users/Lambda-X/orgs","repos_url":"https://api.github.com/users/Lambda-X/repos","events_url":"https://api.github.com/users/Lambda-X/events{/privacy}","received_events_url":"https://api.github.com/users/Lambda-X/received_events","type":"Organization","site_admin":false},"repo":{"id":50098970,"name":"lambdax-blog","full_name":"Lambda-X/lambdax-blog","owner":{"login":"Lambda-X","id":15338403,"avatar_url":"https://avatars.githubusercontent.com/u/15338403?v=3","gravatar_id":"","url":"https://api.github.com/users/Lambda-X","html_url":"https://github.com/Lambda-X","followers_url":"https://api.github.com/users/Lambda-X/followers","following_url":"https://api.github.com/users/Lambda-X/following{/other_user}","gists_url":"https://api.github.com/users/Lambda-X/gists{/gist_id}","starred_url":"https://api.github.com/users/Lambda-X/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/Lambda-X/subscriptions","organizations_url":"https://api.github.com/users/Lambda-X/orgs","repos_url":"https://api.github.com/users/Lambda-X/repos","events_url":"https://api.github.com/users/Lambda-X/events{/privacy}","received_events_url":"https://api.github.com/users/Lambda-X/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/Lambda-X/lambdax-blog","description":"The official blog of LambdaX","fork":false,"url":"https://api.github.com/repos/Lambda-X/lambdax-blog","forks_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/forks","keys_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/keys{/key_id}","collaborators_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/teams","hooks_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/hooks","issue_events_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues/events{/number}","events_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/events","assignees_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/assignees{/user}","branches_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/branches{/branch}","tags_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/tags","blobs_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/refs{/sha}","trees_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/trees{/sha}","statuses_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/statuses/{sha}","languages_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/languages","stargazers_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/stargazers","contributors_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/contributors","subscribers_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/subscribers","subscription_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/subscription","commits_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/commits{/sha}","git_commits_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/commits{/sha}","comments_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/comments{/number}","issue_comment_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues/comments{/number}","contents_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/contents/{+path}","compare_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/compare/{base}...{head}","merges_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/merges","archive_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/downloads","issues_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues{/number}","pulls_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls{/number}","milestones_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/milestones{/number}","notifications_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/labels{/name}","releases_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/releases{/id}","deployments_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/deployments","created_at":"2016-01-21T10:07:24Z","updated_at":"2016-03-24T17:44:46Z","pushed_at":"2016-04-12T17:29:39Z","git_url":"git://github.com/Lambda-X/lambdax-blog.git","ssh_url":"git@github.com:Lambda-X/lambdax-blog.git","clone_url":"https://github.com/Lambda-X/lambdax-blog.git","svn_url":"https://github.com/Lambda-X/lambdax-blog","homepage":"","size":1946,"stargazers_count":1,"watchers_count":1,"language":"JavaScript","has_issues":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":0,"mirror_url":null,"open_issues_count":3,"forks":0,"open_issues":3,"watchers":1,"default_branch":"master"}},"base":{"label":"Lambda-X:master","ref":"master","sha":"50f6527b4121c2457d8fbe7f66024e4e7dc30e0f","user":{"login":"Lambda-X","id":15338403,"avatar_url":"https://avatars.githubusercontent.com/u/15338403?v=3","gravatar_id":"","url":"https://api.github.com/users/Lambda-X","html_url":"https://github.com/Lambda-X","followers_url":"https://api.github.com/users/Lambda-X/followers","following_url":"https://api.github.com/users/Lambda-X/following{/other_user}","gists_url":"https://api.github.com/users/Lambda-X/gists{/gist_id}","starred_url":"https://api.github.com/users/Lambda-X/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/Lambda-X/subscriptions","organizations_url":"https://api.github.com/users/Lambda-X/orgs","repos_url":"https://api.github.com/users/Lambda-X/repos","events_url":"https://api.github.com/users/Lambda-X/events{/privacy}","received_events_url":"https://api.github.com/users/Lambda-X/received_events","type":"Organization","site_admin":false},"repo":{"id":50098970,"name":"lambdax-blog","full_name":"Lambda-X/lambdax-blog","owner":{"login":"Lambda-X","id":15338403,"avatar_url":"https://avatars.githubusercontent.com/u/15338403?v=3","gravatar_id":"","url":"https://api.github.com/users/Lambda-X","html_url":"https://github.com/Lambda-X","followers_url":"https://api.github.com/users/Lambda-X/followers","following_url":"https://api.github.com/users/Lambda-X/following{/other_user}","gists_url":"https://api.github.com/users/Lambda-X/gists{/gist_id}","starred_url":"https://api.github.com/users/Lambda-X/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/Lambda-X/subscriptions","organizations_url":"https://api.github.com/users/Lambda-X/orgs","repos_url":"https://api.github.com/users/Lambda-X/repos","events_url":"https://api.github.com/users/Lambda-X/events{/privacy}","received_events_url":"https://api.github.com/users/Lambda-X/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/Lambda-X/lambdax-blog","description":"The official blog of LambdaX","fork":false,"url":"https://api.github.com/repos/Lambda-X/lambdax-blog","forks_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/forks","keys_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/keys{/key_id}","collaborators_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/teams","hooks_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/hooks","issue_events_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues/events{/number}","events_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/events","assignees_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/assignees{/user}","branches_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/branches{/branch}","tags_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/tags","blobs_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/refs{/sha}","trees_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/trees{/sha}","statuses_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/statuses/{sha}","languages_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/languages","stargazers_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/stargazers","contributors_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/contributors","subscribers_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/subscribers","subscription_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/subscription","commits_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/commits{/sha}","git_commits_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/git/commits{/sha}","comments_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/comments{/number}","issue_comment_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues/comments{/number}","contents_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/contents/{+path}","compare_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/compare/{base}...{head}","merges_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/merges","archive_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/downloads","issues_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues{/number}","pulls_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls{/number}","milestones_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/milestones{/number}","notifications_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/labels{/name}","releases_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/releases{/id}","deployments_url":"https://api.github.com/repos/Lambda-X/lambdax-blog/deployments","created_at":"2016-01-21T10:07:24Z","updated_at":"2016-03-24T17:44:46Z","pushed_at":"2016-04-12T17:29:39Z","git_url":"git://github.com/Lambda-X/lambdax-blog.git","ssh_url":"git@github.com:Lambda-X/lambdax-blog.git","clone_url":"https://github.com/Lambda-X/lambdax-blog.git","svn_url":"https://github.com/Lambda-X/lambdax-blog","homepage":"","size":1946,"stargazers_count":1,"watchers_count":1,"language":"JavaScript","has_issues":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":0,"mirror_url":null,"open_issues_count":3,"forks":0,"open_issues":3,"watchers":1,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/72"},"html":{"href":"https://github.com/Lambda-X/lambdax-blog/pull/72"},"issue":{"href":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues/72"},"comments":{"href":"https://api.github.com/repos/Lambda-X/lambdax-blog/issues/72/comments"},"review_comments":{"href":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/72/comments"},"review_comment":{"href":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/Lambda-X/lambdax-blog/pulls/72/commits"},"statuses":{"href":"https://api.github.com/repos/Lambda-X/lambdax-blog/statuses/ca2dff7aa35f9f8a4bd8556ac10cc4693a0cefb6"}}}}