Gain insights into adopting Elixir for web apps. Explore staffing, code management, functional transition, distributed Elixir, deployment, performance assessment, and more, for a seamless transition.

adelixir.tar.gz

BeliefStructure

BeliefStructure-credo

BeliefStructure-dialyzer

BeliefStructure-inchex

BeliefStructure-coveralls

BeliefStructure-bureacrat

BeliefStructure-bh

BeliefStructure-Aliases

BeliefStructure-format

BeliefStructure-dialyzer-wrong

BeliefStructure-terraform

BeliefStructure-terraform-copy

Umbrella Projects

counter

path_alllocator

path_alllocator-copy

EchoServer-Java

Distillery

observer-copy

formatter

formatter-fixed

sasl_reports

load-testing

profiling

benchee

ecto-log-copy-copy

terraform

observer-real

terraform-postman

nifs

BeliefStructure-coveralls-copy

BeliefStructure-inchexB

Elixir is a relatively new framework but shows rapid growth due to its flexibility as a functional, concurrent, distributed programming language.

This course is a practical guide to adopting an Elixir-based technology stack for distributed web applications. Engineering managers will find helpful guides on upskilling and cross-skilling their teams, and technical leads will grasp the meaningful differences between Elixir and traditional stacks. The course moves from high-level concepts such as staffing, code management, and legacy systems to developing your Elixir environment with a walkthrough of making the functional transition, distributed Elixir, and integrating external code. You’ll wrap up with deployment and maintenance functions, assessing performance, and finalizing the application.

By the end of this course, engineering managers will be prepared to tackle the unique challenge of migrating web applications to Elixir.

Adopting Elixir for Software Engineering Leads & Managers

# The object-oriented touch in Elixir

In this chapter, we noted that object-oriented developers learning Elixir tend to use object-oriented concepts because that’s what they know, and we examined the most popular ones. Adopting Elixir means more than learning its idioms and syntax. To get the most out of it, it’s crucial  to understand its basic abstractions.

We started by examining how to think about a mutable state. When the transition has been made,  it’s easy to see how the concepts of behavior, state, and time go from something implicit and tightly coupled to much more explicit concepts. Just using stronger, higher-order abstractions such as processes and concurrency raises mutable state to a more serious level, where it belongs.

Next, we talked about polymorphism. While most object-oriented developers reach for inheritance first, Elixir developers tend to use pattern matching when dealing with a known set of variables. To support unknown services in an API or application, protocols can be used. Taken together, these two provide all the power of inheritance and a more complete list of options for organizing code.

# Agents, tasks and GenServers

Finally, we introduced Agents, tasks, and GenServers. We used agents to model states with processes, and tasks to model behaviors. Then, we looked at the GenServer abstraction to do both at once. We learned to use processes to do the following:

Get a summary of what we learned about functional transitions in this lesson.

Wrapping Up

Summary of Making the Functional Transition

Introduction

Three Adoption Stories

Concept: Team Building

Concept: Ensuring Code Consistency

Concept: Legacy Systems and Dependencies

Development: Making the Functional Transition

Development - Distributed Elixir

Development - Integrating with External Code

Production - Coordinating Deployments

Production - Metrics and Performance Expectations

Production - Making Your App Production Ready

Conclusion

Appendix

Summary of Making the Functional Transition

The object-oriented touch in Elixir