Forem: Paulo Henrique da Silva

Solving Advent Of Code 2024 on a elixir project

Paulo Henrique da Silva — Thu, 05 Dec 2024 13:18:43 +0000

TL;DR: If you want to take a look at the project itself, here's the GitHub repo

Every year, we have a cool event that happens in December. It's called Advent Of Code, and there are 25 challenges, one for each day until it reaches Christmas 🎅.
In previous editions, I never finished it, and I can list a lot of excuses here 😅, but the main one is that I have issues conciliating job with coding off-hours because I want to do something else, like play video games, watch a movie, or stay with the family.
For 2024, I'm trying to do it end to end. The programming language I've chosen to do so is Elixir because it's my main language and the one that I'm comfortable with nowadays. I know some people use the advent of code to learn new programming languages, which I think is pretty valuable, too.
So, as a way to have the minimum setup as possible to solve the day challenge, I've set an elixir project using the command:

$ mix new advent_of_code2024

This will generate the following struct:

📁 advent_of_code_2024
- 📁 .elixir_ls
- 📁 _build
- 📁 lib
- 📁 test
- 📄 .formatter.exs
- 📄 .gitignore
- 📄 mix.exs
- 📄 README.md

Then, I started to think in a generic way of implementing the entry point to execute a specific day challenge, and end up having a function, AdventOfCode2024.run/1:

defmodule AdventOfCode2024 do
  @moduledoc """
  Documentation for `AdventOfCode2024`.
  """

  @spec run(non_neg_integer()) :: {:ok, any()} | {:error, any()}
  def run(day) do
    solution_module = String.to_existing_atom("Elixir.AdventOfCode2024.Day#{day}")

    day
    |> input_file()
    |> File.read!()
    |> solution_module.run()
  rescue
    error ->
      {:error, error}
  end

  defp input_file(day), do: "#{File.cwd!()}/lib/advent_of_code2024/inputs/day_#{day}"
end

That function receives an integer attribute, representing the day challenge you want to execute, and then, the solution_module variable concatenates it with the module name pattern I use.
Still using the day argument, I get the respective input that the advent of code provides and pass the input content using File.read!/1 to the solution module run/1 function.

If something fails, like the input file or the solution module was not found, or it does not implement the expected run function, I return {:error, Exception.t()}, otherwise the result of AdventOfCode2024 will be the result of the solution_module.run/0.

And, of course, I added tests 😄; this is the test for the entry point:

defmodule AdventOfCode2024Test do
  use ExUnit.Case
  doctest AdventOfCode2024

  alias AdventOfCode2024

  describe "run/1" do
    test "runs solution of the provided day" do
      assert {:ok, _} = AdventOfCode2024.run(1)
    end

    test "returns error when solution fail or is not found" do
      assert {:error, _} = AdventOfCode2024.run(100)
    end
  end
end

Now, let's take a look at the structure where the day solution module lives:

📁 advent_of_code_2024
- ...
- 📁 lib
  - 📁 advent_of_code2024
    - 📁 inputs
      - 📄 day_1
    - 📄 day_1.ex
- 📁 test
  - 📁 advent_of_code2024
    - 📄 day_1_test.exs

Every day challenge has an input, that follows the pattern day_#{n}, the solution module, day_#{n}.ex, and the test file day_#{n}_test.ex.
So, whenever I solve a new challenge, I just need to add these files to the project, and run AdventOfCode2024.run(1) for example.

(SPOILER) Here's an example of the day 1 solution, part 2:

defmodule AdventOfCode2024.Day1 do
  @moduledoc """
  Solution of day 1
  """

  def run(input) do
    result =
      input
      |> parse_input()
      |> find_distances()
      |> Enum.sum()

    {:ok, result}
  end

  defp parse_input(input) do
    input
    |> String.split("\n")
    |> Enum.reduce(%{left: [], right: []}, fn line, acc ->
      [left, right] = String.split(line, ~r/\s+/)

      %{
        acc
        | left: [String.to_integer(left) | acc.left],
          right: [String.to_integer(right) | acc.right]
      }
    end)
    |> Map.update!(:left, &Enum.sort/1)
    |> Map.update!(:right, &Enum.sort/1)
  end

  defp find_distances(parsed_input) do
    find_distances(parsed_input, [])
  end

  defp find_distances(
         %{left: [minor_left_value | left_rest]} = parsed_input,
         distances
       ) do
    count = Enum.count(parsed_input.right, &(&1 == minor_left_value))
    updated_distances = [minor_left_value * count | distances]

    find_distances(%{parsed_input | left: left_rest}, updated_distances)
  end

  defp find_distances(%{left: []}, distances), do: distances
end

and the test:

