Bye Erlang Factory! Hello Code BEAM!


The Erlang Factory conferences have been evolving for the past few years. The origins were about bringing together developers to spread the Erlang love and to share battle stories. Over the years our community has grown beyond Erlang to encompass a more diverse range of languages from the Erlang Ecosystem. Today, to better reflect this, we are rebranding and aligning our events, including the Erlang & Elixir Factory, under a new name Code BEAM belonging to a global family of conferences called Code Sync. We are launching a new Code Sync website with all events, past talks and articles so we hope you'll visit it soon! And see you at the next conferences! We are happy to answer any questions, simply get in touch info@codesync.global

Call For Talks Code BEAM SF 2018 Open


The very first Code Sync conference is Code BEAM SF taking place in San Francisco 15-16 March.

The essence of Code BEAM SF is discovering the future of the Erlang Ecosystem so we look forward to receiving a mix of proposals on innovation and open-source applications based on Erlang, OTP, Elixir, LFE, BEAM and other emerging technologies around the Erlang Ecosystem.

Talks this year will be around the following themes:

Introduction to Erlang and Elixir Tools Case studies BEAM Frameworks Distribution, concurrency, multicore and functional

Deadline for talks is 27 December.

>> SUBMIT YOUR TALK HERE

Speakers and Training


Keynote Speakers


larry wall

Sarah Allen

Language Encodes Wisdom

Co-Creator Adobe After Effects/Shockwave Flash Video, Works at Google

Speaker - Bio

larry wall

Larry Wall

Welcome Inside the Head of Larry Wall

Creator of Perl

Speaker - Bio

John Doe

Joe Armstrong

Work in Progress - ‘How to Make the World a Better Place?’

Co-Inventor of Erlang

Speaker - Bio

John Doe

Brian Troutwine

Piecemeal Into Space: Reliability, Safety and Erlang Principles

Software engineering, with ambitions toward reliability

Speaker - Bio





Line-up #eef17


John Doe

Robert Virding

Lisp Machine Flavors for LFE: implementing objects on Erlang/OTP

Co-Inventor of Erlang

Speaker - Bio

John Doe

Carl Hewitt

Concurrency and Strong Types for IoT

Creator of Actor Model

Speaker - Bio

Dave Thomas

Dave Thomas

Transforming Programming

Pragmatic Programmer turned Publisher

Speaker - Bio

irina-guberman

Irina Guberman

Empowering devices for IoT with Erlang and FPGA

Principal Product Architect at Xaptum

Speaker - Bio

kenji rikitake

Kenji Rikitake

Writing A New Erlang/OTP Module for Beginners

Erlang/OTP Rand Module Co-creator

Speaker - Bio

peter alvaro

Peter Alvaro

Orchestrating Chaos: Applying Database Research in the Wild

Outsider scientist / Nontrepreneur / Professor intern

Speaker - Bio

hannah-howard

Hannah Howard

Stateful Web Apps with Phoenix and OTP

Programmer and life long iconoclast

Speaker - Bio

richard carlsson

Richard Carlsson

Secrets of the Erlang Beam compiler

Father of eunit, edoc and try-catch

Speaker - Bio

justin schneck

Justin Schneck

Prototype to Production: Creating Connected Hardware with Nerves

Pan-galactic Nerves Overlord

Speaker - Bio

Christopher Cote

Instrumenting the World with the BEAM

Lead Lab Engineer at CRT Labs

Speaker - Bio

Danni Friedland

Billions of Events Per Day with Elixir

Lead developer/Team manager eBay

Speaker - Bio

Sarah Gray

Cloud-sourcing T.S. Eliot

Engineer, Manager, Experimenter

Speaker - Bio

Andrea Leopardi

How to Design a Software Library

Elixir Core Team Member

Speaker - Bio

lukas-larson

Lukas Larson

Tracing JIT Compiler

Erlang VM Developer

Speaker - Bio

christopher meiklejohn

Christopher Meiklejohn

Loquat: A Design For Large-Scale Distributed Applications - Tales from the Dark Side

Ph.D. candidate

Speaker - Bio

Claudio Ortolina

Flexible Elixir

Head of Elixir @ Erlang Solutions

filipe varjao

