https://hackernoon.com/how-it-feels-to-learn-javascript-in-2016-d3a717dd577f#.r1tzvvyb8

From hacker news, what's your favorite tech talk? I love tech talks, I try to watch at least 3 new each week this hacker news post will be on my favs tab for a couple of weeks.
https://news.ycombinator.com/item?id=12637239&utmsource=hackernewsletter&utmmedium=email&utmterm=askhn

Code wars now supports Elixir This is the best news ever! I'm a great enthusiastic from Elixir and codewars. Gonna make some of their katas on elixir and contribute with new ones for sure
http://www.codewars.com/

Talking about Elixir this blog post covers how to monitor and Phoenix application in 2016. Nice for those who deploying your elixir apps and need some better monitoring. http://aldusleaf.org/monitoring-elixir-apps-in-2016-prometheus-and-grafana/

I'm a huge enthusiast of GraphQL concepts but I hadn't had time to play around with it. But I liked this talk that is on speakerdeck and hopefully soon on youtube
https://speakerdeck.com/benwilson512/no-rest-for-the-wicked

Another thing that I've been doing is play more around with golang. This links explaining about the flags has helped me a lot
http://golang.rakyll.org/go-tool-flags/?utmsource=golangweekly&utmmedium=email

As everybody knows I'm in love with elixir-lang. Elixir lang is the best thing that I saw in the programming world for a long time. I've been following the elixir-core mail list for a long time (guess since the very beginning). And now I have kudos about this discussion. Deprecating the single quotes erlang string for a sigils may facilitate things especially for newcomers
https://groups.google.com/forum/?utmmedium=email&utmsource=footer#!msg/elixir-lang-core/_pAjPEayLLI/G66JQEWvBAAJ

Last but not least There's mruby. A not new but still exciting way to put ruby code into embedded or minimal software. I've download, played a little with it and of course I created some small integration with a golang code. I may look better into this in the future.
http://mruby.org/

First step: configure

At first we need to configure our environment to check everything that we can do. Luckily Erlang has a nice command line tool that helps we check our environment and set all environment variables before we get started. So after download the source code, just type $ ./otp_build autoconf and we will have a nice set of configuration option to start with.

After that command we will gain a 'configure' command that is the command that will actually check all our dependencies. So just run $ ./configure and wait for it.

At the end of the execution we may have a couple of problems. In my case I have with two libraries, crypto and odbc with erros like ODBC library - link check failed. For crypto to works fine we need to install and link openssl properly. Using brew just makes sure you have the latest version of openssl

$ brew update

$ brew install openssl

Then we need to link open ssl. Once we may have some linked files that conflicts with us we need to pass the --force option

$ brew link openssl --force

Crypto must be fine by now. We then need to configure odbc which I found a bit trickier, once it was not a problem in the past. First install unixodbc then some installation paths by using odbc_config.

$ brew install unixodbc

$ odbc_config --libs
# -L/usr/local/Cellar/unixodbc/2.3.4/lib -lodbc
$ odbc_config --include-prefix
# /usr/local/Cellar/unixodbc/2.3.4/include

Those two configurations paths we will be using to configure our installation again with the flags CFLAGS and LDFLAGS So just type on the configure phase something similar to this (depending on your output):

$ ./configure CFLAGS="-I/usr/local/include" LDFLAGS="-L/usr/local/lib -lodbc"

After a coupe of minutes your environment must be ok for the newest erlang version compiled directly from source. So now you just need to continue with the basic make and sudo make install.

Recently, I've decided to take a better look on Agents and I must admit that I started to like it. I'm use then to play around with some small projects, instead of store data in a full featured DB, it's been a good way to play around.

Agent 101

Agent's a simple process that stores and retrieves data given function. For example.

# Starts an agent proccess with a new MapSet
Agent.start_link(fn -> MapSet.new end, name: :people)  
# {:ok, #PID<0.59.0>}

