5-8 SEPTEMBER 2017
BELLEVUE, WASHINGTON
Bruce Tate is the author of more than ten books, including Programming Phoenix and Seven Languages in Seven Weeks. By day, Bruce is the CTO of icanmakeitbetter.com, the company that builds customer insight communities, where he uses Elixir and Ruby to build beautiful software.
Elixir is a demanding programming language to learn. Folks coming from object-oriented languages will need to pick up a new syntax, but also functional programming and concurrency. In this class, new Elixir programmers will get to lay a firm foundation. We'll learn to code with testing from the ground up, presenting all of the core concepts in Elixir.
We'll start with Elixir datatypes, including maps, structs, tuples, and primitives. We'll move on to core concepts like using recursion, building higher order functions, composing with pipes, and organizing that code into modules.
Once we're through those concepts, we'll build a chatroom on the concurrency concepts that you should know, including tasks, agents and if we have enough time, Erlang's OTP.
After teaching five of these workshops, we've learned that the best way to teach these concepts is to have tests, and have students make those tests pass. This is a lab-focused workshop! Come ready to give those fingers a full workout!"
Beginner, Intermediate
Eric Meadows-Jönsson, the creator of Ecto and Hex, is the second core committer for the Elixir language. Eric works at Football Addicts where he uses his deep Elixir experience to help his team build mobile software to help sports junkies get their daily fix any time, anywhere.
Elixir is a demanding programming language to learn. Folks coming from object-oriented languages will need to pick up a new syntax, but also functional programming and concurrency. In this class, new Elixir programmers will get to lay a firm foundation. We'll learn to code with testing from the ground up, presenting all of the core concepts in Elixir.
We'll start with Elixir datatypes, including maps, structs, tuples, and primitives. We'll move on to core concepts like using recursion, building higher order functions, composing with pipes, and organizing that code into modules.
Once we're through those concepts, we'll build a chatroom on the concurrency concepts that you should know, including tasks, agents and if we have enough time, Erlang's OTP.
After teaching five of these workshops, we've learned that the best way to teach these concepts is to have tests, and have students make those tests pass. This is a lab-focused workshop! Come ready to give those fingers a full workout!
Beginner, Intermediate
After tackling major scaling and performance challenges in the education, eCommerce, public transport and analytics field, he choose Appliscale and the hyper performant world of real time bidding to sharpen his Erlang skills. He is a frequent speaker throughout Silesia and co-organizer of several meet-ups (Functional Miners, Silessian BEAMers, Nodeschool Silesia). His code helps power a multi billion transaction platform, distributed across the globe. Also, Wojciech strongly believes in DevOps culture and not being afraid to change hats when there is a need for it. In the spare time he is giving talks on various IT-related meetings, blogging at http://afronski.pl and reading a lot of books.
Your Elixir app is burning? This is fine. We know how to help you!
Both Erlang and Elixir are praised for their "debuggability". It's true - there are a lot of tools and techniques that can be used, even on live, production systems. Not only that - they are easily accessible and freely usable. Together we're going to explore them in depth.
We're going to learn what exactly happens when you call a GenServer, how to "spy" on processes and introspect the VM internals. We're going to work with an example application - a basic key-value store built on top of Phoenix and Plug, prepare a release for it and deploy it to production. Unfortunately, after the deployment we'll discover some errors - obviously those we didn't anticipate. With the knowledge we gained at the workshop, we'll be able to diagnose and fix them - live in production!
Intermediate, Advanced
Student during mornings, developer at afternoons and open source contributor by evenings. Michal is programming languages enthusiast, focusing mostly on the functional side. He is a member of the Ecto core team and maintainer of the MongoDB adapter. He's Google Summer of Code 2015 alumni, where he worked on Ecto and its MongoDB integration supervised by José Valim himself. When not programming he enjoys reading books, travelling, and sailing - no matter if sunny, rainy or stormy - it's even better if all of those are combined!
Your Elixir app is burning? This is fine. We know how to help you!
Both Erlang and Elixir are praised for their "debuggability". It's true - there are a lot of tools and techniques that can be used, even on live, production systems. Not only that - they are easily accessible and freely usable. Together we're going to explore them in depth.
We're going to learn what exactly happens when you call a GenServer, how to "spy" on processes and introspect the VM internals. We're going to work with an example application - a basic key-value store built on top of Phoenix and Plug, prepare a release for it and deploy it to production. Unfortunately, after the deployment we'll discover some errors - obviously those we didn't anticipate. With the knowledge we gained at the workshop, we'll be able to diagnose and fix them - live in production!
Intermediate, Advanced
Starting from first principles we will investigate how to design reliable OTP applications. We will cover links and monitors, and how and why they are used by OTP to handle process dependencies. Then we will cover Supervisors and go through the guarantees provided by each strategy. Finally we will put this together to build supervision trees that isolate errors and recover systems to a good state with minimal side effects. The session will involve adding fault tolerance to existing applications and implementing our own versions of a few OTP features, including writing a basic supervisor.
An attendee is expected to be familiar with the Elixir language and understand the basics of Tasks, Agents and GenServers. Some knowledge of Supervisors is welcome but not essential. A laptop with Elixir 1.4 (or newer) and Erlang/OTP 19 (or newer) is required. Please feel free to bring questions and problems, time will be set aside to cover some of these.
Intermediate
After years of object oriented development in PHP and Ruby, finally enjoying the benefits of programming in Elixir. Lead Developer at Bleacher Report leading the transition from Ruby and Rails to Elixir and Phoenix.
Co-author with José Valim and Bruce Tate of the upcoming Adopting Elixir book, to be released later this year.
Also as co-organizer of the Erlang & Elixir SF meetup, please get in touch if you'd like to speak!
Starting from first principles we will investigate how to design reliable OTP applications. We will cover links and monitors, and how and why they are used by OTP to handle process dependencies. Then we will cover Supervisors and go through the guarantees provided by each strategy. Finally we will put this together to build supervision trees that isolate errors and recover systems to a good state with minimal side effects. The session will involve adding fault tolerance to existing applications and implementing our own versions of a few OTP features, including writing a basic supervisor.
An attendee is expected to be familiar with the Elixir language and understand the basics of Tasks, Agents and GenServers. Some knowledge of Supervisors is welcome but not essential. A laptop with Elixir 1.4 (or newer) and Erlang/OTP 19 (or newer) is required. Please feel free to bring questions and problems, time will be set aside to cover some of these.
Intermediate
Sonny Scroggin is a software craftsman with broad interests in the world of computing. He is a core team member of the Phoenix Framework and is working on various libraries within the Elixir ecosystem. You can find him presenting or teaching others about Elixir, Phoenix, and other tools and libraries in the local user groups in Nashville, TN and at conferences around the world.
Phoenix is an Elixir framework for building scalable web services with realtime connectivity across all your devices. Together, we’ll take a guided tour of the framework, going from the very basics, to building our own realtime application.
You’ll see the framework’s foundations, core components, and how to use Phoenix to write powerful web services.
We’ll start by exploring the foundations of the framework in Elixir’s Plug library, followed by the core components of Phoenix’s Router and Controller layers.
Next, we’ll review the View layer and build an application together as we learn each concept.
We’ll finish by using the PubSub layer to add realtime functionality to our application.
Along the way, attendees will see how to apply advanced features like router pipelines and plug middelware and receive tips on how to structure a Phoenix application for real-world services.
Beginner
Getting Realtime with Channels
Chris McCord is a programmer with a passion for science and building things. He spends his time crafting the Phoenix Framework, working with the fine folks at DockYard, writing books like Metaprogramming Elixir, and teaching others the tools of the trade.
Come level-up on Phoenix's most exciting features while gaining insights from its creator! Together, we'll use Phoenix Channels and Presence to build a highly interactive, collaborative application that works seamlessly across a distributed infrastructure. This hands-on tutorial will take you step-by-step from a blank project to a usable application. Along the way, you'll gain insights into Phoenix's distributed Pub-Sub layer and see all the tricks to getting the most out this exciting feature-set.
Intermediate Elixir programmers with basic Phoenix exposure.
Bruce Williams is a polyglot technologist, speaker, and Pragmatic Bookshelf author. He's the CTO of CargoSense, a logistics intelligence company built on Elixir and committed to its open source community. Away from the computer, he enjoys languages, traveling to new places, cooking, and the singular hobby of artisan gemstone cutting.
If you’ve wanted rock solid parameter validation for Phoenix actions.
If you’ve built REST APIs and have looked for more flexibility, control, and documentation (you may have investigated
solutions like JSON API, RAML, Swagger, etc),
If you’d like to support rich, single-page applications (React, Relay, Apollo, Elm, etc)
If you need to aggregate data from other backend services and databases into a single, cohesive API.
Build a GraphQL-based API from scratch using Absinthe and Phoenix, starting from a grounding in GraphQL basics and building up to an flexible, scalable, and secure API that will help guide you in meeting your own application's needs. Discover a growing ecosystem of tools and utilities to help you understand, debug, and document your GraphQL API, and how you can make it a first-class citizen in your applications, fully leveraging the advantages in fault tolerance and soft near-real time performance that Elixir offers.
We assume you have at least a basic grounding in Elixir and Phoenix (you may want to attend one of the tutorials the day before). Please have Elixir = 1.4, Erlang = 19, Git, and your favorite code editor pre-installed and ready to go.
Intermediate, Advanced
A full time Elixir developer at CargoSense, Ben is a co-author of the Absinthe GraphQL implementation for Elixir, and the author of ExAws. When not telling you about that time he biked across the USA, Ben also sings professionally and cooks sporadically.
If you’ve wanted rock solid parameter validation for Phoenix actions.
If you’ve built REST APIs and have looked for more flexibility, control, and documentation (you may have investigated
solutions like JSON API, RAML, Swagger, etc),
If you’d like to support rich, single-page applications (React, Relay, Apollo, Elm, etc)
If you need to aggregate data from other backend services and databases into a single, cohesive API.
Build a GraphQL-based API from scratch using Absinthe and Phoenix, starting from a grounding in GraphQL basics and building up to an flexible, scalable, and secure API that will help guide you in meeting your own application's needs. Discover a growing ecosystem of tools and utilities to help you understand, debug, and document your GraphQL API, and how you can make it a first-class citizen in your applications, fully leveraging the advantages in fault tolerance and soft near-real time performance that Elixir offers.
We assume you have at least a basic grounding in Elixir and Phoenix (you may want to attend one of the tutorials the day before). Please have Elixir = 1.4, Erlang = 19, Git, and your favorite code editor pre-installed and ready to go.
Intermediate, Advanced
Frank has built embedded Linux-based software for products in many industries including medical, consumer, telecommunications and defense. He started the Nerves project and has authored several projects used in embedded Elixir-based devices susch as Elixir/ALE, nerves_uart, fwup, and erlinit.
This two-day workshop introduces attendees to embedded development with Elixir and Nerves for creating production-quality IoT devices. The workshop includes real hardware so that attendees can apply what they learn and have the satisfaction of experiencing how simple networked embedded device development can be using Elixir. Topics for the first day include getting started with Nerves, networking and device discovery, connecting to hardware and sending sensor data to the cloud, and safely upgrading devices in the field. The second day covers more advanced topics such as how to build kiosk-type devices, streaming video from cameras, handling hard real-time operations, and selecting boards and processors for embedded Elixir-based products. By the end of the workshop, attendees should be comfortable applying their Elixir programming skills to building robust embedded systems at home or for their job.
Each participant will receive the following (subject to change) equipment as part of this course.
Beginner, Intermediate
| Parts List | |
|---|---|
| Item | Supplier |
| Raspberry Pi 0 W | Microcenter |
| GrovePi Zero | Amazon, Dexter |
| Grove – Buzzer or LED, etc (digital output exercise) | Seeed |
| Grove – Light sensor v1.2 (analog input exercise) | Seeed |
| Grove – Barometer Sensor (I2C exercise) | Seeed |
| PiCamera (streaming video exercise) | Microcenter |
| PiCamera adapter cable | Microcenter, Adafruit |
| Display for kiosk exercise | Qemu |
| MicroSD card (8GB+ for Raspbian, Don’t care for Nerves) | Microcenter / bulkmemorycards.com |
| MicroSD card programmer | N/A |
| Battery/Power brick (Not needed for RPi0W) | N/A |
| MicroUSB Cable | Monoprice |
| Case | McMaster |
| 40 pin GPIO headers | Pololu |
| 11 mm standoffs M2.5 | Pololu |
| 18.6 mm standoffs M2.5 (GrovePi Zero has tall header) | Pololu |
| 18 mm standoffs M2.5 (GrovePi Zero has tall header) | Mouser |
| M2.5 screws and nuts to hold things together | McMaster or Pololu |
| Mini screwdrivers for assembly | Pololu |
Building an Open Source, Real-Time Forum with Phoenix and Elm
Josh has been building software for randos for money for over 16 years, having run a consultancy for 10 of those. Four years ago, he started ElixirSips, which has now become part of DailyDrip.com He's convinced that helping software developers build software better is the best way he can make a large-scale, short-term impact on the world. When Josh isn't coding, he likes to spend his time coding.
There's a lot of cross-pollination between the Elixir community and the Elm community. That's not terribly surprising, as they pair extremely well. However, there aren't that many examples of production quality apps that use both. Firestorm is a community-funded open source project to provide a forum engine, with an Elm frontend.
We'll discuss the design of both the Phoenix app and the Elm client. The communication layer is handled entirely via channels. The client intelligently pre-fetches data before it's requested to provide the fastest frontend I've ever built. We'll spend some time discussing how to model types in an Elm app to represent remote data.
Intermediate
Don't Write Macros (But Do Learn How They Work)
Jesse J. Anderson has been creating things for the web since before comic book movies were cool, first as a designer and more recently as a developer. He prefers ortholinear keyboards, Oxford commas, and spaces over tabs. While known as an Elixir evangelist, he actually gets paid to work as a front end designer at Planning Center. Jesse currently lives near Seattle with his wife and 3 children.
You may have heard that "most of Elixir was written in Elixir" but what does that even mean, and how is that possible? Metaprogramming allows us to write code that writes code and, in addition to powering most of Elixir itself, has allowed for many great projects including Phoenix to exist. Even if you don't have ambitions to create the next Phoenix, understanding metaprogramming basics and learning how the Elixir expressions work under the hood can lead to greater understanding of the code you write every day.
Beginner
Managing Tables With Elixir and OTP
Robert loves bouncing around the globe helping companies build their apps – it doesn't really matter who for. You'll find him developing an indie music app one day, then scaling a giant telemedicine platform the next. He's worked gigs in Boston, NYC and Paris but now runs his remote agency, Echobind. He steps away from the screen to hang with his family, ride bikes, and take pics.
We've all waited for a table at a restaurant - only knowing how much longer the wait would be by asking. By leveraging the power of OTP, we'll design an application that exposes real-time status to both the staff and waiting customers. Genservers and supervisors that once seemed foreign will become clear with this real-world example. Elixir handles real-time application with ease and reliability using the core features of the language. You can too.
Beginner-Intermediate
Well-Behaved Native Implemented Functions for Elixir
Andrew Bennett is a polyglot programming enthusiast who enjoys using Erlang and Elixir to build secure systems for insurance and financial industries. He enjoys systems performance challenges, security and cryptography research, cooking, and robotics. Away from the computer, he loves spending time with his wonderful wife and their two little girls.
Native Implemented Functions (NIFs) are a powerful way to call native functions written in C, C++, Rust, Haskell, and more! However, special attention must be given to avoid destabilizing the Erlang VM. We'll review examples of misbehaving NIFs and how to measure their negative effects on the Erlang VM scheduler. We'll then explore patterns for well-behaved NIFs, including: timeslice reductions, dirty schedulers, I/O events, and threads. We'll also explore the new features introduced in Erlang/OTP 20 and take a look at future plans for the NIF.
Intermediate-Advanced
Plugging the Security Holes in Your Phoenix Application
Griffin Byatt is a security consultant and programmer in New York City with an interest in securing the Elixir ecosystem. He has disclosed a number of vulnerabilities in Plug, Phoenix, and other open source Elixir applications.
Your Phoenix application is insecure. But where are the vulnerabilities and how can you defend against them? In this talk we'll cover all the bases. From auth bypass to code execution, you'll learn where to find vulnerabilities and what patterns should make you sweat.
Intermediate
Scaling Up Elixir at TpT
Shanti is currently working as a software developer at Teachers Pay Teachers to help them move their backend from PHP to Elixir. She's got some unconventional notions about how applications should manage their data, and she's not afraid to share them. On the weekend, she's probably trekking up some mountain trying to escape the sound of car horns and CPU fans.
Introducing a new language into an organization with a large existing codebase is a major effort. Teachers Pay Teachers recently made that transition from PHP to Elixir and NodeJS last year, and I'll share the process, the struggles, and the triumphs we experienced, and the lessons we learned.
Beginner
Christopher Coté
Github:
entone
Twitter:
@entropealab
Company: CRT Labs (National Association of Realtors)
Embedded Elixir for Monitoring the Built Environment
Christopher Coté is a software engineer with a passion for hardware. He is the Lead Lab Engineer for the National Association of Realtors' R&D Lab. Prior to joining NAR, Chris ran his own software development and consulting company. He was a lead engineer for the Obama 2012 campaign and has helped found and build several startups around the Chicago area. Christopher has always found himself driven to create sustainable and efficient systems, whether thats for massive political campaigns, growing food or controlling and monitoring the built world. This experience has given him a unique insight into how technology and the built world coexist in society today and will continue to evolve into the future.
At CRT Labs we are developing an open source building health monitoring system, Rosetta Home. The platform consists of several subsystems for gathering data from disparate data sources including hyper-local weather, whole-home energy usage, indoor environmental quality and HVAC utilization.
The platform is built on a Raspberry Pi 3 running Nerves, a system for building embedded Elixir systems, and several USB gateways for interacting with the different subsystem hardware. Through a combination of wireless protocols including WiFi, ZigBee and 915Mhz FSK we aggregate the disparate data sources for analysis within a cloud based GUI. The Raspberry Pi also hosts a local web server for configuration and review of real time sensor data using websockets and an Elm based frontend.
The cloud platform consists of a simple Elixir/Erlang middleware for client/server certificate verification, InfluxDB as the time-series data store and Grafana for data visualization.
The talk will go in depth into building a production Nerves system and include a full demo of the working system.
Christopher Coté is also a member of the Nerves core development team.
The platform itself is available here https://github.com/rosetta-home/rosetta_home . Along with open sourcing the core platform, we have also open sourced all of the libraries the platform is built upon.
Intermediate
Writing an Editor in Elixir
Software engineer at Twitch and recovering technology entrepreneur. I have been dabbling in Elixir for the past few years or so and very much enjoy it. I play guitar and ukelele, and am learning the banjo, mandolin, fiddle, and how to fly a Cessna 120. I'm also an avid ice hockey player, playing several times a week as time allows.
Elixir for GUIs? Yes, it's possible. I'm working on a modern editor in Elixir, and I'll show you how I'm doing it. Topics will include GUI libraries for Elixir, ports, NIFs, interfacing Elixir with other languages (especially Rust), and general design principles for a modern, programmable editor.
Intermediate
Dr. Erlang/OTP or: How I Learned to Stop Worrying and Love `:disk_log`
Eric Entin (@antipax) leads a team at FanDuel that works on Elixir/Phoenix-based projects. A polyglot programmer who has worked professionally in many languages including Haskell, Ruby, and C++ for over 10 years, Elixir is by far his favorite. He has contributed to Elixir, Phoenix, Ecto, and Postgrex. A lifelong NYC resident and proud graduate of the Bronx High School of Science, he now lives in Queens with his wife and their 2 cats. Eric's interests include music production, backcountry camping, and smoked cheeses.
Even after 2 years of full-time Elixir, I'm still surprised by how many hidden gems I continue to discover in Erlang/OTP. Everyone's heard of ETS, but did you know there's a built-in distributed database? Java interoperability? Native GUIs? From custom ssh servers, to a static analyzer, Erlang/OTP (pretty much) has it all!
Many have said Elixir's greatest strength is Erlang/OTP. It's time to learn how to tap into 20 years of power!
Advanced
The Power of Zero
Dr. Andrew Forward works at CrossFit HQ remotely from Ottawa, Canada. He works as a software developer on financial systems, digitial signatures, security and media streaming. He also teaches undergraduate courses at the local university on topics like software quality, web technologies and programming languages.
He holds degrees in Software Engineering and Computer Science with a focus on documentation, automation and programming languages, but don't hold that against him. He and his wife Ayana have been happily married since before YouTube and have two boys, Hayden and August.
Andrew has been an Elixir enthusiast since 2013.
Automation is hard, but the benefits can be phenomenal. This can be especially challenging when working on your Elixir side project, as you want to see results quickly, so maybe a zero-click deploy and continuous delivery are not on your mind.
In this talk, I will help show you that even on a budget, even on a team of one you can streamline your software development to achieve some lofty goals including
We will look at the abstract view required to achieve the above, but will get hands on experience with specific tools to help ground the theory in practice.
At the end of talk, you should be motivated to better automate your project and leverage some of the tools and techniques.
Specific technologies we will touch on include:
Throughout the talk, we will create a "Naming Things" application that will provide developers with a service to help them name their modules, functions and variables; going from zero to deployed, to upgraded; including database migrations!
Think you or your idea is too small to focus on automation? Let me try to convince you it's not, or at least show a path to help make it possible.
Intermediate
Building Realtime Mobile Apps with React Native and Elixir
Osa Gaius works at Mailchimp. Previously, at Luma, he built WiFi routers and realtime web apps using Elixir. He organizes the Atlanta Elixir Meetup. In his free time, Osa crafts hip hop beats and dances Tango.
Building realtime mobile apps presents several challenges. Most approaches default to complex polling and caching techniques, and/or use subpar toolchains. This talk argues that functional programming is the best way to build scalable mobile apps. The talk demonstrates how to quickly build a realtime cross-platform mobile app similar to Slack or Hiipchat with React Native. In addition, it describes how to use Elixir and the Phoenix framework to drastically reduce the effort and complexity necessary to build a realtime web server. Lastly, the talk argues that this approach is the most maintainable for small to medium-sized development teams.
Intermediate-Advanced
Elixir with Kafka
Mathew earned his degree in computer science and has been using his skills working in many languages and platforms as a full stack and mobile developer. From platform to platform, he believes in using the right tool for the job. For the last few years, he has been working in the IoT connected car space and began using Elixir at the Dallas startup, Vinli. Today, he continues his passion for Elixir and building high throughput and data intensive applications at Toyota Connected.
Elixir with Apache Kafka is a distributed streaming platform which is great at building real-time, web-scale streaming data pipelines that reliably deliver data between producers and consumers. It's a core component of many large big-data pipelines and sounds a lot like our favorite language, Elixir! Toyota Connected's role as the global hub for Toyota's vehicle data means that hundreds of thousands of data points are handled each second. Kafka allows us to maintain a constant stream of these messages into the application without being overwhelmed.
We will show how we used Elixir to handle this scale of throughput and how we interoperated with the other components of the big data ecosystem here at TC. We will show pros and cons with our approach and discuss the alternatives.
Intermediate-Advanced
Implementing an MQTT client in Elixir
Martin works at ShopGun as an Elixir/Erlang developer in Copenhagen, Denmark. He cofounded the Elixir and Erlang meet up group in Copenhagen, and has been running monthly meet ups since 2014. He used to do front-end web development but these days he enjoys implementing network protocols in Elixir. Besides that he has a horrible taste in music and enjoys coffee and mechanical keyboards and he does feel awkward writing about himself in third-person.
Elixir has excellent support for binary pattern matching, and opening and accepting data from a network socket is a breeze compared to most other programming languages. MQTT is a lightweight message protocol. Clients can subscribe and publish messages to topics on a server. It is a nice protocol for communicating with IoT devices, such as sensors and the like.
I want to talk a bit about the protocol itself; I will dive into opening a network socket, connecting and accepting data from a MQTT broker. I will talk a bit about binary pattern matching; how we decode and encode the protocol messages; various strategies (used in the protocol) for communicating message length; how to stitch it all together using a mixture of state gen_state_machines, Supervisors, and regular GenServers in short how to make sense of the specs, and how to turn it into Elixir code.
At the end of the talk the audience should be on their way to implementing their own binary protocols.
Beginner-Intermediate
Keith Gautreaux
Github:
kgautreaux
Twitter:
@kgautreaux
Company: Schweitzer Engineering Laboratories
Patience: Using Phoenix.Presence in a Primary Care Clinic
Keith grew up in Friend, Nebraska, and received a B.S. in Chemistry from Wayne State College in 2004. He continued his education at the University of Nebraska Medical Center and completed his residency at North Colorado Family Medicine in the Rural Training Track in Wray, Colorado, where he was trained in fullspectrum family medicine. Prior to coming to Pullman, he worked in Broken Bow, Nebraska, for five years as a full-spectrum family medicine physician. In 2013 he joined Pullman Family Medicine and practiced in private practice in Pullman for two years before joining SEL.
Keith is board-certified in family medicine and sees patients of all ages. He particularly enjoys practicing evidence-based preventive care to improve the overall health of patients instead of waiting until illness strikes. His chief area of interest is the collaboration of technology and medicine, and he enjoys software development as a hobby. He married Dr. Shaleah Jones in 2006, and they had twin girls in 2011. In his free time, he enjoys spending time with his wife and daughters, playing basketball, and riding bicycles with his wife.
As the medical director for an on-site health clinic in Eastern Washington I want to track status of the patients as they move from check-in through visit, lab, and check-out. Instead of using the old "door flag" system my goal is to develop a system on top of Phoenix.Presence to track the status of the patients and providers and improve the flow of patients through the stages of their clinic visit. This talk will focus on the tribulations encountered in building this system as an Elixir and Phoenix beginner, and the lessons learned.
All
Idea Scaling
Hannah Howard is a senior developer and tech generalist with over 15 years experience in programming and other technical fields. Prior to programming, Hannah worked for 10 years in the non-profit sector in Los Angeles, specializing in LGBT advocacy and community organizing. Hannah returned to coding in 2012, and brings her passion and experience from community organizing to helping new programmers get up to speed on technical topics.
Erlang helps solve a very difficult technological problem: scaling a system that serves hundreds of users to serve millions of users. So why don't more people use it?
I believe there's another kind of scaling problem we rarely think about as programmers: How do ideas scale? Scaling ideas sounds like a scary euphemism for marketing and selling, but it doesn't have to be. Scaling an idea can simply mean lowering the barrier to entry. Or, making your idea solve a simple problem developers already know about so later they can solve problems they haven't yet imagined. Scaling ideas means building communities-- helping people associate your idea not just with the problems it solves but also the relationships they've built around it. As an Elixir community, idea scaling is part of our DNA. We can help bring the ideas and innovations of Erlang to the world. Let's do it together!
All
Alexis Huefner
Company: Big Squid
Elixir as a first language
Lexi Huefner is a Junior Software Developer at Big Squid in Salt Lake City Utah. She has had many careers in her life from Massage Therapist to retail manager to data entry. None of these careers fit so she want back to school to learn to program. School was difficult. The basics of programming made sense until she started to learn object oriented. Luckily she was able to get into an internship that was using purely functional programming. In this internship she fell in love with Elixir and from there she was able to move into her current position. Lexi is a nerd at heart who loves attending Comic Con's. She has two adorable dogs who she loves more than anything.
What would it be like to use Elixir as your first working language? Can someone at an intern or junior level really understand the complexities of functional programming? As junior who has only worked in functional programming and mainly with Elixir I have a unique insight into how easy functional programming can be for beginners. Join me as I examine my journey starting as an intern and working up to a junior position. I will explore why I find Elixir so easy to understand and why I think it's important to get juniors involved in functional programming as early as possible. I hope to inspire everyone to make Elixir something that is easy and important for beginners to learn to help them on their journey to being an amazing developer.
Beginner
Elixir by the Bellyful
Bryan Hunter is an independent software developer with over two decades of consulting experience in complex business domains. He is the founder of Nashville Functional Programmers (@NashFP), and enjoys supporting FP communities around the world. Bryan is an international speaker and has shared his experience in Lean and functional programming at conferences and universities in London, Manila, Oslo, and throughout the United States.
Elixir makes me happy! Since 2007 I have been on the road sharing what bits I've learned about Erlang, the BEAM, and OTP. It was a fun, but Quixotic decade. Folks I met saw the power, but of those thousands maybe 20 became Erlang devs. Then José arrived with Elixir and everything changed; the barriers to adoption began vanishing and waves of Ruby, Node, and .NET devs poured onto the ErlangVM.
Elixir is accessible and the community is warm, but even seasoned devs encounter lots of new and unfamiliar things (FP, processes, BEAM, OTP). The "unknowns' leave newcomers with a thirst, and this session is a 40-minute chug-a-lug at the Intro to Elixir" firehose. It will be fun, fast-paced, broad, and deep. Afterwards Elixir will seem even more special, the ecosystem will be illuminated, and you will have the "why, what, and how" knowledge to confidently continue your Elixir journey well-hydrated and without so many "unknown unknowns."
Beginner
Elixir + Neo4j
Regina got into programming because her last job stunk and was later replaced by a robot also named Regina.
Neo4j is a non-relational graph database with its own query language, Cypher, which means it doesn't work with Ecto. However, graph databases are great at modeling social networks. You will be learning how to combine Elixir Phoenix with Neo4j to make a clone of a popular social networking site with real time updates to the social graph.
Intermediate
Elixir, The Toyota Way
Powell started a software developer in geospatial systems and autonomous vehicles and, after a hiatus to earn his MD and complete a surgery internship, has spent the last several years architecting and building various web-scale platforms in the IoT space. Prior to joining Toyota Connected, he was the CTO of Vinli, a connected car startup in Dallas, and served as an editor on the W3C Automotive Working Group. The Mobility Services Platform team, which Powell leads at Toyota Connected, is tasked with building the global platform for Toyota's mobility initiatives including car-sharing, ride-sharing, fleet management, and more.
Toyota has a century-long legacy of innovation in manufacturing, a legacy framed by the Toyota Production System (TPS). More broadly applied as “Lean Manufacturing" principles, this system has, over the past few decades, had a significant impact on business processes in almost every industry.
At Toyota Connected, we are developing the software that powers Toyota's global mobility programs, and we thought this was a natural place to apply TPS. While most developers are familiar with the overlap of modern development methodologies and Lean Manufacturing, we wanted to implement these principles not only to the way we develop software but also to the way in which that software operates.
We will share our experience of introducing Elixir, building a team, and rapidly deploying products from within the 8th largest company in the world. We want to show that the time-tested principles of TPS have applicability to many areas of how we develop software and that they are an integral part of our Elixir story.
Beginner
Working with legacy databases in Ecto
Geoffrey (or "Geo" for short) Lessel has been working in web development for over 20 years in one form or another. He is the author of the open source Elixir package ReactPhoenix.
Often when starting an Elixir or Phoenix project that is data-backed, there is an existing database that you need to interact with. There are plenty of tutorials about getting started with Ecto in a green project, but how do you take a legacy database and get it working in your new application? We'll explore normal situations all the way to crazy ones like weird foreign keys and even dealing with multiple databases simultaneously!
Beginner-Intermediate
The Alchemist Gopher: My Journey from Go to Elixir
I'm a former physicist turned computer scientist who currently finds joy building distributed systems with Go and Elixir, and trying to make physics and computer science converge. Proud Mexican and tea junkie.
Go and Elixir are powerful and popular tools with a similar goal, but with a different approach. As a seasoned Go developer, I used to look at Elixir from a safe distance, till its fault tolerance capabilities and Phoenix made it impossible to ignore. This talk will describe how Elixir works compared to Go, beyond simple performance benchmarking or syntax preferences, instead focusing on tooling, development environment, and the BEAM internals (compared to the CSP model) that make Elixir shine as a language to build elegant and strong distributed systems.
All
Perhap: Applying Domain Driven Design and Reactive Architectures to Functional Programming
Rob Martin is an architect, functional programmer, writer, educator, and VP Engineering for Big Squid, a machine learning and predictive analytics company in Salt Lake City, Utah. His professional work includes a focus on building teams of functional programmers that productively includes juniors, transitioning teams to functional programming, teaching and working with juniors and interns, mob programming, and simple, demonstrably correct code. He can be found online at Version2beta.com, or version2beta on Twitter, GitHub, and almost everywhere else.
Perhap is a framework for building reactive applications in a Domain Driven Design (DDD) context, which makes it both opinionated in how you design your system, and highly efficient in how you implement it.
* As an event store, Perhap receives events, persists them to Riak, Cassandra, or DynamoDB, and delivers them to consumers over HTTP or a message bus.
* As a DDD application framework, Perhap extends that event store to route events to registered domain services implemented as pure functions (reducers), receive back domain models, and answer queries about entities or allow clients to subscribe to changes in an entity model.
Between these two use cases, Perhap provides a foundation for application development that focuses our attention on domain modeling and our development efforts on the front end and business logic only. We use the core concepts from Domain Driven Design to model our bounded context, entities, events, and models, all enforced by the framework. We get the benefits of a fully reactive architecture for free. Perhap fits extremely well with the Redux store, event, action pattern, or with the Elm model, update, view, subscribe architecture.
This talk focuses on why and how we've used Domain Driven Design to improve our design and architecture in a functional programming environment (specifically using Elixir), how the Reactive Manifesto influenced our choices, and how the product of that work, Perhap, can be used to quickly develop applications using those patterns. We'll walk through a simple application built on Perhap.
As of May 28th, we've built three versions of Perhap - two proofs of concept, and an implementation as a production app that doesn't break a sweat supporting 17,000 users generating a hundred thousand events a day for a Fortune 250 sportswear giant. The open source refactor is not production ready, but will be either ready or close to ready by ElixirConf.
Beginner-Intermediate
Building an Artificial Pancreas with Elixir and Nerves
Tim works at Gaslight in Cincinnati, OH building software solutions on Ruby and Elixir and is a member of the Nerves Core team. He credits his previous experience in building iOS apps for changing the entire way he thinks about development. Those tiny screens gave Tim an appreciation for simplifying workflows that he applies to every application, and it nudged him toward Elixir and the Nerves Project.
Today Tim lives in Mason, OH with his wife, two kids and two dogs. He loves running and has completed the full Cincinnati Flying Pig Marathon twice.
People with Type 1 Diabetes have to constantly monitor & control their food, blood glucose, insulin, physical activity and other factors in order to manage this autoimmune disease effectively. Even with advancements like insulin pumps and continuous glucose monitoring, the process is still manual and error prone for many people. What would happen if someone with T1D could delegate the constant cycle of monitoring, predicting and controlling to a computer?
In this session, I'll get personal about my own journey in supporting my T1D wife using technology. You'll learn about an open source project called the Open Artificial Pancreas System, or OpenAPS, and how it closes the loop on a cycle that the rest of us take for granted. Then together we'll explore what happened when I took my knowledge of OpenAPS and Elixir and glued them together with the Nerves Project.
We'll touch briefly on the topics of hardware prototyping, reverse engineering and binary decoding and how it all came together in one project. Before the session is over, you'll see an embedded Elixir application talk to a commercial insulin pump through the power of the Nerves Project.
All
Elixir Native UI
Boyd Multerer is currently working on still-secret projects (though he's starting to talking about the UI piece). He formerly spent 15 years on the Xbox team where he founded, then ran engineering for Xbox Live. Then he founded and ran all of XNA (think game development platform), and then ran software engineering for the Xbox One console.
I will be showing and discussing an Elixir-Native UI package that only depends on OpenGL (through glut). No browser, no wxWidgets, just Erlang, Elixir and OpenGL... Intended for embedded applications, but with possibilities for use beyond.
The framework supports multiple scenes, animations, input, forms, fonts, and more. I'm trying to optimize it for small package size, as few dependencies as possible, and nice co-existence in an embedded application.
This is a work in progress, but is pretty far along. Hope to release a beta in the next few months. Think of it as an opportunity to both preview a large project and give feedback before the first release.
All
ElixirBridge: How Do We Shape Community?
Anna Neyzberg is a San Francisco native who has done a lot of work in the ruby community in SF and currently sits on the board of RailsBridge. She has taken this community organizing experience and last year co-founded ElixirBridge in SF- an organization that offers free weekend long workshops, with the goal of creating an inclusive welcoming space for underrepresented populations in tech to learn elixir. By day she works as a Developer at Carbon Five. When not in front of a keyboard, she is trying to get better at climbing rocks.
We talk about Elixir as powerful language - concurrent, fault-tolerant, scalable. What about the power of the community? With code we can shape the language. Yet how do we shape a community?
Having spent years doing community organizing in other technical communities, I recently co-founded ElixirBridge - a volunteer run organization that puts on free weekend long workshops to teach Elixir and Phoenix to underrepresented populations in tech.
Creating ElixirBridge involved applying knowledge learned from many past experiences, both successes and failures.
Using ElixirBridge as an example, this talk will shed light on the process of creating a inclusive welcoming community. It will cover what to think about when starting, what has worked, what has not, how to make something sustainable, and why community is important.
It will attempt to answer the question - "how do we build a successful inclusive community and then have the community be self-sustaining?"
All
Back on Your Feet
Claudio works as Head of Elixir at Erlang Solutions Ltd. He's a software engineer with more than 5 years of commercial experience in complex web applications and apis, with expertise in Elixir, Ruby, Elm and JavaScript. He previously worked at New Bamboo Web Development Ltd. (now part of Thoughtbot Inc.) in London, UK.
When writing resilient Elixir applications one of our major concerns is state: where do we store it, what happens to it when a process crashes, how do we efficiently recreate it.
In this talk, we'll look at an example application and apply different techniques that can be used to protect and recover state, each one with specific implications and tradeoffs.
All of the techniques shown in this talk can be applied to everyday development.
Intermediate
Phoenix after 100,000 lines.
I'm an experienced software developer working primarily with backend and databases. I've been using Elixir professionally for the past two and a half years. Prior to that, I worked with Clojure, Ruby and C#.
I have spoken publicly in Brazil more than 30 times in technology events, including big events like RubyConf (500+ people in the room) and TDC. I've given live-coding talks many times. Some slides are available here: https://speakerdeck.com/rranelli
To this day, I've given two talks in english. That first was at ElixirConf 2016 in Orlando ( https://www.youtube.com/watch?v=3KhzyDDju0Q ) and the second at Empex 2017 (video not released)
Given phoenix's rise in popularity, the internet is flooded with examples and "getting started" tutorials.
What happens when your phoenix app grows beyond the "trivial" examples we see in the wild? What are the good patterns you should adopt and what are the ones you should avoid?
In this talk I'm going to share the problems (and solutions!) we encountered while growing our 2+ year old phoenix app beyond 100,000 lines of code, while also migrating from server-side html to a full fledged SPA.
After this talk, the listener will be able to (hopefully) better access the trade-offs and impacts on using Phoenix for their next (hopefully big) project.
All
HTTP/2 Plug to Phoenix, Cowboy too
Gary is a member of the Phoenix core team, often found answering questions on StackOverflow for the elixir and phoenix-framework tags. He is developer at VoiceLayer using Elixir and Phoenix full-time.
In this talk, we will look at the changes in Cowboy 2 and how we can use it with Plug and Phoenix by using a custom Plug adapter. We will look at how this can be done using a library and integrating it with Plug. The same technique will be applied to Phoenix, writing a custom handler in a library and using it with Phoenix.
We will also explore how HTTP/2 can be used to build a new Phoenix Transport, allowing Phoenix PubSub to work with a bidirectional HTTP/2 channel. We will investigate how existing transports work, and what changes are required to implement a custom transport.
Intermediate-Advanced
Realtime Vehicle Tracking with Elixir and Phoenix.
James was so captivated by development that he worked his way through one of his high school's only two programming books. It focused on Pascal, and since he didn't have the expensive software necessary to make Pascal run on his computer, he'd write programs by hand on paper then go back through the book to double-check his syntax.
At Gaslight you'll find him in front of his Mac, writing Web apps in Ruby and JavaScript. He loves using his creativity to solve problems with code and watch software take on a life of its own after the initial development process. He's also our office expert on Elixir and gave a talk at the first-ever ElixirConf.
James is largely a self-taught developer and got his start in technology when he joined Cincinnati Christian University's IT department while still a student. Around 2007, he discovered Ruby and spent six months learning the language as he discovered the Cincinnati Ruby community. Eventually, he landed a full-time Ruby job at Meyer Tool, an aerospace company. In 2010, James became employee number one (after the co-founders) at Gaslight.
He lives in Amelia, Ohio, with his wife, two sons and a red Australian cattle dog named Mila. While he considers programming both a job and a hobby, James also describes himself as a serial gamer and outdoor lover.
Our client came to us with an idea. Help students catch their school buses on time. Doing this required adding realtime bus tracking to their mobile application. I knew Elixir would be well suited for this but, I underestimated just how much.
Elixir helped us quickly parse the binary protocols of GPS devices. Phoenix helped us to send realtime updates from devices to our mobile application. Ranch made it easy to deal with the thundering herd of GPS devices trying to connect to us all at once.
This is not to say that their weren't challenges along the way. We had to deal with hardware protocols that did not always line up with their spec sheets. Communication between us and the buses had to be safe and secure. The nature of communication over the cellular network meant messages could be received out of order. The logistics of school buses that can break down or get moved to different routes meant devices had to be dynamically supervised. Even through these challenges OTP, Elixir, and Phoenix continued to shine.
In this talk discuss these challenges and talk through the solutions we came up with. We will touch on parsing binary protocols, dealing with out of order messages and adding dynamic supervision in OTP.
Intermediate
Keep an Eye on the Sky with Nerves and Phoenix
Jeff is a concurrency junkie and hardware tinkerer from OKC. He arrived at the gates of Erlang as a refugee after spending many years in denial of the realities of concurrency in OOP languages. He started writing Elixir in late 2013 and joined the Nerves core team in 2017. He enjoys collecting STEM-related hobbies and traveling with his wife Laura.
As part of the next generation air traffic control system, regulators in the United States and abroad will require most aircraft to be equipped with avionics by 2020 that automatically broadcast identity, position, and velocity data at regular intervals using a standard radio messaging protocol. This technology, known as Automatic Dependent Surveillance Broadcast (ADS-B), is already in use by the majority of aircraft today and can easily be received on the ground by anyone using cheap Software Defined Radio (SDR) hardware purchased online.
Because ADS-B messages can come from hundreds (if not thousands) of aircraft operating in the sky in parallel at any given time, Elixir is well suited to elegantly handle the problem of tracking them all concurrently in realtime. In this talk, we'll explore highly concurrent approaches to solving this problem using the tools and techniques offered by OTP and GenStage. We'll examine how SDR hardware support is provided using Nerves on an embedded Linux platform such as Raspberry Pi. Finally, we'll take a look at some ways we can visualize all of this flight activity on the web in realtime using Phoenix.
Intermediate-Advanced
It's Better Unstated
TJ began his programming career 20 years ago by accident. By hacking together WordPerfect macros to streamline his job as a proofreader, he discovered he liked programming more than any creative activity he'd ever tried. Today, he's interested in leveraging his deep experience with object-oriented design, applying it and unlearning it, in equal measure, in the pursuit of functional programming and design knowledge.
This is a story about transitioning an obsession with object-oriented software design to an obsession with functional software design. It's about experimentation, learning, and play. It's about what happens when you let go of sacred cows you've hung onto for nearly 20 years and insist on wiping the slate clean.
The story is told through a code kata. It starts with a Ruby example, the result of a rigorous application of OO principles. It's thoroughly decomposed, free of conditionals, and contains small objects representing domain concepts, including state. The solution is all about state and it's lovely, if a little overwrought.
But could I implement the same kata in Elixir entirely without state? It turns out that leveraging functional approaches and Elixir features like pattern matching, robust list processing, and guard clauses, a conditional-free solution emerged with an 85% reduction in lines of code.
This talked is aimed squarely at the developer thinking about or just starting to transition from an OO mindset to a functional one. I've had several jaw-dropping moments along my learning path and I hope to share my experiences and enthusiasm with others.
Beginner
Streaming Video with Elixir
John Wahba is a software engineer at Twitch that manages running interactive livestreams.
Running a video stream is challenging. You can't just "load it all into memory" because a single video can often be larger than the memory you have available. You can't know everything that will play ahead of time "some videos don't exist yet" at the time of the stream's start. You can't go down because dead air is bad and unprofessional. Elixir offers great language level features and libraries for handling these challenges. Join me as we use elixir to generate a longrunning video stream using Genstage and Stream which we can modify in real time!
The goal of this talk is to walk through some of the difficulties in dealing with large amounts of data.
Intermediate
Building GraphQL APIs with Absinthe
Live APIs with GraphQL Subscriptions
Bruce Williams is a polyglot technologist, speaker, and Pragmatic Bookshelf author. He's the CTO of CargoSense, a logistics intelligence company built on Elixir and committed to its open source community. Away from the computer, he enjoys languages, traveling to new places, cooking, and the singular hobby of artisan gemstone cutting.
APIs have gone live with GraphQL Subscriptions! Phoenix channels are a fantastic tool for connecting clients to your server, but can be difficult to use as a central data retrieval method. You can end up duplicating logic already found your API, stymied by inefficient datastore access, and sprawling channel code that has to handle all of the possible cases your clients need.
GraphQL is a query language for your unified API that lets clients choose what information they want. This holds true no matter what backends you're using, whether an Ecto backed Database or other APIs themselves.
Subscriptions with Absinthe provide real time push data capabilities with the flexibility of GraphQL documents powered by Elixir specific optimizations not found in any other GraphQL subscriptions platform.
In this talk we're going to demo this real time ability, and talk about the development and production experience we have with subscriptions at Cargosense, a logistics intelligence company that's used Absinthe to power its production GraphQL API for almost two years.
Advanced
Live APIs with GraphQL Subscriptions
A full time Elixir developer at CargoSense, Ben is a co-author of the Absinthe GraphQL implementation for Elixir, and the author of ExAws. When not telling you about that time he biked across the USA, Ben also sings professionally and cooks sporadically.
APIs have gone live with GraphQL Subscriptions! Phoenix channels are a fantastic tool for connecting clients to your server, but can be difficult to use as a central data retrieval method. You can end up duplicating logic already found your API, stymied by inefficient datastore access, and sprawling channel code that has to handle all of the possible cases your clients need.
GraphQL is a query language for your unified API that lets clients choose what information they want. This holds true no matter what backends you're using, whether an Ecto backed Database or other APIs themselves.
Subscriptions with Absinthe provide real time push data capabilities with the flexibility of GraphQL documents powered by Elixir specific optimizations not found in any other GraphQL subscriptions platform.
In this talk we're going to demo this real time ability, and talk about the development and production experience we have with subscriptions at Cargosense, a logistics intelligence company that's used Absinthe to power its production GraphQL API for almost two years.
Advanced
Thinking In Ecto
Darin Wilson has been coding professionally since the days when you got help with coding problems by posting a message to a BBS over a 300-baud modem. Over the years, he's developed apps for banking, education, television, social media, and robotic arms. He is currently the web team lead at Infinite Red, a web and mobile application development company.
Ecto can be a little mysterious. In some ways, it's a lot like database libraries you've used before, and in other ways it's completely different. You may have been initially drawn in by the parts that seemed familiar, only to get confused when it didn't work like you expected. At a certain point, following examples doesn't quite cut it, and you start to ask: what's really going on here?
In this talk, you'll learn about the core principles behind Ecto's design: the big ideas that make Ecto work the way it does. You'll be introduced to some new patterns you'll want to embrace, and some old ones you'll want to punt. Along the way, we'll look at some practical, real-world use cases that illustrate how these ideas play out. By understanding just a few basic principles, the library as a whole will start to make more sense, and you'll be able to work less by rote and more by instinct. If you're new to Ecto, or just want to understand it better, this talk is for you.
Beginner - Intermediate
Cajoling the Bird: How we squeezed more out of Phoenix PubSub
Simon has deployed Haskell, Scheme, Erlang, and Elixir code to production. Currently spreading the functional gospel at Grindr, LLC.
Grindr is a mobile-only geosocial network with +3M DAU in 137 countries, whose customers send +300M messages a day. The value of the Grindr experience is predicated on accurate indicators of who is online or present at any point.
The chat team at Grindr set out to build a real-time Presence Service, capable of handling hundreds of thousands of concurrent short-lived online sessions, all exchanging info in real-time.
Our talk recounts the story of how we implemented, re-implemented, load tested, optimized, and re-re-implemented the Grindr Presence service, before finally achieving the desired real-world performance characteristics.
We cover in particular: tooling, heuristics, OTP design, and the dirty, dirty workarounds that sometimes save the day. Erlang and Elixir shell snippets will be shared with all.
Our path meanders from the trivial (kernel polling, tuning GC) to the esoteric (BEAM machines with lcnt), to the slightly dodgy (bypassing OTP best practices for raw speed).
The audience will get a chance to see how fun it is to build a minimal load test tool in Elixir, and how to leverage it to target problematic performance hotspots.
Intermediate-Advanced
Elixir Power Tracing
Gabi works as CTO at VoiceLayer. VoiceLayer enhances mobile and web applications with Push-To-Talk capabilities and is built using Phoenix in Elixir. Gabi enjoys exploring new technologies and competing at hackathons.
Tracing is a technique for tracking events during a program execution for debugging purposes. Compared to other languages that require prior instrumentation, Elixir has powerful dynamic tracing capabilities out the box by the virtue of the Erlang VM. Unfortunately tracing is often overlooked when troubleshooting hard problems or tuning an application.
In this talk we are going to take a deep dive on tracing to understand how it works, its limitations and discuss specific use case scenarios. We will also explore available tools like dbg, recon_ex and erlyberly.
Last we will describe DTrace which provides yet another level of observability to your program or complete system even in production.
Advanced