defmodule AdventOfCode2024.Day1Test do
  use ExUnit.Case
  doctest AdventOfCode2024.Day1

  alias AdventOfCode2024.Day1

  describe "run/1" do
    test "calculates the distance" do
      input =
        Enum.join(
          [
            "3   4",
            "4   3",
            "2   5",
            "1   3",
            "3   9",
            "3   3"
          ],
          "\n"
        )

      assert Day1.run(input) == {:ok, 31}
    end
  end
end

You may wonder how I am organizing part 1 and part 2 solutions in GitHub, and I'm using commits and tags like so:

commit <sha> (tag: day_2_2nd_solution)
    Day 2 - Second solution.

commit <sha> (tag: day_2_1st_solution)
    Day 2 - First solution.

This way, I can use git checkout day_n_(1st|2nd)_solution and run AdventOfCore.run(n) to get the result of the specific day/part I want to.

That's pretty much it. Thank you for the reading, and if you're curious to see and try the project, here's the GitHub repo; depending on when you access it, I may (or may not 😅) have finished it, I hope this structure works for you as well.

Cheers!

Setting up Zed for Elixir development 💧

Paulo Henrique da Silva — Sat, 09 Nov 2024 16:42:57 +0000

TL; DR: In this article, I describe how I setup zed to develop in elixir and phoenix framework, and here is the gist having the settings I use

It's been a while since I use VS Code to develop elixir applications, and so far, it has been a great tool, especially when using extensions like ElixirLS, Phoenix Framework, Jump to Test, and others.
But like all tools, it has some bottlenecks, and for me, the bottleneck is when working with large projects, where I need to switch between branches multiple times during the day.
Because of that, I started to search for alternatives, and Zed seemed to be the new hype. Don't get me wrong. I know many developers love Vim, but I'm a UI boy and haven't had good experiences with it; I know it's a great editor, but it's just not my thing 😅.
So, let's go back to Zed. To install it, you can use package managers like homebrew or download it directly from their website.
To download by homebrew, you can use the following command:

$ brew install --cask zed  && zed

That's it; you have Zed installed; now let's configure it for Elixir development!
One of the most important tools, at least for me, is the language server, which helps with auto-complete, lint validations, and formatting. Currently, elixir has three options, elixir-ls, lexical, and next-ls. All three are great, and each one has your strength and weakness, I know that there are plans to have a new one that has the goal to be a join of those three to have a LS to rule them all, looking forward to it 😃.
But until this day doesn't come, I personally prefer ElixirLS, that comes as default on Zed; in my experience, it tends to be more stable when working with large projects, but that's me, you may find that prefers lexical or next-ls, this last one for example allows you to setup credo warnings to be shown in the code, which is pretty cool.
To setup a language server, use the shortcut cmd + shift + P and type and select the option zed: open settings, and add the following code:

"languages": {
  "Elixir": {
    "language_servers": ["elixir-ls"] // <- `next-ls` or `lexical`
  }
}

Then, you can setup the specifics based on what language server you prefer, for ElixirLS, I like to turn off dialyzer when developing and let CIs like CircleCI or Github Actions to run that for me when I push the branch, to do so, you can add lsp config like below:

"lsp": {
  "elixir-ls": {
    "settings": {
      "dialyzerEnabled": false
    }
  }
}

Pretty easy, right? Now, let's set up the second most important tool for me: code formatting. Here is the snippet we need to add to enable auto format on zed:

"languages": {
  "Elixir": {
    "language_servers": ["elixir-ls", "tailwindcss-language-server"]
  }
}

At this stage, you have the minimum requirement to start developing in elixir on Zed; now let's go into specifics, HEEX:

"languages": {
  "HEEX": {
    "language_servers": [
      "elixir-ls",
      "tailwindcss-language-server",
      "emmet-language-server"
    ]
  }
}

In the snippet above, we're setting up heex to format using mix format, elixir-ls, for elixir code that may be inside of the heex files, tailwindcss-language-server, to have tailwind classes auto-complete, and emmet-language-server, to have auto-complete for HTML (i.e. div.flex to be converted to <div class="flex"></div>).
One caveat about Emmet, you may need to do a workaround to make it work as expected. First, use cmd + shift + P, and select option zed: extensions, and install Emmet extension. Once you install it, open and edit the file ~/Library/Application\ Support/Zed/extensions/installed/emmet/extension.toml to reference heex extension:

[language_servers.emmet-language-server]
language = "HTML"
languages = ["HTML", "PHP", "ERB", "JavaScript", "TSX", "CSS", "HEEX"]

[language_servers.emmet-language-server.language_ids]
HEEX = "heex"

Well, that's pretty much it; thank you for reading this! I hope this was useful for you. If you like it or have suggestions on how I can improve this post, please leave a comment; I'll be glad to know that this is being helpful 😄.
Here's the gist having my Zed config, where I'm going to keep updating when learning more about it.

Cheers!