# Put some data on the Mapset
Agent.update(:people, fn(people_set) ->  
  MapSet.put people_set, %{name: "John Doe"}
end)  
# :ok
Agent.update(:people, fn(people_set) ->  
  MapSet.put people_set, %{name: "Charlie Brown"}
end)  
# :ok
Agent.update(:people, fn(people_set) ->  
  MapSet.put people_set, %{name: "Pedro Medeiros"}
end)  
# :ok

# Recover the data once inserted
Agent.get(:people, fn(people_set) -> people_set end)  
# #MapSet<[%{name: "Charlie Brown"}, %{name: "John Doe"}, %{name: "Pedro Medeiros"}]>

As we can see we start a process giving it a name (people) and when we need to do any operation on our agent named :people, all we need to do is pass the atom as the first argument, which can also be a PID of the process.

Now that we have the basics of Agents, let's move on creating a new Agent which is unique for our application. let's call this module PeopleStore. Turns out that Module names are atoms on elixir, so we can easily use then as the name of our Agent.

# people_store.ex
defmodule PeopleStore do  
  def start_link do
    Agent.start_link(fn -> MapSet.new end, name: __MODULE__)
  end
end  

Now that we have the agent up and running when we run start_link, let's do some operational over it. Notice that we used __MODULE__ syntax, which is the equivalent to the model name PeopleStore

# people_store.ex
# ...
  def add_person person do
    __MODULE__
      |> Agent.update(fn people -> 
           MapSet.put people, person
         end)
  end

Let's say that our users has names that is unique, and we want to retrieve a person based on a name field. We can achieve this by implement our Agent.get/2 with Enum.find/2

# people_store.ex
# ...

  def get_person name do
    __MODULE__
      |> Agent.get(fn people ->
           Enum.find people, &(&1.name == name)
         end)
  end

On Enum.find function we used a shortcut function operator, which is just a syntax sugar for fn x -> x.name == name end. It's visible how it can be simple for small things, it uses &N to determine the argument position of the callback function.

Now with our PeopleStore we can store people and search for people based on name. I'm using it sometimes to fake some test data, It's really useful. And being a GenServer we known It won't have concurrency issues, once an Agent will only do one thing at the time.

Let's See our final Example on using our brand new PeopleStore

AgentStore.start_link #important to instanciate it in memory

AgentStore.add_person(%{name: "john doe"})  
AgentStore.add_person(%{name: "Foo bar"})  
AgentStore.add_person(%{name: "Dave"})

person = Agent.get_person("john doe")

IO.puts("just found #{person.name}")  
# Just found john doe

The safe operator is just some simpler way to do something that we already have in rails. But now this feature is in the core language.

Now show me the code. On rails is pretty common to have errors like this

> @current_user.trophy.title
# NoMethodError: undefined method `title' for nil:NilClass

On this little fix solves this problem

> @current_user.trophy.try(:title)
# nil

There's no error raised if one uses the try operator. That's pretty cool. Unfortunately It is limited to the rails stack. Now with the new ruby 2.3.0 is possible to use the safe operator which was attributed to the & key word.

Now the same behaviour we can extend with

> @current_user.trophy.&title
# nil

Now is much safer to write code in plain ruby.

New times has come, and wiht it I discovery a new guy that does the same job and has a really nice support for rails 4.2. Meet refile. Just like paperclip and carrierwave it provides full support to manipulate images, validates types and facilitates data trasnfer with support to cloud servers like amazon s3.

To get started with refile first let's create a scaffold for post and later we will attach an image to the post.

bundle exec rails g scaffold post tittle:string content:text image_id:string

We added an image attribute with the sufix _id, refile requires that to work. Do not forget that. Then is time to open our model and puts an attachement into it

class Post < ActiveRecord::BASE  
  attachment :image
end  

Now we can integrate our upload input into our view with the refile helper to create a upload field at our /views/posts/_form.html.erb

<%= form_for @post do |f| %>  
  <%= f.attachment_field :image %>
<% end %>  

At our PostsController don't forget the change the permit of strong parameters to validates image and not image_id.

