VT Alumni Blog Aggregator

My bitcoin wallet

Thierry Janaudy — Sun, 27 Sep 2015 02:06:00 +0000

tj2015

The rise and rise of bitcoin

Thierry Janaudy — Fri, 18 Sep 2015 10:54:00 +0000

Travis CI on a Java project with Docker support

David GageotDavid GageotDavid Gageot — Fri, 21 Aug 2015 16:42:01 +0000

I maintain a couple of Java projects that use Travis CI for automated CI. It’s great! I’m also working with SonarSource to migrate most of their internal Jenkins to Travis. That’s quite a few projects… Java build stack on Travis CI Most of these projects use the standard language: java travis.yml configuration. And it works … Continue reading

Better Docker on OSX with docker-machine, boot2docker and VMware

David GageotDavid GageotDavid Gageot — Thu, 20 Aug 2015 19:23:10 +0000

I’m on OSX and work a lot with Docker. I’ve always found boot2docker on VirtualBox OK enough to the extent that it was not worth spending time making Docker run on VMware Fusion instead. Even if performances are better. Specially on shared folders. Well, until now. Docker Machine to the rescue! The new preferred way … Continue reading

Easily generate SSL certificates and htpasswd files with Docker

Anthony Dahanne — Mon, 17 Aug 2015 04:04:17 +0000

So you don’t have installed OpenSSL or apache2-utils on your laptop, but you have Docker installed and you want to generate SSL (self-signed or not) certificates and an htpasswd file for basic authentication ? Follow those easy steps ! Generate SSL certificates from a Docker container I gathered those steps from this nice article from … Continuer la lecture de →

Bitcoins for the impatient (and for my mum)

Thierry Janaudy — Sun, 28 Jun 2015 01:32:00 +0000

Bitcoins for the impatient and for my mum

You can find all sorts of explanation on Internet with regards to Bitcoins (A bitcoin is a virtual or crypto currency) technologies and protocols.
However, I have not found a reference where I could point my mum to - a simple page explaining what is Bitcoins, how it works, in layman terms.
This is my attempt at explaining bitcoins. Mum, be patient. Read through it and then we will talk. Let’s start with some cryptography concepts.

Cryptography concepts

It is quite unfortunate - but to understand bitcoins and the fancy distributed ledger concept you have to understand a little bit of cryptography.
Do not be scared.
Behind the mathematical complexity of asymmetric encryption lies a very simple concept: it is easy to multiply, but very hard to factorize.
This is the concept behind asymmetric cryptosystems such as RSA (Rivest Shamir Adleman) and ECC (Elliptic Curve Cryptography), where the public key is known to everyone, but the private key only known to you.
Throughout the years, the best way I have found to explain this is to take the following example.
There is an inherent relationship between the public key and the private key, but what is it?
Take the following number, 221, and treat it as my public key. Everyone knows I am the owner of a public key of value 221.
My public key is the product of two prime numbers (a natural number greater than 1 that has no positive divisors other than 1 and itself.).
It would probably take two 1 or 2 minutes to figure out what those numbers are.
You will find that 221 = 13 * 17.
My private key is the pair (13, 17), supposedly only known to me.

It is very easy to compute the public key (221) knowing the private key (13, 17) but a lot more difficult to factorize 221 to find (13, 17). Whereas the multiplication would take you 5 seconds to do, it would take you 60 seconds or more to find the factors.

That’s it. You got it. RSA, ECC the most two famous asymmetric crypto systems are simply based on that principle!

RSA or ECC?

Bitcoins uses ECC, not RSA, mainly because the key sizes are much shorter in ECC than in RSA for the same cryptography strength.
An ECC key size of 160 bits is equivalent to a RSA key size of 1024, ECC 256 to RSA 3072, etc.
Shorter size usually means less space to take, and less computing power needed.

Hold on son, bits, what are bits?

Mum, a bit is either 1 or 0. Computers work like that.. yeah sorry.
So anything we deal with, like I am typing this, is translated at some point into a series of 1 and 0, “base 2”, or binary representation.
For example, the sentence, “Les sanglots longs des violons de l'automne” translates into:
1001100, 1100101, 1110011, 100000, 1110011, 1100001, 1101110, 1100111, 1101100, 1101111, 1110100, 1110011, 100000, 1101100, 1101111, 1101110, 1100111, 1110011, 100000, 1100100, 1100101, 1110011, 100000, 1110110, 1101001, 1101111, 1101100, 1101111, 1101110, 1110011, 100000, 1100100, 1100101, 100000, 1101100, 100111, 1100001, 1110101, 1110100, 1101111, 1101101, 1101110, 1100101

