location_city Bengaluru schedule Oct 13th 10:00 AM - 06:00 PM place ESquire Hall 1 people 4 Interested add_circle_outline Notify

Full day hands-on workshop on building concurrent, fault-tolerant and scalable systems in Erlang/OTP in the Erlang Ecosystem. We will look at three languages in the Ecosystem, Erlang, Elixir and LFE, and show how they can all be used together when building systems.

 
 

Outline/Structure of the Workshop

Full-day hands-on workshop on how to build an Erlang application.

Learning Outcome

An understanding of various issues in building concurrent, fault-tolerant and how to address them using Erlang/OTP.

Target Audience

Developers interested in building concurrent, fault-tolerant systems.

schedule Submitted 4 years ago

Public Feedback


    • Robert Virding
      keyboard_arrow_down

      Robert Virding - The Erlang Ecosystem

      Robert Virding
      Robert Virding
      Language Expert
      Erlang Solutions
      schedule 4 years ago
      Sold Out!
      45 Mins
      Keynote
      Intermediate

      Erlang is in many ways quite old though many of the problems for which it used are quite modern. The Erlang language and system was designed around a set of requirements for telecom systems. They were distributed, massively concurrent systems which had to scale with demand, be capable of handling massive peak loads and never fail. The Erlang concurrency and error-handling model was developed around these requirements. We will describe the development of the language and the design of systems based on the Erlang showing how well the functional paradigm suits attacking these types of problems. We will also look at the further development with the introduction of new languages in the Erlang environment - the Erlang ecosystem.

    • Abdulsattar Mohammed
      keyboard_arrow_down

      Abdulsattar Mohammed - Dependently Typed Programming with Idris

      45 Mins
      Talk
      Intermediate

      Types allow us to structure data to match the functional requirements of the problem we are trying to solve. But, in most languages, we end up choosing/building types that are the closest to our requirement. They don't exactly fit our bill, as a result of which, we write runtime code to enforce those conditions. Then we write tests because the compiler can't help us. Dependently Typed Languages like Idris allow us to encode a wide range of invariants into the type itself allowing us to possibly have zero runtime errors.