def post_params  
  params.require(:post).permit(:image) # not :image_id
end  

Now we are set. We can now create a new post with image and file upload. But now we need to vizualize then. Refile provides a helper for that. just add it to our view.

<%= image_tag attachment_url(@post, :image, :fill, 150, 150, format: "jpg") %>  

Yey! now we have our app up and running with the refile gem.

The rules of FizzBuzz are:
The program must output a line from 1 to a given number with three exceptions:

1. If the value of that line is divided by 3 then the output must be Fizz.
2. If the value of that line is divided by 5 then the output must be Buzz.
3. If the value of that line is divided by 3 and by 5 the output of that line must be FizzBuzz.

Now that we have all the rules. Let's start by creating a new app. The fist step is to type mix new fizz_buzz at the terminal we will see this output:

* creating README.md
* creating .gitignore
* creating mix.exs
* creating config
* creating config/config.exs
* creating lib
* creating lib/fizz_buzz.ex
* creating test
* creating test/test_helper.exs
* creating test/fizz_buzz_test.exs

Your mix project was created successfully.  
You can use mix to compile it, test it, and more:

    cd fizz_buzz
    mix test

Run `mix help` for more commands.  

Our app is now created, we can now enter at the fizz_buzz folder and see the file structure for a typical elixir app. The three most important files are the mix.exs, test/fizz_buzz_test.exs and lib/fizz_buzz.ex. mix.exs is the file that configures your project. It has 2 main public functions application and project. The project function must return a list with the project information just as the app name, the app version and its dependencies. The application function is where you put the information that will be used to generate an .app file.

# mix.exs
defmodule FizzBuzz.Mixfile do  
  use Mix.Project

  def project do
    [app: :fizz_buzz,
     version: "0.0.1",
     elixir: "~> 1.1.0-dev",
     deps: deps]
  end

  def application do
    [applications: [:logger]]
  end

  defp deps do
    []
  end
end  

The lib/fizz_buzz.ex is the file generated that is intended to be the main file of our app. It is created by default and only has an empty module to be implemented.

# fizz_buzz.ex
defmodule FizzBuzz do  
end  

The test/fizz_buzz_test.exs file is where you put your tests. In fact every file that lies inside the test will be executed as a test file. By default when we create a project, mix creates a simple test that tests if 1 + 1 is equals 2.

# fizz_buzz_test.exs
defmodule FizzBuzzTest do  
  use ExUnit.Case

  test "the truth" do
    assert 1 + 1 == 2
  end
end  

You can run this test with mix test command at the root of the project. We will see that our test will be pass. Try changing the value of the sum from 2 to 3 and see what happens.

Let's start to implement our FizzBuzz by writing some tests. First Let's create a test. Guess the first thing that we got to do is to create the first test from 1 to 3 where it will output this:

1  
2  
Fizz  

And here is the code of the test.

  test "compute values from 1 to 3" do
    expected_result = """
    1
    2
    Fizz
    """
    assert FizzBuzz.compute(3) == expected_result
  end

If we try to run the tests again we will see an error. Saying that the function compute/0 is not defined. Let's go and implement it.

# fizz_buzz.ex
defmodule FizzBuzz do  
  def compute(number) do
    """
    1
    2
    Fizz
    """
  end
end  

Aha! I bet you already realized what I did. In elixir the last expressions is the return value of the function. So what our function does is just returning the expected output for our test. if we run mix test we will see that everything is passing and we are very happy. This is part of the TDD philosophy, first we write the test and it should fail, then we write a small piece of software so the test can pass. Then finally we refactor the code. We already known what we want so we can go straight to our code.

defmodule FizzBuzz do  
  def compute(number) when number > 1 do
    compute(number - 1) <> output_line(number)
  end

  def compute(1) do
    output_line(1)
  end

  defp output_line(number) do
    if rem(number, 3) == 0 do
      "Fizz\n"
    else
      "#{number}\n"
    end
  end
end  