I am sure you are quite happy to know that!?

Bitcoins uses key lengths of 256 bits

This is a large number, quite large.
2^256 = 115792089237316195423570985008687907853269984665640564039457584007913129639936
There are 78 digits in the above number. It is slightly less than 10^77
FYI, the number of atoms in the observable universe is 10^80
You now see how hard it can be to factorize a number as big as this!

Alright, so what? I have large numbers, a public key and a private key

Each transaction (to send or receive money) of bitcoins is made public. How do we know the transaction comes from you, the public key owner?
By digitally signing it.
Digital signatures use your private key and the resulting computation can be checked or verified using your public key!
Bitcoins uses SHA256 - a secure hash function. (They are actually hashing twice, using two different algorithms, but we want to keep this simple, right!)
Behind the barbaric term hash function, or one-way hash function, lies another simple concept, “collision resistance”, i.e., it is hard to find two different inputs to the function that would produce the same output or hash.

I am a bit confused: how does SHA (hash function) relate to public/private keys?

They are both needed to digitally sign an electronic document, or bitcoin transaction.
SHA produces a fingerprint. The private keys signs the fingerprint, producing an electronic signature.
This electronic signature can be verified by anyone using your public key.

Standards exist so that implementors of cryptographic systems can talk to each other. Bitcoins relies on ECDSA (Elliptic Curve Digital Signature Algorithm).

Ok, I think I get it

Each transaction in the Bitcoins network is checked using cryptographic concepts such as ECC, SHA, ECDSA - those transactions are made public and inserted into a public ledger.
The public ledger is composed of block chains - and the key principle of Bitcoins’ implementation is that there is no central authority.
If there is no central authority, how do they avoid double spending or duplicate transactions?

This is what the Double-Spending link says:
“Bitcoin protects against double spending by verifying each transaction added to the block chain to ensure that the inputs for the transaction had not previously already been spent.”
A transaction is considered valid when confirmation takes place: meaning that is has been mined with a depth of one, then, the transaction is inserted into the a block chain.

How confirmation works is very innovative. How does it work?

Block chains? Confirmation?
A block chain is a set of transaction that potentially contains all transactions ever executed up to the genesis block (The first block ever created).
Each block contains a hash (now you know what it is) of the previous block and so forth.
This is the most important part of Bitcoins, the innovation, how do transactions get validated without a central authority and how to stop double-spending.
The original paper introduces the concept of timestamps, via a timestamp server.
The idea to avoid double-spending is to detect if an owner did not sign an earlier transaction. If there is an attempt to sign a later transaction, it would be ignored.

The timestamp server (I am quoting the paper here) “works by taking a hash of a block of items to be timestamped and widely publishing the hash, such as in a newspaper (...). The timestamp proves that the data must have existed at the time, obviously, in order to get into the hash. Each timestamp includes the previous timestamp in its hash, forming a chain, with each additional timestamp reinforcing the ones before it”. (See Section 3 of the original paper from Satoshi Nakamoto).

Now it makes sense. The brain (or set of brains) behind Bitcoins, Satoshi Nakamoto, introduces a timestamp server that creates a set of hashes that are broadcasted to the network, proving the existence of data.
Also, as stated before, each block having a reference to the hash of the previous block makes difficult to modify one block as it would imply modifying all the blocks before it in the chain.
By difficult, I mean computationally difficult or very hard to do.

This block chain concept is actively used by startups in FinTech. Check the reference for Ripple Labs.

Are we done? I am falling asleep. Hold on, no central authority?

Yes, no central authority. The use of a single timestamps server would makes things easier… but as Bitcoins is designed to work on a peer-to-peer network (P2P: a bunch of computers collaborating to achieve some common goal), this timestamp server needs to work on a P2P basis.
This concept took me a short while to get - what Satoshi Nakamoto refers to as “proof of work”.
The idea, at least as I understand it, is that you do not want to give the decision to (in)validate a set of transactions to a unique entity or to a set of individuals, this would defeat the purpose of “no central authority”.

How do you achieve fairness in the decision process on a distributed peer-to-peer network? This part is key and is the true innovation of Bitcoins.

Think about it.