Filipe Varjao

Measuring Erlang Energy Consumption and Why It Matters

Ph.D. student of Computer Science at UFPE - Brazil

Speaker - Bio

Jesse Anderson

Jesse J Anderson

The ABCs of OTP

Front End Designer

Speaker - Bio

Michal Slaski

Erlang Performance Lab

Captain Erlang

Speaker - Bio

Lauren Tan

From Front-End to Full Stack with Elixir & Phoenix

Senior Full Stack Engineer at Netflix

Speaker - Bio

Brujo Benavides

Erlang Oddities

Inaka’s CTO / Erlang Solutions Tech Lead and Trainer

Speaker - Bio

Ted Burghart

Riak on OTP-19, or "What took you so long?"

Senior Nerd @ Basho Technologies

Speaker - Bio

Richard Kallos

Debugging Code that Crashes the BEAM

Backend developer at AdGear

Speaker - Bio

Peter Hastie

Realtime Data Pipelines with Elixir GenStage

Bleacher Report Engineer

Speaker - Bio

Peer Stritzinger

Fast-Path to Erlang Embedded: Wireless Embedded Erlang Applications with Grisp Hardware Boards and Toolchain

Founding owner and managing director of Peer Stritzinger GmbH

Speaker - Bio

Louis-Philippe Gauthier

Staying Afloat with Buoy: A High-Performance HTTP Client

Director of Platform Engineering

Speaker - Bio

Josh Adams

Elm and Phoenix: Two FP Flavors That Taste Great Together

ElixirSips, Co-Founder DailyDrip

Speaker - Bio

Jeremy Pierre

Alpaca: Static Typing on the BEAM

Director of Platform Engineering at Askuity Inc

Speaker - Bio

Duncan Sparrell

Responding to Cyber Attack at Machine Speed

Award winning (US Intelligence Community Seal Medallion, AT&T Science & Technology Medal) cybergeek

Speaker - Bio

Kevin Smith

Cutting Edge Chatops with Elixir & Erlang

CTO, Operable Inc.

Speaker - Bio

Casey Rosenthal

Chaos Engineering: Experimentation vs Testing.

Engineering Manager at Netflix

Speaker - Bio

John Doe

Garrett Smith

AI Hacker

Tutorial - Bio

Ari Lerner

How Elixir Made Us Better Programmers

Developer, teacher, and all around fun person

Speaker - Bio

Anna Neyzberg

How Elixir Made Us Better Programmers

Developer, teacher, and all around fun person

Speaker - Bio

Vladan Djakovic

Instrumenting and Testing High Performance Switching Fabric for IoT

The Architect

Speaker - Bio

Dave Thomas

Francesco Cesarini

O'Reilly Author & Founder of Erlang Solutions

Training - Bio

John Doe

Joe Armstrong

Co-Inventor of Erlang

Training - Bio

John Doe

Robert Virding

Co-Inventor of Erlang

Training - Bio

John Doe

Marc Sugiyama

Senior Architect at Erlang Solutions

Training - Bio

Claudio Ortolina

Head of Elixir @ Erlang Solutions

Training - Bio

Themes Description
Tools Erlang and Elixir's popularity is growing but it's not always clear what off-the-shelf software is useful in production quality systems. In this track you will learn what existing production systems' maintainers are using to monitor and test their systems. This track will include the war stories and experience reports of novice and expert users alike.
Case Studies Every new domain that Erlang and Elixir pushes into brings a new class of problems and a new class of solutions. In this track we'll learn from other's experience, where things have been peachy and where they haven't been so much. We'll all walk away with a more clear idea of how to build highly reliable software.
BEAM In this track you will learn from the leading experts and Erlang committers about new language constructs, virtual machine implementations and powerful libraries which together form the Erlang eco-system. Esoteric VM implementations are presented, alongside improvements and enhancements to the existing ones. You will learn how many of its features work and how to best use them to write fast and efficient code.
Frameworks In this track, you will learn from the leading experts and committers about new and leading frameworks such as (but not limited to) Phoenix, MongooseIM, Nerves and RabbitMQ. You will find out how these frameworks work, how to best use them and where not to use them.
Distribution, Concurrency, Multicore & Functional Scaling vertically by adding more powerful hardware is a thing of the past. We scaled horizontally, by adding more commodity hardware. With the coming of age of mega-core architectures, we have the choice of either adding more hardware or more cores, or both. Erlang style concurrency puts us ahead of the game when it comes to scaling with both approaches.
Schedule

