Merge branch 'master' of https://github.com/moldedbits/moldedbits.github.io

Author: aksswami

CNAME

@@ -0,0 +1 @@
+eng.moldedbits.com

Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gem 'github-pages', group: :jekyll_plugins

Gemfile.lock

@@ -0,0 +1,217 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.8)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.5.2)
+      public_suffix (>= 2.0.2, < 4.0)
+    coffee-script (2.4.1)
+      coffee-script-source
+      execjs
+    coffee-script-source (1.12.2)
+    colorator (1.1.0)
+    ethon (0.10.1)
+      ffi (>= 1.3.0)
+    execjs (2.7.0)
+    faraday (0.13.1)
+      multipart-post (>= 1.2, < 3)
+    ffi (1.9.18)
+    forwardable-extended (2.6.0)
+    gemoji (3.0.0)
+    github-pages (157)
+      activesupport (= 4.2.8)
+      github-pages-health-check (= 1.3.5)
+      jekyll (= 3.5.2)
+      jekyll-avatar (= 0.4.2)
+      jekyll-coffeescript (= 1.0.1)
+      jekyll-default-layout (= 0.1.4)
+      jekyll-feed (= 0.9.2)
+      jekyll-gist (= 1.4.1)
+      jekyll-github-metadata (= 2.9.1)
+      jekyll-mentions (= 1.2.0)
+      jekyll-optional-front-matter (= 0.2.0)
+      jekyll-paginate (= 1.1.0)
+      jekyll-readme-index (= 0.1.0)
+      jekyll-redirect-from (= 0.12.1)
+      jekyll-relative-links (= 0.4.1)
+      jekyll-sass-converter (= 1.5.0)
+      jekyll-seo-tag (= 2.3.0)
+      jekyll-sitemap (= 1.0.0)
+      jekyll-swiss (= 0.4.0)
+      jekyll-theme-architect (= 0.1.0)
+      jekyll-theme-cayman (= 0.1.0)
+      jekyll-theme-dinky (= 0.1.0)
+      jekyll-theme-hacker (= 0.1.0)
+      jekyll-theme-leap-day (= 0.1.0)
+      jekyll-theme-merlot (= 0.1.0)
+      jekyll-theme-midnight (= 0.1.0)
+      jekyll-theme-minimal (= 0.1.0)
+      jekyll-theme-modernist (= 0.1.0)
+      jekyll-theme-primer (= 0.5.2)
+      jekyll-theme-slate (= 0.1.0)
+      jekyll-theme-tactile (= 0.1.0)
+      jekyll-theme-time-machine (= 0.1.0)
+      jekyll-titles-from-headings (= 0.4.0)
+      jemoji (= 0.8.0)
+      kramdown (= 1.13.2)
+      liquid (= 4.0.0)
+      listen (= 3.0.6)
+      mercenary (~> 0.3)
+      minima (= 2.1.1)
+      rouge (= 1.11.1)
+      terminal-table (~> 1.4)
+    github-pages-health-check (1.3.5)
+      addressable (~> 2.3)
+      net-dns (~> 0.8)
+      octokit (~> 4.0)
+      public_suffix (~> 2.0)
+      typhoeus (~> 0.7)
+    html-pipeline (2.7.0)
+      activesupport (>= 2)
+      nokogiri (>= 1.4)
+    i18n (0.8.6)
+    jekyll (3.5.2)
+      addressable (~> 2.4)
+      colorator (~> 1.0)
+      jekyll-sass-converter (~> 1.0)
+      jekyll-watch (~> 1.1)
+      kramdown (~> 1.3)
+      liquid (~> 4.0)
+      mercenary (~> 0.3.3)
+      pathutil (~> 0.9)
+      rouge (~> 1.7)
+      safe_yaml (~> 1.0)
+    jekyll-avatar (0.4.2)
+      jekyll (~> 3.0)
+    jekyll-coffeescript (1.0.1)
+      coffee-script (~> 2.2)
+    jekyll-default-layout (0.1.4)
+      jekyll (~> 3.0)
+    jekyll-feed (0.9.2)
+      jekyll (~> 3.3)
+    jekyll-gist (1.4.1)
+      octokit (~> 4.2)
+    jekyll-github-metadata (2.9.1)
+      jekyll (~> 3.1)
+      octokit (~> 4.0, != 4.4.0)
+    jekyll-mentions (1.2.0)
+      activesupport (~> 4.0)
+      html-pipeline (~> 2.3)
+      jekyll (~> 3.0)
+    jekyll-optional-front-matter (0.2.0)
+      jekyll (~> 3.0)
+    jekyll-paginate (1.1.0)
+    jekyll-readme-index (0.1.0)
+      jekyll (~> 3.0)
+    jekyll-redirect-from (0.12.1)
+      jekyll (~> 3.3)
+    jekyll-relative-links (0.4.1)
+      jekyll (~> 3.3)
+    jekyll-sass-converter (1.5.0)
+      sass (~> 3.4)
+    jekyll-seo-tag (2.3.0)
+      jekyll (~> 3.3)
+    jekyll-sitemap (1.0.0)
+      jekyll (~> 3.3)
+    jekyll-swiss (0.4.0)
+    jekyll-theme-architect (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-cayman (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-dinky (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-hacker (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-leap-day (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-merlot (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-midnight (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-minimal (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-modernist (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-primer (0.5.2)
+      jekyll (~> 3.5)
+      jekyll-github-metadata (~> 2.9)
+      jekyll-seo-tag (~> 2.2)
+    jekyll-theme-slate (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-tactile (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-theme-time-machine (0.1.0)
+      jekyll (~> 3.5)
+      jekyll-seo-tag (~> 2.0)
+    jekyll-titles-from-headings (0.4.0)
+      jekyll (~> 3.3)
+    jekyll-watch (1.5.0)
+      listen (~> 3.0, < 3.1)
+    jemoji (0.8.0)
+      activesupport (~> 4.0)
+      gemoji (~> 3.0)
+      html-pipeline (~> 2.2)
+      jekyll (>= 3.0)
+    kramdown (1.13.2)
+    liquid (4.0.0)
+    listen (3.0.6)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9.7)
+    mercenary (0.3.6)
+    mini_portile2 (2.2.0)
+    minima (2.1.1)
+      jekyll (~> 3.3)
+    minitest (5.10.3)
+    multipart-post (2.0.0)
+    net-dns (0.8.0)
+    nokogiri (1.8.0)
+      mini_portile2 (~> 2.2.0)
+    octokit (4.7.0)
+      sawyer (~> 0.8.0, >= 0.5.3)
+    pathutil (0.14.0)
+      forwardable-extended (~> 2.6)
+    public_suffix (2.0.5)
+    rb-fsevent (0.10.2)
+    rb-inotify (0.9.10)
+      ffi (>= 0.5.0, < 2)
+    rouge (1.11.1)
+    safe_yaml (1.0.4)
+    sass (3.5.1)
+      sass-listen (~> 4.0.0)
+    sass-listen (4.0.0)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    sawyer (0.8.1)
+      addressable (>= 2.3.5, < 2.6)
+      faraday (~> 0.8, < 1.0)
+    terminal-table (1.8.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
+    thread_safe (0.3.6)
+    typhoeus (0.8.0)
+      ethon (>= 0.8.0)
+    tzinfo (1.2.3)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  github-pages
+
+BUNDLED WITH
+   1.14.6

_posts/2017-08-28-the-rx-way.md

@@ -0,0 +1,135 @@
+---
+layout: post
+title:  "The Rx way of doing things"
+date:   2017-08-28 8:00:00
+author: abhishek
+categories: Reactive-Programming
+---
+We have been trying to include more and more reactive approach in apps that we build at [moldedbits](http:///www.moldedbits.com). Now that I am little more  comfortable with reactive way of doing things I decided to write a blog on reactive vs imperative way of solving a problem. I will try to explain how reactive programming makes developer's life easy by doing more in less code.
+
+### Problem Statement
+Consider following problem statement
+
+1. You have to make an API call which returns a map of ObjectId to Object
+2. You need to convert this map to a list of objects which contain object-id
+3. Now you need to filter some objects from this list
+4. For each of these filtered objects you need to do another API call.
+5. Above API calls should be done sequentially and each subsequent API call should be done after a delay of 100 ms.
+
+This is a real life scenario. I had written implementation for this in one of our Android app. We use [Retrofit](http://square.github.io/retrofit/) for networking, [RxJava-2](https://github.com/ReactiveX/RxJava) for reactive programming and [Retrolambda](https://github.com/orfjackal/retrolambda) for Java8 like syntax and boilerplate reduction.
+
+Now think about how you will implement this in imperative world.
+
+### The Imperative Way
+
+Let me help you. In an imperative world
+
+1. You will probably do an API call with help of Retrofit(if you are using retrofit) or in a AsyncTask.
+2. When this API returns you will iterate the map and convert it in a list on main thread (off-course you can do it in a different thread but I want to keep things simple).
+3. After which you would do a second iteration for filtering out desired objects.
+4. Now things get interesting as you need to perform API calls for each of these remaining objects in list. You probably will need to write a Service or AsyncTask which now performs synchronous API calls after a sleep of 100ms.
+
+Now that is lot of work and I am not even considering edge cases and error handling for sake of simplicity. Think of the case when API returns a large list of objects and you can't afford to process that on main thread.
+
+Well, Rx does all this heavy lifting for you. Lets see how.
+
+### The Rx Way
+
+Reactive programming is totally a different approach towards writing code. Everything in reactive world is considered a stream. These streams are immutable and there are plethora of operators available which operate on these streams. Real power of reactive programming lies in these tried and tested operators.
+
+Rx makes task of switching between the thread as easy as having an apple pie. Our above said problem statement can be accomplished by mere 10 lines of code with RxJava. Here is a sample from production code
+
+{% highlight java %}
+APIProvider.getInstance().getService().getMyObjects(userName)
+  .subscribeOn(Schedules.io())
+  .map(MyObject::toList)
+  .flatMap(rx.Observable::from)
+  .filter(myObject->myObject.getName().equals(Constants.SOME_NAME))
+  // adding a 10ms delay in subsequent api calls
+  .flatMap(myObject -> Observable.timer(100, TimeUnit.MILLISECONDS).map(y -> myObject))
+  .doOnNext(rule -> {
+      // deleting my object one by one
+      APIProvider.getInstance()
+        .getService().deleteMyObject(userName, rule.getId())
+        .subscribe();
+  }).subscribe();
+{% endhighlight %}
+
+lets understand this code line by line
+
+```
+APIProvider.getInstance().getService().getMyObjects(userName)
+```
+Its `Retrofit` way of doing an API call. This API returns a map of `MyObjectId` to `MyObject`. An example JSON looks like this
+{% highlight json %}
+{
+  "1": {
+    "name": "object1"
+  },
+  "2": {
+    "name": "object2"
+  }
+}
+{% endhighlight %}
+
+```
+.subscribeOn(Schedules.io())
+```
+`subscribeOn` is an Rx operator which directs RxJava to start processing on scheduler thread (a background thread). Just this line lets you switch your processing to a background thread. How cool is that!
+
+```
+.map(MyObject::toList)
+```
+`Map` is transformation operator which allows us to convert things. Here we are converting `Map` to `List`. `toList` is a static method written in `MyObject` class. This method converts a `Map<ObjectId, MyObject>` to `List<MyObject>`. List version has object id's in object itself. `MyObject::toList` is Java 8 way of calling this method, Its named as [Method Reference](https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html). Transformed data structure now looks like this
+{% highlight json %}
+[
+  {
+    "id": "1",
+    "name": "object1"
+  },
+  {
+    "id": "2",
+    "name": "object2"
+  }
+]
+{% endhighlight %}
+
+```
+.flatMap(rx.Observable::from)
+```
+
+This statement allows us to receive each `MyObject` as separate event on observable stream. Before this we were having whole List or Map as single event on observable stream. To perform filtering and API calls on each of these separately we need to have them as independent events on stream.
+
+```
+.filter(myObject->myObject.getName().equals(Constants.SOME_NAME))
+```
+
+This is pretty obvious. `filter` operator allows us to filter out events which do not match filtering criteria. Any object whose name does not match with `Constants.SOME_NAME` is not allowed to propagate further in stream.
+
+```
+.flatMap(myObject -> Observable.timer(100, TimeUnit.MILLISECONDS).map(y -> myObject))
+```
+
+This interesting piece of code is allowing us to add a delay of 100 milliseconds between subsequent results. Inside `flatmap` we are creating another stream using [`Timer`](http://reactivex.io/documentation/operators/timer.html) observable. As per documentation `Timer` returns an Observable that emits a single number zero after a delay period you specify. Since, we do not want to loose our `MyObjects` we need to map this zero back to `MyObject`. Outer `flatmap` is making sure that event are received on current stream.
+
+```
+doOnNext(myObject -> {
+    // deleting my object one by one
+    APIProvider.getInstance()
+      .getService().deleteMyObject(userName, myObject.getId())
+      .subscribe();
+})
+```
+
+Finally, since we have nice stream of `MyObjects` including a delay of 100ms we can perform our API calls. That is what is happening inside `doOnNext` operator. `doOnNext` operator allows us add a hook on each event in a stream.
+
+```
+.subscribe()
+```
+Fire! this is what this operator does. This the simplest version of [`Subscribe`](http://reactivex.io/documentation/operators/subscribe.html) operator that we have used here. You can read more about it in docs.
+
+ If you have noticed, all this work is happening in a background thread without us having to worry about anything. In my case I had no need to process API results in Android main thread but in case if you do you can just use [`ObserveOn`](http://reactivex.io/documentation/operators/observeon.html) operator to switch threads any time.
+
+So what do you think about it? Let me know in comments.
+
+Happy Coding !!