Bitcoins uses a concept called “hashcash” invented by the cryptographer Adam Back.
All “miners” (the people validating the transaction for a small fee) compete by trying to find a solution to a problem (they receive the transactions to validate). The winner inserts the transactions into a block chain, etc., and the start competing again to validate the next set of transactions.
What is this problem? It is about finding a hash that satisfies a pattern. There is a difficulty target that is automatically adjusted every two weeks by the Bitcoins network.

Ok, it is still a little bit cryptic.It is a beauty. Let me try to explain a little bit better.

Imagine a network of “miners” - people/computers validating transactions for acceptance by the whole network. Let’s say we have 10.
We do not want one computer, or a set of computers to take over the control of blocks generation.
Those 10 miners constantly compete by computing a hash tied to the data of the block being mined. The winner is the one who finds a hash that matches a dynamically adjusted pattern.

More details please.

The idea is to calculate the SHA256 for example on a data block until the resulting hash would match a pattern. (In reality, it is a bit more complex, you need to worry about Merkel trees, longest chains, mining depth, etc.).
What is this pattern? It can be as simple as finding a hash whose prefix contains a specific number of 0s. The more 0s to find, the more time-consuming for the miner, the more difficult.

Nothing beats an example. (Code is below).

Let’s take this block of data, the string “Les sanglots longs des violons de l'automne”.
To find the SHA256 with 3 0s takes 27,228 iterations in 20 milliseconds, with the resulting hash: 000NL9xhiJT093++6ai2tyUm0SiDvvakO4RyI86zzTw=
To find the SHA256 with 4 0s takes 17,770,201 iterations in 14 seconds, with the resulting hash: 0000i0Myy+PtP8FFu11+20UDVRaS0WJyPz+dZI6dWGY=
It is a crypto lottery process.

As mentioned by Satoshi Nakamoto, “proof-of-work” is essentially "one-CPU-one-vote”.

Summary

Tried my best to conceptualize Bitcoins. This is it in small nutshell. There is obviously a lot more to it: wallets, addresses, what is a transaction, etc.
At least now I hope that you have the appetite to go and learn more. Lots of links below.
I highly recommend this Mastering Bitcoin: Unlocking Digital Cryptocurrencies from Andreas M. Antonopoulos

Thanks

TJ

Links

RSA: https://en.wikipedia.org/wiki/RSA_(cryptosystem)
ECC: https://en.wikipedia.org/wiki/Elliptic_curve_cryptography
ECC Key Sizes: https://www.nsa.gov/business/programs/elliptic_curve.shtml
Atoms in universe: http://www.universetoday.com/36302/atoms-in-the-universe/
Collision resistance: https://en.wikipedia.org/wiki/Collision_resistance
ECDSA: https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm
EC Domain parameters: https://tools.ietf.org/html/draft-ietf-pkix-ecc-nist-recommended-curves-00
Double spending: https://en.bitcoin.it/wiki/Double-spending
Confirmation: https://en.bitcoin.it/wiki/Confirmation
Original Bitcoin Paper: https://bitcoin.org/bitcoin.pdf
Block Chains: https://en.bitcoin.it/wiki/Block_chain
Ripple Labs: http://www.smh.com.au/business/banking-and-finance/ripple-plans-to-wash-away-currency-exchange-20150506-1myyo1.html
Adam Back: http://www.cypherspace.org/adam/
Hashcash: http://www.hashcash.org/
Merkle Tree: https://en.wikipedia.org/wiki/Merkle_tree

String to bits


"Les sanglots longs des violons de l'automne".map(c => Integer.toBinaryString(c))

2^256

Use bc or


new java.math.BigInteger("2").pow(256) = 115792089237316195423570985008687907853269984665640564039457584007913129639936

Digital signature and verification


package org.tj.ecc

import java.security.KeyPairGenerator
import java.security.spec.ECGenParameterSpec
import java.security.Signature
import java.util.Base64

object ECCTests {
  val eccKpg = KeyPairGenerator.getInstance("EC", "SunEC")
  val ecsp = new ECGenParameterSpec("secp256r1")
  eccKpg.initialize(ecsp)

  val kp = eccKpg.genKeyPair
  