#EEF17

Hide options that do not apply to your search




*DCMF: Distribution, Concurrency, Multicore and Functional


Time Crystal Ballroom Crystal Lounge Regimental
09:00-09:15
Welcome
09:15-10:15
Keynote - Language Encodes Wisdom
Sarah Allen
10:15-10:45
Coffee Break
10:45 - 11:30
Concurrency and Strong Types for IoT
Carl Hewitt
Writing A New Erlang/OTP Module for Beginners
Kenji Rikitake
Cloud-sourcing T.S. Eliot
Sarah Gray
11:35 - 12:20
Riak on OTP-19
Ted Burghart
Monitoring and Pre-emptive Support: The Road to Five Nines on the Beam
Francesco Cesarini
The ABCs of OTP
Jesse J. Anderson
12:20 - 13:20
Lunch
13:20 - 14:05
Erlang Oddities
Brujo Benavides
Responding to Cyber Attack at Machine Speed
Duncan Sparrell
Staying Afloat with Buoy: A High-Performance HTTP Client
Louis-Philippe Gauthier
14:10 - 14:55
Chaos at Netflix
Casey Rosenthal
How to Design a Software Library
Andrea Leopardi
Stateful Web Apps with Phoenix and OTP
Hannah Howard
14:55 - 15:25
Coffee Break
15:25 - 16:10
Loquat: A Design For Large-Scale Distributed Applications
Christopher Meiklejohn
Erlang Performance Lab
Michal Slaski
How Elixir Made Us Better Programmers
Ari Lerner and Anna Neyzberg
16:05 - 16:50
Lisp Machine Flavors for LFE: implementing objects on Erlang/OTP
Robert Virding
From Front-End to Full Stack with Elixir & Phoenix
Lauren Tan
Measuring Erlang Energy Consumption and Why It Matters
Filipe Varjão
17:00 - 18:00
Lightning talks
18:00 - 21:00
Conference Party
Time Crystal Ballroom Crystal Lounge Regimental
09:00-10:00
Keynote: Piecemeal Into Space - Reliability, Safety and Erlang Principles
Brian Troutwine
10:00-10:15
OTP Team
Lukas Larsson
10:15-10:45
Coffee Break
10:45 - 11:30
Alpaca: Static Typing on the BEAM
Jeremy Pierre
Empowering devices for IoT with Erlang and FPGA
Irina Guberman
Billions of Events Per Day with Elixir
Danni Friedland
11:35 - 12:20
Flexible Elixir
Claudio Ortolina
Work in Progress - ‘How to Make the World a Better Place?’
Joe Armstrong
Instrumenting and a Testing High Performance Switching Fabric for IoT
Vladan Djakovic
12:20 - 13:20
Lunch
13:20 - 14:05
Tracing JIT Compiler
Lukas Larsson
Wireless Embedded Erlang Applications with Grisp Hardware Boards and Toolchain
Peer Stritzinger
Realtime Data Pipelines with Elixir GenStage
Peter Hastie
14:10 - 14:55
Orchestrating Chaos: Applying Database Research in the Wild
Peter Alvaro
Building Devices with Elixir / Erlang using Nerves
Justin Schneck
Building a web app in Erlang, yes you heard me right I said Erlang, not Elixir
Garrett Smith
14:55 - 15:25
Coffee Break
15:25 - 16:10
Elm and Phoenix: Two FP Flavors That Taste Great Together
Josh Adams
Secrets of the Erlang BEAM compiler
Richard Carlsson
Debugging Code that Crashes the BEAM
Richard Kallos
16:15 - 17:00
Transforming Programming
Dave Thomas
Cutting Edge Chatops with Elixir & Erlang
Kevin Smith
Instrumenting the World with the BEAM
Christopher Coté
17:10 - 17:55
Keynote
Joe Armstrong and Larry Wall
17:55 - 18:30
Closing Notes and Leaving Drinks

