Original article: https://medium.com/better-programming/object-oriented-programming-the-trillion-dollar-disaster-%EF%B8%8F-92a4b666c7c7

Slashdot page: https://developers.slashdot.org/story/19/07/22/0426201/is-object-oriented-programming-a-trillion-dollar-disaster

https://medium.com/flatiron-labs/elixir-and-the-beam-how-concurrency-really-works-3cc151cddd61

We were having great successes right from the start, and by the end of the week, the team was very jazzed about what the new approach could mean for the historically daunting task of building with a JavaScript framework like React or Angular.

Take for example the "like" button on a Lucidboard card. To implement this feature, we needed to do two things. First, we indicate to LiveView that we would like to send an event when the user clicks the heart icon, sending the card's id as a parameter in the view template:

<a phx-click="like" phx-value="<%= @card.id %>" href="#">
    <%= fas("heart") %> <%= length(@card.likes) %>
</a>
        

Then, we handle the event in the LiveView module:

def handle_event("like", card_id, socket) do
  live_board_action({:like, id: card_id, user: user_id(socket)}, socket)
  {:noreply, socket}
end

In this case, we've simply executed the action against the running board and returned an unmodified state. The user will get the same board-update broadcast that all other users looking at the board will get which will increment the like count on the card. Whenever the board updates, all users looking at it will receive the event. It looks like this:

def handle_info({:board, board}, socket) do
  {:noreply, assign(socket, :board, board)}
end

Underneath, whenever this state (stored in the socket) is updated, the templates re-render, and only the updated placeholders get pushed down to the client over the websocket connection. The client side then is using the pre-existing, open-source morphdom library which LiveView leverages to do an efficient patch on the DOM to bring it up to date. Chris McCord & co. have demonstrated how all of this is so robust and efficient across the board.

Even as we went deeper, we found the patterns Chris has introduced with this library very logical, simple, and easy to use, and I imagine teams needing to build these single-page app experiences would be well-served to look closely. I'm really looking forward to using it more and learning further where the pitfalls may be and how it can super-charge my projects.

phoenix_live_view_example

phoenix_live_view_example has many great hints as to how LiveView works. I found the easiest way to get it going is to clone, then:

1. Open config/dev.exs, find the Demo.Repo config at the very bottom, and add port: 9977.
2. Launch a postgres instance with docker run -v demo_db_data:/var/lib/postgresql/data -p 9977:5432 --restart=always --name=demo_db -d postgres
3. Follow the other setup instructions in the example repo's README.md.
4. Launch the app! (iex -S mix phx.server) By default, it's accessible at http://localhost:4000

Ignoring SSL Security

In the example repo, you might get an error from hex about ssl certificates. To solve this, export a variable. In fish, use set -x HEX_UNSAFE_HTTPS 1. In bash, use export HEX_UNSAFE_HTTPS=1.

Chris McCord has announced that he's made his Phoenix LiveView project public. (Good are in this article.) While a proper "release" is still yet to come, this represents an exciting moment many of us have been waiting for because we can now dig in, experiment with the technology, and even help with contributions.

For our QL Hack Week, starting March 18, we'll attempt to begin building client-side interactivity into the Lucidboard project with this library. Stay tuned!

Keynote about Nerves

Justin Schneck spoke about his Nerves project, and they have been building some exciting things! Nerves is a toolchain which makes deploying Elixir applications (with linux) to embedded devices like Raspberry Pis a piece of cake. His talk discussed NervesHub, their new hosted or self-hosted solution for managing these built Nerves images. With this infrastructure, you can not only push and fetch these images, but also issue commands to deploy them to your live fleet of devices in a very secure fashion. He also mentioned NervesKey, a miniscule device which can be soldered to a device (or some are embedding it from the factory) which can serve as a hardware security token when interacting with NervesHub etc.

Cadre: Building reliable distributed stateful systems in Elixir