  val text2sign = "Les sanglots longs des violons de l'automne"
  val ecdsa = Signature.getInstance("SHA256withECDSA", "SunEC")
  val privKey = kp.getPrivate
  <<(s"Private Key $privKey")
  ecdsa.initSign(privKey)
  ecdsa.update(text2sign.getBytes)
  val sig = ecdsa.sign
  val signatureb64 = new String(Base64.getEncoder.encode(sig))
  <<(s"Signature for text: $signatureb64")
  
  val signature = Signature.getInstance("SHA256withECDSA", "SunEC")
  val pubKey = kp.getPublic
  <<(s"Public Key $pubKey")
  signature.initVerify(pubKey)
  signature.update(text2sign.getBytes)
  val result = signature.verify(sig)
  <<(s"Verified signature: $result")
  
  def main(args: Array[String]): Unit = {
  }
  
  def <<(any: AnyRef) = println(any)
}

Output is


Private Key sun.security.ec.ECPrivateKeyImpl@9364
Signature for text: MEUCIHCss5744CdiTZB6NbjmS/KUoYij62g4MyNbzaLxDmOiAiEAjD41Rjcy91IdBGvrexRc4eFhxd884FIMQmRPCUhA2+4=
Public Key Sun EC public key, 256 bits
  public x coord: 65479953046212531738762935537232089915367280178473139038566429069872218746437
  public y coord: 54888950959211905102812252682418929722745382700581796025271727271177672920890
  parameters: secp256r1 [NIST P-256, X9.62 prime256v1] (1.2.840.10045.3.1.7)
Verified signature: true

Hashcash competition


package org.tj.ecc

import java.security.MessageDigest
import java.util.Base64
import scala.annotation.tailrec

object HashCash {
  def proofOfWork(data: String, pattern: String, maxIter: Int): Option[Int] = {
    val md = MessageDigest.getInstance("SHA-256")
    val encoder = Base64.getEncoder
    
    @tailrec
    def helper(nonce: Int, iter: Int): Option[Int] = {
      if (iter > maxIter) None
      else {
        val datum = data + nonce
        md.reset
        md.update(datum.getBytes)
        val digest = new String(encoder.encode(md.digest))
        if (digest.startsWith(pattern)) Some(nonce)
        else helper(nonce + 1, iter + 1)
      }
    }
    
    helper(0, 0)
  }
  
  def main(args: Array[String]): Unit = {
    val t0 = System.currentTimeMillis
    val result = proofOfWork("Les sanglots longs des violons de l'automne", "0000", 100000000)
    val tf = (System.currentTimeMillis() - t0)
    println(s"Result $result in $tf millis")
  }
}

Ripple plans to wash away currency exchange

Thierry Janaudy — Thu, 25 Jun 2015 12:04:00 +0000

A very nice application for distributed ledgers! Ripple plans to wash away currency exchange

La fin des banques?

Thierry Janaudy — Fri, 19 Jun 2015 03:15:00 +0000

A very good book to read (in French) about bank digitization and the impact of new technologies, and how it will (how it does!) affect your wallet.
Apple, Bitcoin, Paypal, Google : la fin des banques ? : Comment la technologie va changer votre argent

Abstracting JMS over lambdas: Scala vs Java 8

Thierry Janaudy — Sat, 28 Mar 2015 08:36:00 +0000

Follows two implementations of a JMS abstraction layer using functional interfaces in Java 8 and Scala 2.11.

Let's start with Java 8.
First the definition of two functional interfaces:


import javax.jms.Session;

@FunctionalInterface
public interface MessagingSession {
  void withSession(final Session session);
}

and import javax.jms.MessageProducer;


@FunctionalInterface
public interface MessagingProducer {
  void produce(final MessageProducer producer);
}

The main class:


import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.Session;
import javax.jms.TextMessage;

import org.apache.activemq.ActiveMQConnectionFactory;

public class Messaging {
  private final boolean transacted = false;
  private final int ackMode = Session.AUTO_ACKNOWLEDGE;
 
  private final ConnectionFactory connectionFactory;
  private final Connection connection;
 
  private Session session = null;
 
  public Messaging() throws Exception {
    this.connectionFactory = new ActiveMQConnectionFactory("vm://localhost");
    this.connection = connectionFactory.createConnection();
    connection.start();
  }
 
  public Destination createQueue(final String qn) throws Exception {
    return session.createQueue(qn);
  }
 
  public TextMessage createTextMessage(final String text) throws Exception {
    return session.createTextMessage(text);
  }
 