Idiomatic Elixir: Growing a Program (9-5pm, Marines Memorial Hotel)

Spend a day coding with Dave Thomas, exploring Elixir, its libraries, and his ideas on how to write idiomatic, functional programs.

  • Trainer: Dave Thomas

  • This course is for you if...
    • you know Erlang and want to try Elixir
    • you know some Elixir and need to get to the next level
    • you're a programmer who hasn't tried either, but wants to...

    Description:

    The best way to get a feel for a language is to write lots of code in it, and that's what we'll do. Expect to be programming, ideally in pairs, for at least half the time. For the rest of the time, I'll present and lead discussions. We'll all aim to create an online game, but we'll take it in steps:


    • first we'll write some basic support code
    • then we'll implement a library the implements the game logic. Doing this will let us experiment with a functional style of coding.
    • we'll write a console interface to our game engine, so we can play it. But we'll write it as a separate application, so we'll learn how this kind of structuring enforces strict isolation of components.
    • our game engine needs to become a fully fledged server, so we'll do that. But we won't do it the way most people use. Instead, we'll play with my favorite way of arranging this kind of code.
    • once our game engine is a server, we can run it from multiple clients. You can even use your client code to play on someone else's server (network willing).
    • now we're going for the IPO—we'll put our game on the web. We won't write it as an HTML app, though. Instead we'll use Phoenix channels to drive a JavaScript client in the browser. And, as if by magic, that API will be identical to the one we used for the command line client.
    • if we have time, we'll play with Phoenix presence, for a true social multiplayer experience.

    The main idea is to show you how a functional approach leads to pure, clean, and reusable code. As we add more and more functionality, the code we've already written will just continue to work.

    • Bring:
    • A laptop with Elixir installed.


    Register for Tutorial

Deep Learning with TensorFlow and Guild AI (9-12.30pm, Marines Memorial Hotel)

The field of Artificial Intelligence has made amazing strides over the last few years. The driving force behind its success is Deep Learning, an approach to machines intelligence that uses complex multi-layer neural networks.

In this workshop we'll explore deep learning using TensorFlow, Google's recently released library for numerical computations. We'll also use Guild AI, an open source tool that supports collaboration on deep learning experiments.

By the end of the workshop you will have participated in a complete workflow of deep learning and have a basic understanding of how the process can be used to build applications.


  • Workshop Goals:
  • Introduce deep learning
  • Train a neural network
  • Tweak network hyper parameters
  • Put a network into production

Prerequisities

This is an introduction to deep learning using TensorFlow. You should install TensorFlow and Guild AI on your laptop in preparation for the workshop.

  • TensorFlow: https://www.tensorflow.org/
  • Guild AI: https://www.guild.ai/

Some experience with Python will let you to dive deeper into the TensorFlow code but is not strictly required.


About Garrett

Garrett was a software engineer at CloudBees and is responsible for building scalable, er, that is, awesome software! At CloudBees Garrett led the development of the RUN platform-as-a-service that provided reliable, performant application hosting to tens of thousands of customers, which in turn served tens of millions of end-users!

Garrett's weapon of choice for the development of awesome software is Erlang - a highly concurrent functional programming language that use used by companies like Facebook, WhatsApp and Machine Zone to build the world's largest messaging systems. Garrett is an international speaker and instructor. He organizes the Chicago Erlang User Group which sponsors Chicago Erlang - an annual Erlang conference in the heart of the US. He is the author of several Erlang projects including e2, Psycho, and LambdaPad. He is the creator of the satirical videos MongoDB Is Web Scale, Node.js Is Bad Ass Rock Star Tech, and Erlang The Movie II, The Sequel.

Garrett maintains his blog at http://gar1t.com.

Twitter: @gar1t
Github: gar1t



Register for Tutorial

Building Chatbots and Chatty Things (9-5pm, Marines Memorial Hotel)


Target Audience:

Software Developers & Engineers


Prerequisites:

Knowledge and experience of any programming language that has XMPP or HTTP client libraries, e.g. Erlang or Elixir.


Objectives:

A better understanding of tools for building and maintaining messaging systems based on the MongooseIM platform. Understand the basics of chatbots and MongooseIM APIs.


Course Outline:

