Powering an IoT device with Elixir

Trying out Nerves

The wonders of guard and pattern matching

Language Features I Wish JavaScript Had

First impressions of Elixir as a JS developer

Hitting the ground running with Elixir

## Context

I've been playing with [Phoenix](https://www.phoenixframework.org) lately and it's been a bit of adjustment coming from Next.js, Django and Rails. Most issues I've come up agains have been entirely user error, I read some more and figure out the issue was me all along. One issue I ran into recently however, was when adding [Tailwind](https://tailwindcss.com) to a new Phoenix project.

## What happened?

I went through the [instructions to add Tailwind](https://github.com/phoenixframework/tailwind) without dealign with `nom` and `node`. But I kept running into the same issue.

```sh
mix tailwind --runtime-config default
Generated tailwind_test app
node:internal/modules/package_json_reader:4
const internalModuleReadJSON = function (f) { return require('fs').internalModuleReadJSON(f); };
                                                                   ^

TypeError: require(...).internalModuleReadJSON is not a function
    at internalModuleReadJSON (node:internal/modules/package_json_reader:4:68)
    at Object.read (node:internal/modules/package_json_reader:21:42)
    at readPackage (node:internal/modules/cjs/loader:296:36)
    at readPackageScope (node:internal/modules/cjs/loader:329:19)
    at trySelf (node:internal/modules/cjs/loader:444:40)
    at Function.Module._resolveFilename (node:internal/modules/cjs/loader:910:24)
    at Function.Module._load (node:internal/modules/cjs/loader:778:27)
    at Module.require (node:internal/modules/cjs/loader:1005:19)
    at Module._preloadModules (node:internal/modules/cjs/loader:1276:12)
    at loadPreloadModules (node:internal/bootstrap/pre_execution:487:5)
** (Mix) `mix tailwind default` exited with 1
```

## Where is the issue?

After a trying different versions of the mix library, then the tailwind-cli directly, I finally found the problem.

An issue on the **vercel/pkg** repo reveals the problem, [Packaged apps crash with zero messaging when NODE_OPTIONS is set](https://github.com/vercel/pkg/issues/1517)

I usually run my projects in the VS Code terminal, what I didn't realise is that the `NODE_OPTIONS` environment variable is set to make debugging easier and this causes issues with the tailwind-cli.

### Why does it happen?

The reason this happens is due to the tool, **vercel/pkg**. It's a tool for packaging a node app into a single binary and Tailwind uses this to create their CLI. The benefit to users is that if you don't want to deal with Node and NPM directly, you can use **tailwind-cli** without any dependencies.

## How did I work around this?

### Run it from another terminal

The VS Code terminal is convenient but with this issue, the easiest workaround is to run the commands in a standalone terminal of your choice. 

### Unset the environment variable

Running `unset NODE_OPTIONS` in the VS Code integrated terminal before `mix tailwind default` worked for me and lasts for the session.

### VS Code settings

I also had success adding the following to the workspace settings - `.vscode/settings.json`

```json
{
  "debug.javascript.terminalOptions": {
    "env": null
  }
}
```

This will disable the ability to attach to code in the project automatically but for a Phoenix project where I was avoiding using Node anyway, this isn't a problem.


---

There you have it. Hopefully this issue will be resolved in future and this workaround won't be needed but as of Tailwind 3.0.24, it's useful to know when running from a VS Code integrated terminal. I used `mix tailwind --runtime-config default` mainly for testing my tailwind setup, if you're using this with phoenix you'll likely be running `mix phx.server`.

Working around a build issue with Tailwind and Phoenix

As a web developer, serving static assets is essential. It may be images, JavaScript and CSS or even static HTML pages. Let’s take a look at how we could make a very basic web server that serves everything from a static assets folder.

## What we’re making
We’re going to make server in Elixir using `plug_cowboy` that will serve the `assets` folder. This will be very simple and won’t do any routing, we’ll simply use the `Plug.Static` plug. 
Take a look at the source code in an [example repo here](https://github.com/Darth-Knoppix/elixir-exercises/tree/master/simple_plug_static).

## How to make a static asset server
Let’s start from scratch and create a new project, if you’ve got an existing project there’s only a couple changes to make so you can use this as a guide.
### Create a new project
Run `mix new simple_plug_static --sup`  to setup the project then add `plug_cowboy` to your dependencies in `mix.exs`

Your `mix.exs` `deps` function should look like this:
```elixir
defp deps do
  [
    {:plug_cowboy, "~> 2.5"}
  ]
end
```

_You can update the dependencies afterwards by running `mix deps.get`._

### Use `Plug.Cowboy` 
The only other step is to update `lib/simple_plug_static/application.ex`.

Update the `children` variable to setup a `Plug.Cowboy`.
```elixir
children = [
  {Plug.Cowboy, scheme: :http, plug: {Plug.Static, at: "/", from: "assets"}, options: [port: 3000]}
]
```

The key part is using `Plug.Static` and providing a couple of options.
- `at` specifies the path that’s accessible on the server
- `from` specifics the directory to serve, in our case let’s set this to `assets`

### Create some assets to serve
Create the following folder `simple_plug_static/assets` and put some files you want to serve. In the example, I created `hello.txt` but other files should work just the same.

### Start the server and try it out
Start the server with `mix run --no-halt`, once it’s up and running you should be able to visit [localhost:3000/hello.txt](http://localhost:3000/hello.txt) in a browser to access the static resources.

That’s it.

## When to use this
This is a very simple static asset server with almost no configuration. In a real world scenario, it’s more common to use a router and serve static assets as [part of a larger application](https://hexdocs.pm/plug/Plug.Static.html#module-examples). 

## Resources
- [Plug.Static docs](https://hexdocs.pm/plug/Plug.Static.html "Plug Static")


A short step-by-step guide on how you can create a simple web server that serves static files in Elixir.

You’ll often hear talk about Phoenix a lot in the Elixir ecosystem but there are a few other options for web servers. We’re going to take a look at what underpins Phoenix and see how to create a simple web server in Elixir. We’ll use [`plug_cowboy`](https://hexdocs.pm/plug_cowboy/Plug.Cowboy.html) which combines the Erlang web server [Cowboy](https://github.com/ninenines/cowboy) and a nice adapter [Plug](https://hexdocs.pm/plug/readme.html).

## What we’re making
We’re going to make what can barely be called a web server, it’s simply going to respond with “Hello World” over HTTP/1.1. It’s a humble start but from here, it’s easy to add routing, serve static assets, make your own API and more.

If you’d like to see the code right away - take a look at the [example repo here](https://github.com/Darth-Knoppix/elixir-exercises/tree/master/simple_plug_rest). 

## Creating a simple server
We’ll create a new project, add the only dependency we need - `plug_cowboy`, then do a little bit of setup.

### Create a new project
Let’s start with a new app: `mix new simple_plug_rest --sup`, this will create a barebones Elixir project.

Now, install`plug_cowboy` in `mix.exs` like so:
```elixir
def deps do
  [
    {:plug_cowboy, "~> 2.0"}
  ]
end
```

_You can update the dependencies afterwards by running `mix deps.get`._

### Create a simple Plug
A plug is a specification for our web server, let’s make a simple plug based on that simply replies with “Hello World”.

```elixir
defmodule SimplePlugRest do
  @moduledoc """
  A Plug that always responds with a string
  """
  import Plug.Conn

  def init(options) do
    options
  end

  @doc """
  Simple route that returns a string
  """
  @spec call(Plug.Conn.t(), any) :: Plug.Conn.t()
  def call(conn, _opts) do
    conn
    |> put_resp_content_type("text/plain")
    |> send_resp(200, "Hello World")
  end
end

```

### Setup Application:
The final piece of the puzzle is to start the Cowboy server as a supervised process and tell `plug_cowboy` which plug to use.

```elixir
defmodule SimplePlugRest.Application do
  @moduledoc false

  use Application

  @impl true
  def start(_type, _args) do
    children = [
      # Start `SimplePlugRest` and listen on port 3000
      {Plug.Cowboy, scheme: :http, plug: SimplePlugRest, options: [port: 3000]}
    ]

    # See https://hexdocs.pm/elixir/Supervisor.html
    # for other strategies and supported options
    opts = [strategy: :one_for_one, name: SimplePlugRest.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

```

Start your web server up by running `mix run --no-halt` then visit `localhost:3000` in your browser! It’s not pretty, but it works.

## What about JSON?
One of the most common response types nowadays is JSON. If you’d like, you can leverage the [jason](https://hexdocs.pm/jason/Jason.html) package to encode a map in Elixir.

To get started, add `{:jason, "~> 1.1"}` to your `mix.exs` deps.

Then use `Jason.encode!` to encode the data. If you were to build upon this, a simple helper function could do make creating a json payload easier.

In the meantime, the `call` method will look something like this:
```elixir
def call(conn, _opts) do
  body = Jason.encode!(%{hello: "world"})

  conn
  |> put_resp_content_type("application/json")
  |> send_resp(200, body)
end
```

That’s it. You now have the building blocks for creating a web server in Elixir with some easy to use libraries.

## Resources
- [Plug documentation](https://hexdocs.pm/plug/readme.html#hello-world)
- [Jason documentation](https://hexdocs.pm/jason/readme.html) - for JSON encoding and decoding

A short step-by-step guide on how you can create a simple web server in Elixir.

There might be some situations where you need to know which operating system your code is running on, especially if you're making your own mix tasks that need to work on different platforms. A common use case could be determining the location of a file to read it as config or maybe finding the correct application to launch. This can be achieved with the operating system module in Erlang.

It's as easy as `:os.type()`, running it on my M1 Mac I see the following output in IEx.

```sh
iex(1)> :os.type()
{:unix, :darwin}
```

From this I can see that my operating system is in the Unix family with the Osname, Darwin. On a Windows machine, you'd see `:win32` as the Osfamily. 

## When would this be used?

Here's an example of how this is used in the [ExDoc codebase](https://github.com/elixir-lang/ex_doc).

```elixir
defp browser_open(path) do
  {cmd, args, options} =
    case :os.type() do
      {:win32, _} ->
        dirname = Path.dirname(path)
        basename = Path.basename(path)
        {"cmd", ["/c", "start", basename], [cd: dirname]}

      {:unix, :darwin} ->
        {"open", [path], []}

      {:unix, _} ->
        {"xdg-open", [path], []}
    end

  System.cmd(cmd, args, options)
end
```

[See this snippet in the ExDoc codebase](https://github.com/elixir-lang/ex_doc/blob/af1715ca33d5779c1a388d1d653ae481c417d166/lib/mix/tasks/docs.ex#L481)

This is an easy way to tailor this script to open the browser so it works on more platforms.

## Resources

- [:os.type/0 - Erlang docs](https://www.erlang.org/doc/man/os.html#type-0)



How to detect the operating system family and name within the Elixir language (by using the OS module in Erlang)

Learn more about Elixir

Elixir Articles