We can see that at our function compute/1 definition we are defining some rules for two specific cases. In Elixir what makes a function signature is its names and its arity (number of values you can pass to a function). But we can define some rules for a function to execute, just like we did with when. Note that we are using recursion instead of using a conventional loop, it's a common thing at functional languages to use recursion calls. Run mix test and our test pass. Let's write the test to print until 5 so we can see the Buzz word at screen.

  test "compute values from 1 to 5" do
    expected_result = """
    1
    2
    Fizz
    4
    Buzz
    """
    assert FizzBuzz.compute(5) == expected_result
  end

If we try to run this test it will fail. This is because we have not implemented a rule of what happens when the number is divided by 5. Since we have refactored our code before, we can just modify our output_line/1 function and just add some simple rule there and everything will pass! yey!

  defp output_line(number) do
    if rem(number, 3) == 0 do
      "Fizz\n"
    else
      if rem(number, 5) == 0 do
        "Buzz\n"
      else
        "#{number}\n"
      end
    end
  end

Now that everything is passing we can try to refactor that code. I really don't like the inner block thing that we are producing for every new rule we must explicitly create a new if block and close it. Let's try another conditional that is more clear to use.

  defp output_line(number) do
    cond do
      rem(number, 3) == 0 ->
        "Fizz\n"
      rem(number, 5) == 0 ->
        "Buzz\n"
      true ->
        "#{number}\n"
    end
  end

Okay now just one more case we must cover that is if the number is divided by 3 and 5 at the same time. First let's write our test case until 15 run the tests and see it failing.

  test "compute values from 1 to 15" do
    expected_result = "1\n2\nFizz\n4\nBuzz\nFizz\n7\n8\nFizz\nBuzz\n11\nFizz\n13\n14\nFizzBuzz\n"
    assert FizzBuzz.compute(15) == expected_result
  end

It fails as expected let's write the last rule first so we can make sure it has a higher precedent.

  defp output_line(number) do
    cond do
      rem(number, 3) == 0 && rem(number, 5) == 0 ->
        "FizzBuzz\n"
      rem(number, 3) == 0 ->
        "Fizz\n"
      rem(number, 5) == 0 ->
        "Buzz\n"
      true ->
        "#{number}\n"
    end
  end

And our tests are passing again. By this time we must already solve the problem. You can try by creating a string that goes from 1 to 100 and will see that our tests will pass. At this point we have our mix application completely done. We can run test on it. Now let's try to run our code at the console. If we type iex -S mix we will enter at an interactive Elixir console and we will have access to all our code thought here. Let's try by typing FizzBuzz.compute(5). The output of our FizzBuzz challenge is done there. And you can try any other value that you want.

This was a quick introduction to mix, a build tool that ships with Elixir. There's a lot to go from here. But having a such nice tool to create a project with a full functional test suite is already great.

In the official web site there's a page that show all the currently possibilities to install elixir in your machine. There are packages for Mac (port, brew), gentoo, arch, fedora and more. I prefer to install with the precompiled packages but for that one must isntall erlang first. Here we can see an easy way to setup our environment to run Erlang and Elixir on our machine. The current version of Elixir requires Erlang 17 or superior. So be sure to install the right version of Erlang first.

Once we setup our environment properly We have four new executables in our environment elixir that can run our elixir code. elixirc to compile the code to a .beam extension to run at the Erlang VM. mix to create and manage our app with the properly steps and dependencies. And lastly iex, and iterative tool to run and evaluate elixir code on the fly. To get start jus type > iex in your terminal and you can start running some code.

iex > name = "John"  
"John"
iex > "Hello #{name}"  
"Hello John"

With this code we could start our Hello World. iex evaluate every line of code and output the result for each of then. In this example we can see a string interpolation, a nice feature of elixir. By using #{} we can represent represent any value inside a string without concatenating it explicitly. You can try doing some simple operations in the terminal. such as sum two integer with + or concatenate two strings with <>.