Paul Schoenfelder, known for his Distillery project among many others, spoke about his almost-finished project, Cadre. Cadre is a tool in a similar vein to Jepsen which provides a framework for testing applications which run in a distributed fashion. This is a tricky problem domain that requires tricky solutions. With his tool, you can randomize the failures (like nodes going down etc) that occur over the lifecycle of your application and tests a great many scenarios very quickly. When an issue is found, the same scenario can be repeated by using the same "seed", so the fix can be properly confirmed.

While our runtime does put distributed solutions within reach, they still remain on the more difficult end of the spectrum, and many teams do absolutely fine without clustering.

Ecto Without a DB

Greg Vaughn spoke about using the Ecto library's Schema and Changeset parts to do data structuring and validation without its Query and Repo parts which are used to actually build queries and interact with a database. He showed how the functionality provided can give developers a very nice API for validating inputs, whether coming from a form or anywhere, so that you can be sure data entering the next layer meets your requirements. Obviously, this is usually very important, when working with a DB or not.

I think the fact that this is a natural option follows from the fact that Elixir's functional approach leads to neatly decoupled solutions.

The Business Case for Elixir

Brian Cardarella, founder & chairman of DockYard, did a fantastic job of laying out our business case. I won't try and enumerate his points, but I would recommend this talk to anyone thinking about adopting Elixir from a company or enterprise level!

Keynote about OOP Hegemony

Osa Gaius-Obaseki made a really fantastic talk about the entrenched idea that OOP is how one builds software. With an upcoming interview with Google, he found it odd that they would require he use Java in the interview -- the position doesn't necessarily require Java! So, he found himself learning the language for the purpose of the interview. He spoke about the early days of Java, working with columnists to get "Java is a godsend which changes everything!" type articles written. These articles spoke to upper management types and less engineers. Java is largely credited for the ascension of OOP.

We're left today with a world in which OOP is the de-facto way build software and there seems to be little discussion of other options. For me, OOP seems to slow me down, lead me to introduce bugs, and make concurrent execution worlds more difficult.

Osa's talk was brilliant, and I would recommend it to folks looking for some discussion around this.

Keynote about LiveView

Chris McCord, author of the Phoenix framework, has been working furiously on his LiveView project which may turn out to be a paradigm-shifting technology in the space of building snappy, app-like, client-side interactivity as our current-day JavaScript SPA frameworks do, but without the convoluted JavaScript language and ecosystem at all!

To learn more detail, I recommend checking out his recent article.

Hastega: Challenge for GPGPU on Elixir

Susumu Yamazaki came in from Japan to share his team's work on Hastega with us. It's a very interesting project which is using Rust code with the Rustler in order to leverage not just the CPU as we normally do, but the GPU as well in order to execute computations. As this strategy is refined, it may be a very powerful drop-in tool for doing big data processing, for instance, using all the strengths of Elixir, with execution faster than a compiled language (not using the GPU as is typical) could manage.

José Valim's Closing Keynote

José spent the first 10 minutes or so talking about the new Erlang Ecosystem Foundation that he's helping launch. This non-profit group of individuals, spanning many languages and specialties within the greater Erlang ecosystem, will be helping increase adoption by contributing to libraries, tools, and documentation.

GenStage is already a potent tool for setting up data processing pipelines over a cluster of nodes, but José spent the rest of his time discussing his newly released tool, Broadway. Having spent much time working with various companies on their GenStage setups, he found that certain issues continued to crop up. Broadway is a tool that will take some simple configuration parameters, and automatically start up a GenStage system in the ideal way.

I'm really interested to see how things develop with Elixir's role in the big data processing field. It's great to see it break into new areas, one by one.

This podcast episode is a fantastic overview of the technology and how it fits into the software engineering landscape, in general.

Brian Cardarella of DockYard has done a great talk, The Business Case for Elixir. Check this one out if you're interested in the reasons for adoption, from a company's perspective.

Phoenix LiveView is a new library which could represent a paradigm shift in how many of us build SPAs. Chris McCord's recent article sheds some light on how it works. His even more recent ElixirConf EU talk goes deeper yet.

