This is a thorough guide for SQL experts and newbies alike, so let’s summarize what we’ll talk about in this article:

We’ll explain what the purpose and characteristics of transactions are Then, we’ll outline how to approach them in Elixir, using “the Ecto way” Finally, we’ll get to explain how it feels superior to different ORMs

https://curiosum.com/blog/elixir-ecto-database-transactions

Check out an example project that aims to create a Rust NIF that crops an image and makes it grayscale to show you a way to run your Rust code from Elixir efficiently. https://curiosum.com/blog/getting-rusty-with-elixir-nifs-rust

https://curiosum.com/blog/how-become-senior-elixir-developer-popularity-interview-szymon-soppa

https://mave.io/blog/page-transitions-with-phoenix-liveview

I recently completed the 6th GUI task in LiveView 🎉 - a Circle Drawer with undo/redo functionality.

I wrote a post about the implementation and some decisions I made, and I hope others find it interesting!

✍️ https://www.germanvelasco.com/blog/seven-guis-circle-drawer

One of the most interesting things was that the task was meant to be a challenge of undo/redo functionality:

“In an ideal solution the undo/redo functionality comes for free… just comes out as a natural consequence of the language / toolkit / paradigm.”

When it came time to implement the undo/redo functionality, I was happily surprised that the solution definitely “came for free” because of Elixir’s functional paradigm and LiveView’s reactivity.

In the end, the undo/redo functionality was the easiest part of the whole task!

Episode 111 of Thinking Elixir. Ever wanted to deploy a PR for show-and-tell, QA testing, or to get feedback on it? Jason Axelson joins us to share how he did that on Render.com. We explore how it can be done on other platforms like Fly.io as well. We talk about how this ability benefits teams and companies. We dig into how setting up a seeded DB for the code isolates data changes but also makes it easier for people to test the code with multiple data scenarios. Turns out doing this may be easier than I thought!

https://podcast.thinkingelixir.com/111

Find out how to write a command-line application in Elixir, using tools such as ElixirScript, OptionParser, Escript, Bakeware, and Burrito. https://blog.appsignal.com/2022/08/09/write-a-standalone-cli-application-in-elixir.html

Find out how to write a command-line application in Elixir, using tools such as ElixirScript, OptionParser, Escript, Bakeware, and Burrito. https://blog.appsignal.com/2022/08/09/write-a-standalone-cli-application-in-elixir.html

Check out
Elixir 1.14 Release Candidate in action
Improvements in Debugging

https://medium.com/blackode/elixir-1-14-release-candidate-in-action-17e283ce3132

https://cmdarek.com/pages/air-quality-station.html

Siblings v0.4.0 has been released.

Added Siblings.multi_call/2 and Siblings.multi_transition/3 to operate on all the dynamic children.

Elixir’s machine learning suite is still relatively new, but it stands as a viable alternative to a lot of the more established tools in the Python ecosystem. Follow along as I build a neural network using nx and axon to work through the famous Kaggle Competition “Titanic - Machine Learning from Disaster” and visualize the results in livebook:

https://ryancurtin.com/posts/titanic-machine-learning-in-elixir/

Tesla provides a Telemetry middleware which is pretty straightforward to configure for your clients. It is possible to extend the middleware behaviour and group metrics by host, method or path.

This post will show how to setup Telemetry with Tesla and path grouping: https://felipeelias.github.io/elixir/2022/08/03/elixir-telemetry-and-tesla.html

PlugLimit is using Redis Lua scripting to provide rate-limiting functionality for web applications based on a Plug library. Salient Redis Lua scripting feature is a race conditions resiliency which makes it a recommended solution for distributed systems (e.g.: Phoenix servers swarm behind a round robin load-balancer).

PlugLimit provides two built-in rate limiters: fixed window and token bucket. Custom rate limiters can easily be added as a user defined Redis Lua scripts.

https://github.com/Recruitee/plug_limit

Sometimes our application collects more logs than we would expect. Especially in the case of endpoints responsible for the server status. Thanks to a simple plug, you can inform about the system state all the time without logging this request.

More on: https://bartoszgorka.com/health-status-without-log-request

In this week’s ElixirCast, learn how to defend your Phoenix app against bot attacks in minutes with Paraxial.io!

https://elixircasts.io/bot-defense-with-paraxial.io

Some people excitedly talk about the “end of localhost development” when developer machines move to the cloud. Presumably this is better because our environments, infrastructure and projects are so complex that they need this additional layer of abstraction just to keep teams productive. Is this our inevitable future? Or is this trying to solve the wrong problem? We talk about what we think this movement is about and how it relates to us. Elixir projects can potentially be much simpler with fewer external dependencies making this move to the cloud less compelling. Join us as we contemplate how Elixir and Phoenix might fare in a world with no “localhost development”.

https://podcast.thinkingelixir.com/110

Changelog

v13.2.0

Enhancements

• Rendered Markdown toggle for @moduledoc, @typedoc, and @doc
  • Inject markdown in @doc deprecated: …
  • Inject Markdown into doc lines and heredocs
  • Ignore false for documentation module attributes
  • Ignore @doc metadata that can’t include Markdown
    • guard: …
    • since: …
  • Ignore @callback(unquote(spec)) when trying to find typespecs
  • Interleave Markdown and Elixir for doctests
    • Mark code blocks as Elixir language in Markdown documentation
    • Mark multi-line exceptions in doctests as Markdown
    • Treat DBG prefix doctest lines as Markdown instead of Elixir
    • Resolve owner of docs as following call definition clause.
    • Count …> as Markdown since it’s not Elixir syntax
    • Count ** (… as Markdown since it’s not Elixir syntax for exception in iex prompts
    • Count iex> as Markdown since it’s not Elixir syntax
  • Documentation links in rendered documentation
    • Modulars MODULE
    • Callbacks
      • Relative (c:NAME/ARITY)
      • Absolute (c:MODULE.NAME/ARITY)
    • Types
      • Relative (t:NAME/ARITY)
      • Absolute (t:MODULE.NAME/ARITY)
    • Functions and Macros
      • Relative (NAME/ARITY)
      • Absolute (MODULE.NAME/ARITY)
• Quick Documentation for more elements
  • Callbacks (@doc above @callback and @macrocallback)
  • Types (@typedoc above @type, @typep, and @opaque)
• Compatibility with IntelliJ 2022.2.
• Updated Elixir version used in tests.
• Updated Gradle dependencies.

Bug Fixes

• Add compiled CallDefinitionImpl delegation targets to resolve results
• Log non-Call modulars for resolving delegation
• Fix operator token set for **.

Installation Instructions

The Livebook desktop app was just launched. Now one can install Livebook on their machine without having Elixir installed before.

Elixir turned out to be an awesome solution for this sort of product for two reasons. It made creating a purpose-built WebSocket API a joyful experience. It also allowed us to leverage its unique binary handling capabilities to handle a goofy protocol easily and present it in a Javascript digestible format to our browser clients. Check out our code here: https://github.com/pluralsh/plural How we built it: https://www.plural.sh/blog/how-we-created-an-in-browser-kubernetes-experience/