One thing about Elixir and the Erlang VM. Is that there's no mutability. In Erlang if you assign a value to a variable you can't reassign it later. as if you can see bellow, it shows an error if you try to assign the value again. That happens because the = operator is not an assignment operator but a matching operator.

X = 1.  
1  
X = 2.  
** exception error: no match of right hand side value 2

At the first time we do X = 1 erlang see if X is matched to any value. If it is not matched it will bind 1 to X. Once X is bind to 1 if you try to do the match again it will see that 1 is not 2 and an error will occur. Elixir is a little bit different from that. Duo the fact that elixir is build on top of the Erlang VM immutability will maintain, but with Elixir it is possible to reassign a value to another variable more than once.

iex> x = 1  
1  
iex> x = 2  
2  

One example that we illustrates great the immutability aspect of elixir is how it handles Lists. If we create a list [1,2,3] and than we want to perform an operation at the List, like update a value from it. What Elixir will do is create another list with the new values and return it just like the docs explain. That way we are assigning a new array with the updated values to the variable a.

iex> a = [1,2,3]  
[1, 2, 3]
iex> a = List.replace_at(a, 1, 10)  
[1, 10, 3]

With the basics up and ready let's do some code that can be compiled and executed. Basically, Elixir organize everything in modules. The modules contain names functions that can have public or private assessors. Let's write a hello world file names hello.ex

# hello.ex
defmodule HelloWorld do

  def say_hello(name) do
    IO.puts("Hello #{name}")
  end

end

HelloWorld.say_hello("John")  

Now that we have our file let's run the code. To run this just type on command line elixir hello.ex and you will see the Hello World message popup. But wait, Didn't I said that elixir compiles code to run on Erlang VM. For that we have the command elixirc. If you run elixirc hello.ex it will produce the compiled file Elixir.HelloWorld.beam, which it is just the binary that will load your code into the Erlang VM. Once generated if you enter into iex from that folder you can type HelloWorld.say_hello("Paul") and your code will run. This is because it is already compiled into a .beam file.

This is the quickstart of the language itself. With this basic structure to start to understand how an Elixir app is build. The next step to go from here is to understand how mix can make our life easy by integrating some tests to our code and by help with dependency management.

But as a unfortunately surprise. The current version of devise doesn't work with the new version of rails. So I had to go to other fast alternative. Searching over the web I came across authlogic. I remember that I was using authlogic at my previous job with one specific web, and it worked ok. For my surprise it worked really well with Rails 4.2.0.beta. The only thing that I found confusing was the documentation. It's not as clear as the devise one. But here we go step by step.

First thing I did was put the gem at the gem file.

gem 'authlogic', '~> 3.4.2'  

Then we run bundle install to install dependencies and we are ready to create our model. One can create a model with any field that is needed just remember to include some fields that are necessary for authlogic to operate. such as login, email, crypted_password, password_salt and persistence_token. You can choose to have only login or email. But if you have both fields authlogic will lookup for both. This is an example of my model migration.

class CreateUsers < ActiveRecord::Migration  
  def change
    create_table :users do |t|
      t.string :login
      t.string :name

      t.string :crypted_password
      t.string :password_salt
      t.string :persistence_token

      t.integer :login_count
      t.integer :failed_login_count
      t.datetime :last_request_at
      t.datetime :current_login_at
      t.datetime :last_login_at
      t.string :current_login_ip
      t.string :last_login_ip

      t.timestamps null: false
    end
  end
end  

Those last fields are from the documentation module MagicColumns. If you have then at your athlogic model they will be used by the library, but you can simply ignore then.

Then is time to tell that your model itself will use authlogic. For that authlogic provides a method named acts_as_authentic which accepts a block of code for configuration. I really had a hard time to find more information about all the possible options it accepts but the one that I really wanted to use was easy to find. That was how to set the crypto provider to use bcrypt.

class User < ActiveRecord::Base  
  acts_as_authentic do |c|
    c.crypto_provider = Authlogic::CryptoProviders::BCrypt
  end