The runtime is incredibly efficient and handling many simultaneous users. Read about How Discord Scaled Elixir to 5M Concurrent Users with only 4 full-time engineers or how Bleacher Report could reduce 150 servers running their Ruby on Rails app to 2 when they rewrote in Elixir.

I think the most exciting thing about the tool, for me, is simply how it leads me to write code that is so uncommonly easy to read, follow, refactor, and test. The fact that we embrace the thing that makes good OOP code, functional programming, is a big component of this, but the tooling and the features seem to generally draw from the best practices across the field, allowing me to stay focused on the problem at hand and iterate quickly. I think this talk describes some of these ideas: using FP naturally (or sometimes forcibly!) leads you to "pits of success" where one ends up with good designs which are easy to reason about, test, etc. (The YouTube description is worth a read.)

A developer from Podium wrote a great article explaining how they have been all-in on Elixir for some time and, despite looking closely at a number of alternatives, couldn't be happier with their choice.

The book Adopting Elixir got a hearty recommendation from someone at the Lonestar ElixirConf in Austin I just returned from. The guy said it really sold his team and I imagine it would be a great explanation of the why & how from a higher level than an actual intro to programming the language. I actually think the Elixir books from Pragmatic Programmers are good, in general. I originally learned the language from Programming Elixir.

The Awesome Elixir page lists a great many learning resources, libraries and other useful goodies.

Saša Jurić, a well-respected member of the community, did a fantastic talk at GOTO 2019 about BEAM technology, The Soul of Erlang and Elixir.

Hopefully, I'll come back and add to this post in the future as I find stuff.

It's not technically the Elixir core team, but 2 members of the Elixir core team are working on a new HTTP library! It sounds nice because it aims to be a low-level, extendible foundation from which we can build more powerful components using BEAM processes etc. I'll be keeping the ears peeled on this one.

Let me know if you're interested in participating!

Project description is on our Cheese Factory site.

This meeting will be at 4 PM in Park Place (11 Monroe) and on Zoom, as always.

Work on Lucidboard continues! Please reach out if you'd like to be involved in any way. We're looking for all types of help in bringing this Kanban tool to a usable state!

Lonestar ElixirConf!

This one looks like a great conference and I will be attending. Talk to your leader & let me know if you think you might like to come as well!

Elixir 1.8.0 (And 1.8.1!) Released

This release brings a number of small features and performance enhancements. One that I'm happy to see is improved support for dealing with time zones.

Changelog

Nifty Trick for with Statements

I've used this trick once or twice and thought it was pretty clever. Tyler Pachal went ahead and wrote a nice article describing it!

Other Cool Articles

• Podium reflects on 2 years of being all-in on Elixir. Spoiler alert: they love it & have no regrets.
• Thomas Barrasso reflects on his first month of using Elixir.
• Monterail has posted a short article about how their team got up and going with Elixir, borrowing training methods from Plataformatec (Elixir creators) themselves.

This new instance of the Ghost blogging platform will be the new home for all things Elixir at QL. I'd like to use it for meeting notes and other items that are worth sharing around.

Reach out to me if you'd like to get access to contribute!

The episode is available on Soundcloud.

Some of the ideas:

• Being explicit. For clarity and all the other reasons.
• Functional code is simple. No need to question what's "really" going on behind the code.
• Interesting opinion explained: Even if Desmond isn't leveraging the power of processes and concurrency, he'll still choose Elixir for most programming tasks.
• JS and Scala both allow functionally type code, but because they allow references, the "hodge-podge" of 2 paradigms leads to trouble.
• Refactoring is sooo easy with a bunch of stateless functions.
• The functional approach is comfortable for modeling the real world. Also, things do happen at the same time in the real world, so modeling your program in a system and paradigm that naturally allows you to operate accordingly seems preferable.

Actually, of the handful of elixir podcasts I'm following in general, this one is great. I'm catching up since I only found it recently, and the content seems top notch.