  public void withSession(final MessagingSession messagingSession) throws Exception {
    session = connection.createSession(transacted, ackMode);
    messagingSession.withSession(session);
  }
 
  public void withProducer(final Destination destination, final MessagingProducer messagingProducer) throws Exception {
    messagingProducer.produce(session.createProducer(destination));
  }
}

And a demo class - how to use the above:


import javax.jms.Destination;
import javax.jms.TextMessage;

public class JavaMessagingDemo {
  public static void main(String[] args) throws Exception {
    final Messaging messaging = new Messaging();
  
    messaging.withSession((session) -> {
      try {
        final Destination destination = messaging.createQueue("ANOTHER.QUEUE");
        messaging.withProducer(destination, (producer) -> {
          try {
            final TextMessage message = messaging.createTextMessage("MY.MESSAGE");
            producer.send(message);
          } catch (Exception e) {
            e.printStackTrace();
          }
        });
      } catch (Exception e) {
        e.printStackTrace();
      }
    });
  }
}

In Scala 2.11:


import javax.jms.Session
import org.apache.activemq.ActiveMQConnectionFactory
import javax.jms.Destination
import javax.jms.MessageProducer

object Messaging {
  val transacted = false
  val ackMode = Session.AUTO_ACKNOWLEDGE
  val connectionFactory = new ActiveMQConnectionFactory("vm://localhost")
  val connection = connectionFactory.createConnection
  connection.start
  
  implicit def jms2richsession(session: Session) = new EnrichedJMSSession(session)
  
  def withSession(f: Session => Unit) = f(connection.createSession(transacted, ackMode))
  
  class EnrichedJMSSession(val session: Session) {
    def withProducer(dest: Destination)(f: MessageProducer => Unit) = f(session.createProducer(dest))
  }
}

object ScalaDemo {
  import Messaging._
  
  def main(args: Array[String]): Unit = {
    withSession { session =>  
      val dest = session.createQueue("MY.QUEUE")
      session.withProducer(dest) { producer =>
        val message = session.createTextMessage("Some message")
        producer.send(message)
      }
    }
  }
}

Group By Sum Scala 2.11 vs Java 8

Thierry Janaudy — Thu, 26 Mar 2015 05:38:00 +0000

I had to recently implement an aggregate function in Scala 2.11 and Java 8... Which one do you prefer?

Scala 2.11


case class Datum(val id: String, val count: Int)

object GroupBySumScalaDemo {
  val list = List(Datum("a", 1), Datum("a", 2), Datum("a", 3),
                  Datum("b", 4), Datum("b", 5),
                  Datum("c", 6))
                  
  // Want to group by 'id' and sum all values
  val map = list.groupBy(_.id).mapValues(_.map(_.count).sum)   
  
  println(map)
  
  def main(args: Array[String]): Unit = {
  }
}

Java 8


class MyDatum {
  private final String id;
  private final int count;
 
  public MyDatum(final String id, final int count) {
    this.id = id;
    this.count = count;
    }

  public String getId() {
    return id;
  }

  public int getCount() {
    return count;
  }
}

public class GroupBySumJava8Demo {
  public GroupBySumJava8Demo() {
    final List list = Arrays.asList(
      new MyDatum("a", 1), new MyDatum("a", 2), new MyDatum("a", 3),
      new MyDatum("b", 4), new MyDatum("b", 5),
      new MyDatum("c", 6));
    final Map map = list.stream()
      .collect(Collectors.groupingBy(MyDatum::getId, Collectors.summingInt(MyDatum::getCount)));
    System.out.println(map);
  }

  public static void main(String[] args) {
    new GroupBySumJava8Demo();
  }
}

I know which one I like ;-)

Monadic behaviour

Thierry Janaudy — Sat, 07 Mar 2015 03:22:00 +0000

Today, home-sick, read and found a bunch of nice links on Scala and Monads. For future reference, I paste those links here.
Monads in Scala I
Haskell Monads
Category Theory
Monads are elephant I, Monads are elephant II, Monads are elephant III, Monads are elephant IV
Scalaz Monads

Adventures in financial and software engineering

Thierry Janaudy — Fri, 06 Mar 2015 00:57:00 +0000

Worth a read

RPC, Protobuf, Scala

Thierry Janaudy — Sat, 21 Feb 2015 04:01:00 +0000

Seen too many custom frameworks for RPC, asynchronous callbacks, custom serialization, etc...... There are great frameworks out there to handle this. Let's have a look at a simple Search service, asynchronous request, using protobuf and Scala. Some *.proto def where the services are defined, and the data to marshall in and out.