end  

Authlogic expect us to create a Session model so it can use it to create and restore our session object for that I just placed over the models folder a class named UserSession that inherits from Authlogic::Session::Base

class UserSession < Authlogic::Session::Base  
end  

Then It was time to create a controller and a view that would handle the authentication actions. I created then a controller just for that with 3 actions new, create and destroy, just like the rails resource way. and created our form to handle the login properly.

#routes.rb
resource :user_session, only: [:create, :new, :destroy]  

class UserSessionsController < ApplicationController  
  def new
    @user = User.new
  end

  def create
    @user_session = UserSession.new params.require(:user)
      .permit(:login, :password)
    if @user_session.save
      redirect_to root_path
    else
      redirect_to new_user_session_path
    end
  end

  def destroy
    current_user_session.destroy
    redirect_to new_user_session_path
  end
end  

<!-- app/views/user_sessions/new.html.erb -->  
<%= form_for @user, url: user_session_path, method: :post, html: { class: 'form-horizontal', role: 'form' } do |f| %>  
  <div class='form-group'>
    <%= f.text_field :login, class: 'form-control', placeholder: 'Login' %>
  </div>
  <div class='form-group'>
    <%= f.password_field :password, class: 'form-control', placeholder: 'Password' %>
  </div>
  <%= f.submit 'Login', class: 'btn btn-primary' %>
  <% end %>
<% end %>  

