Service Discovery is an important aspect of microservices, particularly when using containers on elastic infrastructure. Most popular approaches for service discovery require a standalone fault tolerant cluster like Consul, Zookeeper or etcd.

If you are already using Akka as a clustering platform for your services, there is an interesting alternative available for Service Discovery. CRDTs, or Conflict-free Replicated Data Types are a relatively new primitive in distributed systems. CRDTs allows concurrent updates without coordination and has provisions for tuning consistency levels. 'Distributed Data' extension natively supports CRDTs on top of Akka-Cluster.

We used CRDTs in Akka to build the service registration and discovery mechanism for TMT's (Thirty Meter Telescope) software platform. TMT will be world's largest optical telescope once operational. The ongoing software work is open source and available on github. We would like to share the details of our implementation and also compare it existing approaches.

Organising code as chained combination of data processing steps is a common pattern. Functional programming has made it ubiquitous due to concise lambda notations. But there are wide variations in how these pipelines are implemented. In this talk we will explore important properties of lazy data streams such as: push vs pull, hot vs cold, linear-flows vs graphs, perishable vs reusable, unicast vs multicast, synchronous vs asynchronous back-pressured etc.

We will then explain "reactive-streams" protocol which guarantees asynchronous back-pressure for push based data streams. We will conclude with a demo using Akka-Streams which is an implementation of this protocol. The demo will involve a) streaming images from server to the browser over websockets, b) transferring large files from one source server to multiple destination servers.

Haskell has populairzed typelcasses a principled way to add ad-hoc extensions on existing data types. They allow you to 1) add new operations on existing data types and 2) support new data types on existing operations, and thus solve the famous "expression problem".

There is a lot of similarily between typeclasses and Java good practices of programming to interfaces and preferring composition over inheritance. The missing link is the implicit dictionary passing which allows haskell to be much more concise and expressive.

In this tutorial, we will look at how Scala adopts typeclasses by adding the missing link of implicits.

Objected oriented languages like Scala support the paradigm of programming with functions. How does it work? The language has to conceptually map functions to objects. This tutorial will explain this idea by starting with a simple Java-like code and progressively refactor it to make use of higher order functions. As a result, you will learn about a few syntax sugars and also the cost implication of using objects to represent functions.

Sync, Async, Blocking, Non-Blocking, Streaming are the buzzwords in the reactive programming world. This talk will attempt to attach some meaning to them. It will also demo the performance and resource consumption patterns for blocking-io, Scala Futures and RxJava Observables for comparable programs. Finally, a command line application that consumes twitter streams API will demo what is possible using the new reactive abstractions.

At ThoughtWorks, a 50-people team is building a marketing website backend for one of the largest consumer electronics brands in the world. We are Play-Scala as our web framework which allows us to design the application in a very different but powerful ways. This experience based talk will talk about these differences, emphasizing on two of them: "Dealing with concurrency without threads" and "Dependency resolution with constructor injection".

Dealing with concurrency without threads
- The backend is end to end non-blocking with highly concurrent architecture
- Each page consists of 20+ reusable snippets, so each page request translates into 20+ outbound web service calls to get data for the snippet data in parallel
- Posting data involves download/upload of large images from/to remote services, also done in parallel
- We will show you how Scala Futures, Play and ReactiveMongo functional programming paradigm allows us to do all this without blocking any thread or managing thread-pools by hand

Dependency resolution with constructor injection
- Dependency injection is considered essential for designing applications that are easy to test. Usaully, dependencies are specified as constructors parameters
- Scala traits allow us to get rid of constructors by wrapping classes and their factories inside components that in turn can depend on other components, this enables a compile time mechanism for dependency resolution which is very flexible
- We will show examples of this pattern, its effects testing without external DI frameworks

We will briefly talk on how functional programming style in general helps with testing and software delivery on agile projects. Finally, we will also cover the pain-points these approaches bring out, and argue if it is worth to pay that cost.