This one-day course presents tools for building and maintaining messaging systems with MongooseIM platform. It gives insight into the deployment and configuration of a fully featured messaging server, and also monitoring tools which allow support engineers to inspect and monitor running system. It exercises installing client libraries on devices like RaspberryPi as well as implementing chatbots that can run on such devices.

The course contains the following topics:

  • Introduction to MongooseIM Platform
  • Installing the messaging service with MongooseIM Deploy
  • Monitoring MongooseIM server
  • Installing MongooseIM client libraries on RaspberryPi
  • Developing MongooseIM chatbots

About Michal

Michał Ślaski started programming in Erlang at the AGH - University of Science and Technology in Krakow, Poland, when working on his Masters prototyping massively multiplayer online games. After graduating, he joined Erlang Solutions on key projects around the world. He is currently heading Erlang Solutions' Krakow office in Poland, keeping the Erlang flag up high.

Twitter: @michalslaski
Github: michalslaski



Register for Tutorial

Newsletter Sign Up

No Spam - Only latest news, price and activity updates

Sponsors

Would you like to sponsor the Erlang & Elixir Factory San Francisco Bay Area 2017 Conference? There are many sponsorship options available.
To learn more, please reach out to us at: conferences@erlang-solutions.com



Our Sponsors

Platinum Sponsors



Gold Sponsors



Silver Sponsors



Media Sponsors


Conference Details

  • Marines Memorial Club and Hotel, 609 Sutter Street, San Francisco, CA 94102
  • (415) 673-6672

The Erlang & Elixir Factory SF Bay Area 2017 is returning to downtown San Francisco to the Marines' Memorial Club and Hotel in Union Square.
We have also secured standard hotel rooms (at USD199++ per night) and deluxe rooms (at USD 229++ per night).

Find more details here.

San Francisco Training Schedule


Basic Erlang

20-22 March (3 day course)

  • Trainer: Joe Armstrong
  • Target Audience: Software Developers & Engineers
  • Pre-requisites: Good programming skills in another language

  • Objectives:
  • Understanding of the basics of Erlang
  • Read/Write/Design Erlang Programs
  • Provides basics needed to attend the OTP course

  • Course Outline:
  • Basic Erlang is a three-day introductory course, providing most pre-requisites to attend the OTP course. The course contains the following topics:-
  • Background
  • Basic Erlang
  • Erlang Shell
  • Sequential Erlang
  • Concurrent Erlang
  • Process Design Patterns
  • Process Error Handling
  • Modules & Processes

  • Data Structures:
  • 1.Records
  • 2.Maps
  • 3.Binaries
  • 4.List comprehension

  • Funs and High-Order Functions
  • Macros
  • Distributed Programming

Complete OTP