Now is time to create our helper methods at the controller so we can access it across our application. For that I just follow what Ryan Bates did on that outdated (but f##### useful) railscasts).

class ApplicationController < ActionController::Base  
  self.responder = ApplicationResponder
  helper_method :current_user_session, :current_user

# ...

private  
  def current_user_session
    @current_user_session ||= UserSession.find
  end

  def current_user
    @current_user ||= current_user_session && current_user_session.user
  end
end  

We can place that helper method in any part of our app to verify if the user is logged in. and to permit access to certain actions.

Conclusion

It was not hard at all to setup authlogic I can happily use it during all my app development. But to tell the truth I can't wait to go back to devise just for the good documentation and examples. That is the thing that authlogic lacks the most. But it is an good and easy library to setup.

I’m a native C++ programmer. What that means is that C++ is my first programming language that I learned for good, and was by coding c++ that I’ve learned to love to programing and is the thing that I do everyday, doesn’t matter if it is for my day job work, I’m always writing some piece of code for whatever reasons. Unfortunately, C++ was not so good to supply my old necessities anymore like it used to. I wanted to get the job done fast and to complete my goals as fast as I can with an elegant code. That was when I learned Java, a.k.a The biggest mistake of my life. Java has a error proof way that is nice for some people that are already into C++, but it was not I was really looking for. It seems that It took a lot of the verbose of C++, simplified a little with not a worth gain. It was when I met ruby, javascript, node, python and programming friendly languages like that.

Those kind of scripting languages were a game changer for me. I could do what I wanted as fast as I could and with such expressiveness that I could not find either in C++ or in Java. So I left C++ behind for sometimes. I really wish I could left Java behind too, but I always had to code something or another in Java because the IT world, specially in Brazil, basically breaths Java.

During the time I was looking for expressiveness and fast development, I ended up going away from some system development and away from some root concepts that I was missing somehow. So In the last years I ended up reading some articles about programming in C++ again and I was looking for what was new in other languages, like Scala, Go, Rust. I had to say. I really liked what Rust and Go are promising. But I just can’t introduce any of those languages to the table of the companies that are not wiling to try new things just yet. So I have to dig in deeper on what they are using and propose some changes based on what they are actually doing. So I’m relearning to fly on C++ code.

I bet that the hardest thing is going to be how to make a 100% portable code. I never was a biggest windows fan. All my development stack are based on *nix systems. But one thing that I learned is that C++ is widely used on Windows development. Here where I live mostly of the people that are programming on C++ are using Windows for development. That scares me a little, but that’s just how it is. I did not decided yet how I’m going to do that. But I’m starting by reading some basic C++ concepts and hopeful I’m gonna keep updating my status on that.

And of course I’m planning on write some more on c++ development.

database.getUserProfile(function(profile, err){  
  if(!err){
    networkAdapter.getTwitterInfo(profile.twitterUrl, function(twitterData, err){
      if (!err){
        database.getFriendsFromTwitter(twitterData, function(friends, err){
          if(!err) {
            var friendsOnTwitter = friends.map(function(friend){
              return friend.userName;
            });
            sendResponse(friendsOnTwitter);
          }
        });
      }
    });
  }
});

There are up to 6 levels of indentation on that code. and it can potentially grown. This is because we are just doing 2 database calls and 1 network call that has to be treated in a synchronous way. That is something that sucks about javascript callbacks. Sure the code is not perfectly planned. But It's just an example of how it could have grown wrong doing just something that any system nowadays has to do. Which is handle multiple IO calls. For that problems like that Promises were created.

For an example of how handle promises I'm gonna use the Q library which is maintained currently by Kris Kowal. This library is highly used at many places that has a javascript interpreter, like nodejs and all the major web browsers.

To use the example above with it our code will became really more clear.

database.getUserProfile()  
  .then(function(profile){
    return networkAdapter.getTwitterInfo(profile.twitterUrl);
  }).then(function(twitterData){
    return database.getFriendsFromTwitter(twitterData)
  }).then(function(friends){
    var friendsOnTwitter = friends.map(function(friend){
      return friend.userName;
    });
    sendResponse(friendsOnTwitter);
  });

Just like that our code became so much more readable. With the then statement we pass a callback that will eventually be called if our expression executes successfully, in this case the IO calls. And we chain all the callbacks by returning a new promises that will perform another IO call that will call the next then callback in the stack.

But wait, what about the error handles. What happened to them?

They can be easily replace with just one last call at the end of the stack of promises handles, which is the catch call.

database.getUserProfile()  
  .then(function(profile){
    return networkAdapter.getTwitterInfo(profile.twitterUrl);
  }).then(function(twitterData){
    return database.getFriendsFromTwitter(twitterData)
  }).then(function(friends){
    var friendsOnTwitter = friends.map(function(friend){
      return friend.userName;
    });
    sendResponse(friendsOnTwitter);
  }).catch(function(err){
    console.log(err);
  });

Even the error handles became more clear to read, just like that. That's why I believe that the use of a Promise library can have a really good use. Especially now that the next itteration of the javascript standart will support Promises natively (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)

References:

Promisses/A spec http://wiki.commonjs.org/wiki/Promises/A
ES6 own implementation of promisses http://www.html5rocks.com/en/tutorials/es6/promises/

But to tell the true. It is a little bit of ugly to pass a lot of parameters vi the get attribute to url. But it has a good and meaningful propose. It is made to... wait for it... to get the data from somewhere.

As it is pointed by some authors in the REST/Hypermedia/Webservice literature. When you perform the an HTTP request using the GET parameter at the header. You must not interfere with the universe that the service you are fetching the data from lives in. That's why when you enter some news sites you are fetching the content with it.

The Get method must be safe. And of course it must also be idempotent. Which means it must not cause any side effects to the system. It only exists to fetch the data by a meaning url. For example the url /books says something. It says that it will fetch some books. But let's says I'm developing some library system. And of course I need to apply some filters to the /books url. In that case It's really ok to pass parameters at the url like /books?genre=fiction. It has a meaning that I want to fetch some books of my system And wanna to apply the filter that says, I wanna books with the genre fiction. It's not so ugly like the guy I quoted at the beginning of my post, because it has some meaning.

But let's say That I wanna to fetch the cover of a specific book. In that case you should use the cover parameter in the URL and not in the segment expansion. Which means that your url can be /books/13/cover. That means that I will fetch the cover of the book with the id 13. The expansion path must be used to represent some kind of segment of the resource. In that case. the cover of an specific book.