syntax = "proto2";

package myprotocol;

message SearchRequest {
 required int32 requestid = 1;
}

message SearchResponse {
 required int32 requestid = 1;
 required int32 responseid = 2;
}

A simple RPC call definition:


syntax = "proto2";
option java_generic_services = true;

package myprotocol;

import "Search.proto";

service SearchService {
  rpc Search (SearchRequest) returns (SearchResponse);
}

Then you define two classes...the one that implements your RpcChannel is the one where you plugin your underlying messaging system, such as JMS, Solace, Tibco RV, or sockets...


package demo

import java.util.logging.Logger

import com.google.protobuf.Descriptors.MethodDescriptor
import com.google.protobuf.Message
import com.google.protobuf.RpcCallback
import com.google.protobuf.RpcChannel
import com.google.protobuf.RpcController

import myprotocol.Search.SearchRequest
import myprotocol.Search.SearchResponse

class SChannel extends RpcChannel {
  val logger = Logger.getLogger("SChannel")
  
  override def callMethod(methodDescriptor: MethodDescriptor , 
                          rpcController: RpcController , 
                          m1: Message, 
                          m2: Message, 
                          rpcCallback: RpcCallback[Message] ) {
    m1 match {
      case sr: SearchRequest => {
        val response = SearchResponse.newBuilder.setRequestid(sr.getRequestid).setResponseid(2).build
        rpcCallback.run(response)
      }
      case _ => logger.warning(s"Not handling message type $m1 yet")
    }
  } //  override def callMethod
}

class SController extends RpcController {
  val logger = Logger.getLogger("SController")
  
  override def reset() {
    logger.info("reset()")
  }

  override def failed(): Boolean = {
    logger.info("failed()")
    false
  }

  override def errorText(): String = {
    logger.info("errorText()")
    null
  }

  override def startCancel() {
    logger.info("startCancel()")
  }

  override def setFailed(s: String) {
    logger.info(s"setFailed($s")
  }

  override def isCanceled():Boolean = {
    logger.info("isCanceled()")
    false
  }

  override def notifyOnCancel(rpccallback: RpcCallback[Object]) {
    logger.info(s"notifyOnCancel($rpccallback)")
  }
}

Edited I Forgot the code to actually use those classes :-)


package demo

import java.util.logging.Logger

import com.google.protobuf.RpcCallback

import myprotocol.Search.SearchRequest
import myprotocol.Search.SearchResponse
import myprotocol.Services

object RPCDemo {
  val logger = Logger.getLogger("RPCDemo")
  
  def main(args: Array[String]): Unit = {
    val channel = new SChannel
    val controller = new SController
    val services = Services.SearchService.newStub(channel)
    val request = SearchRequest.newBuilder().setRequestid(1).build
    val callback = new RpcCallback[SearchResponse] {
      override def run(obj: SearchResponse) = logger.info(s"Received on RpcCallback $obj")
    }
    services.search(controller, request, callback)
    
    logger.info("Sleeping 5 seconds")
    Thread.sleep(5000)
    logger.info("Ciao")
  }
}

For example, if you are looking for a pre-built TCP/IP socket implementation on top of protobuf, check out protobuf-socket-rpcA detailed view of a custom channel can be seen there: RpcChannelImpl.java
Edited II You can obviously define an implict instead of this callback a la Java:


  import scala.language.implicitConversions
  implicit def f2cb(f: (SearchResponse) => Unit) = new RpcCallback[SearchResponse] {
    override def run(sr: SearchResponse) = f(sr)
  }

  services.search(controller, request, (resp: SearchResponse) => {
    logger.info(s"Received on RpcCallback $resp")
  })

... Voila.

Stop installing postgres on your laptop : use Docker instead

Anthony Dahanne — Mon, 19 Jan 2015 16:06:05 +0000

Tired of managing a full-blown DB server on your development machine ? Let’s give Docker a try ! Getting started with Docker First, if your development machine is not running Linux (ie if you’re running windows or mac os x), it’s easier to use boot2docker to get started, since it will take care of installing: … Continuer la lecture de →

Ouray! Just completed my Machine Learning Course!

Thierry Janaudy — Sun, 11 Jan 2015 06:21:00 +0000

Completed my ML course from Coursera! Lots of work!