27 - 30 March (4 Days Course)

  • Trainer: Francesco Cesarini
  • Target Audience: Software Developers & Engineers
  • Prerequisites: Complete Erlang or Basic Erlang, preferably followed by some practical experience

  • Objectives:
  • Understand the design principles of OTP
  • Understand OTP behaviours
  • Understand OTP System Configuration
  • Awareness of the available OTP applications

  • Course Outline:
  • The OTP course covers advanced Erlang features such as design patterns, applications and libraries, giving the participants the ability to develop systems using OTP. The course contains the following topics:

  • Behaviours
  • Generic Servers
  • Finite State Machines
  • Supervisors
  • Event Handlers
  • Applications
  • Building Compliant Processes
  • System Architectures Support Library
  • System Principles & Release Handling
  • Release Upgrade

  • Certification exam associated with this course.

  • Advanced Erlang Techniques

    20 - 21 March (2 Days Course)

    • Trainer: Robert Virding
    • Target Audience: Software Developers & Engineers

    • Prerequisites:
    • Knowledge and experience of Erlang, at least equivalent to Basic Erlang or Complete Erlang courses.
    • Knowledge of OTP is beneficial but not strictly necessary
    • Experience with building and maintaining large systems.

    • Objectives:
    • A better understanding of tools for building and maintaining systems
    • Understand the basics of profiling and debugging of running systems

    • Course Outline:
    • This two-day course presents some more advanced tools for building and maintaining applications with Erlang. It also gives insight into the tracing tools in the system which allow support engineers to inspect and monitor running systems. The course contains the following topics:

    • Parse Transforms
    • Profiling
    • Emulator Flags (BEAM introduction)
    • Observer
    • Tracing & Debugging:
    • Trace BIFs & Match Specifications
    • The dbg Tool
    • Recon, Redbug

    (Learn you some) LFE

    22 March

    • Trainer: Robert Virding
    • Target Audience: Software Developers and Engineers, with a focus on backend services

    • Prerequisites:
    • Good programming skills in Erlang or Elixir
    • Fluency with OTP

    • Objectives:
    • Learn Lisp basics as it applies to Erlang and the BEAM
    • Basic/Sequential LFE
    • Concurrent and Parallel programming using LFE
    • Using OTP from LFE

    • Course Outline:
    • In this one-day course, students begin by learning the basics of Lisp as it applies to Erlang and OTP, followed by learning how the Erlang concurrency and fault-tolerance are handled in LFE. We conclude by showing how LFE interfaces to OTP and other languages in the Erlang ecosystem.

    • The course contains the following topics:
    • LFE repl
    • Basic datatypes
    • Structure of code
    • Data Structures (Maps, Records, Binaries)
    • Concurrency and error handling in LFE
    • Interfacing LFE with OTP
    • Lambdas and higher order functions
    • Macros

    Elixir/OTP Bootcamp

    27 - 30 March (4 Days Course)

    • Trainer: Marc Sugiyama
    • Target Audience: Software Developers and Engineers, with a focus on backend services

    • Prerequisites:
    • Good programming skills in another language such as Java, Perl, Python, node.js, or Ruby
    • Familiarity with server-side software development helpful

    • Objectives:
    • How to use Elixir for backend servers and REST interfaces
    • Basic/Sequential Elixir
    • Concurrent and Parallel programming
    • Distributed Applications
    • Building, Testing, and Deploying

    • Course Outline:
    • Students will start by learning the basics of the Elixir language. Following that, the course turns to concurrency and students will learn the details of writing parallel and concurrent Elixir applications and the underlying concurrency capabilities provided by BEAM (the Erlang virtual machine). The course shows the right way to write concurrent applications that will scale by using OTP Behaviours. At the completion of the courses, students will know how to build, test, and deploy a concurrent, distributed backend service applications. The course contains the following topics:

    • Background Elixir/Erlang
    • Basic Elixir
    • Elixir Shell
    • Sequential Elixir
    • Concurrent Elixir
    • BEAM (Erlang virtual machine) internals
    • Process Design Patterns
    • Process Error Handling
    • Modules & Processes
    • Data Structures (Maps. Structs, Records, Binaries)
    • List comprehension
    • Funs and High-Order Functions
    • Macros & Language Features
    • Code Upgrading
    • Distributed Programming
    • Behaviours
    • Generic Servers
    • Supervisors
    • Using Mix

    Elixir/OTP Bootcamp

    21 - 22 March (2 Days Course)

    • Trainer: Claudio Ortolina
    • Target Audience: Software Developers and Engineers, with a focus on providing web-based services

    • Prerequisites:
    • Prior experience with Elixir and Phoenix (3 to 6 months), familiarity with building web services helpful (i.e. REST interfaces).

    • Objectives:
    • How to organise, grow and maintain an application with multiple responsibilities
    • How to test and statically check an application to minimise integration issues
    • How to integrate resilience patterns to provide partial availability despite outages

    • Course Outline:
    • Students will go through analysis and refactor of an existing codebase to improve decoupling, isolation, testability and resilience. The course will cover the following topics:

    • Approaching an existing codebase (code structure, OTP structure)
    • Basic resilience testing
    • Extracting commands for reusability
    • Type specifications and domain borders
    • Extraction to umbrella layout
    • Effective unit and integration testing
    • Client/Server patterns via adapter
    • OTP and circuit breakers to guarantee availability

    Lightning Talks

    We will be giving the 1 hour of Lightning Talks more exposure this year. For the first time, lightning talks will be on the main stage and not just during the drinks, giving each talk a much larger audience and increased engagement. As well as this, all videos and slides of the Lightning Talks will be given a section of the website, where they can be promoted and shared in the future.
    Watch the talks