feat: New Redix and Caches lessons, refreshed existing storage lessons. by doomspork · Pull Request #3056 · elixirschool/elixirschool

doomspork · 2025-07-13T17:39:10Z

Summary

New Redix lesson covering basic usage, pipelining, data types, telemetry, transactions (MULTI/EXEC), and real-world examples (caching with TTL, rate limiting)
New Cachex lesson covering core operations, expiration/TTL, lazy loading with fetch, transactions, statistics, distributed caching, and custom hooks
Refreshed ETS lesson with updated terminology (objects), concurrency options, advanced querying, and a practical cache example

brain-geek

This is a massive and awesome update.

Added a few notes that might improve readability/consistency.

brain-geek · 2025-11-27T16:16:19Z

+
+### Building a Connection Pool
+
+For high-traffic applications, we might want to use multiple Redis connections. Here's a simple connection pool implementation:


Should we maybe skip this section? High-traffic applications are definitely out of scope for basic technology lesson.

I'm also thinking of removing the pub/sub section now too. I got carried away and wanted to cover too much to be comprehensive

brain-geek · 2025-11-27T16:21:44Z

+# Clean up Redis before each test
+ExUnit.after_suite(fn _results ->
+  {:ok, conn} = Redix.start_link(Application.get_env(:my_app, :redis_url))
+  Redix.command!(conn, ["FLUSHDB"])


This will create weird concurrency test failures if you use it in async: true tests.

Also, ExUnit.after_suite runs it after full suite, not each test.

That's fair, let me think about how to capture this best without going to off into the weeds.

brain-geek · 2025-11-27T16:22:47Z

+In our `config/test.exs`:
+
+```elixir
+config :my_app, :redis_url, "redis://localhost:6379/15"  # Use a test database


This is the first time we're using redis_url config variable.

Maybe use it in initial supervision tree setup example as well, instead of hardcoding the address?

Good feedback!

brain-geek · 2025-11-27T16:29:21Z

-In this case, we are passing in the node associated with our IEx session.
-
-## Nodes
+This command creates a new schema on the current node. After running this, you'll notice a new directory in your current working directory named something like `Mnesia.nonode@nohost` - this is where Mnesia stores its data files.


what is schema?

doomspork · 2025-11-28T15:32:48Z

@brain-geek thank you, thank you! I've been slowly chipping away at these lessons locally as I get back into the flow of writing lessons and explore some potential changes. Let me work through your feedback and other changes, then I'll tag you for another look 😁

I also screwed up using 1 PR for all the lessons, I wasn't anticipating getting reviews but I love it 🫶

Copilot

Pull request overview

Adds new storage lessons for Redis/Cache libraries and substantially refreshes existing in-runtime storage lessons to improve coverage of caching, concurrency, and distribution concepts.

Changes:

Added new lessons: Redix (Redis client) and Cachex (ETS-based cache library)
Major rewrite/expansion of the Mnesia lesson (schema, queries, distribution, examples)
Major refresh of the ETS lesson (table types, concurrency options, practical cache example)

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 13 comments.

File	Description
lessons/en/storage/redix.md	New Redix lesson with usage patterns, telemetry, caching, rate limiting, and transactions
lessons/en/storage/cachex.md	New Cachex lesson covering core ops, TTL/expiration, fetch, transactions, stats, and distributed setup
lessons/en/storage/mnesia.md	Expanded Mnesia lesson with updated structure, examples, querying, distribution/replication, and best practices
lessons/en/storage/ets.md	Updated ETS lesson with table types, concurrency options, richer querying, and a cache example

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

You can also share your feedback on Copilot code review. Take the survey.

+end
+
+defmodule MyApp.RateLimitPlug do
+  use Plug.Conn


+        # Use remote_ip if behind a proxy/load balancer
+        to_string(:inet_parse.ntoa(conn.remote_ip))
+      {:header, name} ->
+        get_req_header(conn, name) |> List.first() || "anonymous"
+      val when is_function(val, 1) ->
+        val.(conn)
+      nil ->
+        # Default fallback: IP


Copilot

Pull request overview

Adds new storage lessons for Redis (Redix) and caching (Cachex) while significantly refreshing the existing ETS and Mnesia lessons to include more advanced patterns and practical examples.

Changes:

Introduce new Redix lesson with basic usage, pipelining, telemetry, transactions, and example patterns (cache + rate limiting).
Introduce new Cachex lesson covering setup, TTL/expiration, fetch/lazy loading, transactions, stats/hooks, and distributed caching.
Refresh ETS and Mnesia lessons with updated terminology, concurrency/distribution guidance, and more “real application” examples.

Reviewed changes

Copilot reviewed 4 out of 4 changed files in this pull request and generated 13 comments.

File	Description
lessons/en/storage/redix.md	New lesson covering Redix usage patterns, telemetry, caching, and rate limiting examples.
lessons/en/storage/cachex.md	New Cachex lesson including setup, core/advanced operations, TTL, fetch, transactions, hooks, and distributed mode.
lessons/en/storage/ets.md	Major rewrite expanding ETS table types, concurrency options, querying, and an ETS-backed cache example.
lessons/en/storage/mnesia.md	Major rewrite expanding Mnesia setup, querying, distributed replication, and application-style examples.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-03-20T01:05:42Z

+  redis_url = Application.get_env(:my_app, :redis_url, "redis://localhost:6379")
+
+  children = [
+    {Redix, name: :redix, host: redis_url}


In the supervision tree example, redis_url is a full Redis URI but it's passed as host:. host: expects a hostname (e.g., "localhost"), so this configuration will fail. Use the URI form supported by Redix (e.g., pass the URI as the first argument / url: option, or use host: + port: parsed from the URI).

Suggested change

{Redix, name: :redix, host: redis_url}

{Redix, name: :redix, url: redis_url}

Copilot · 2026-03-20T01:05:42Z

+  def exists?(key) do
+    case Redix.command(@redix_name, ["EXISTS", key]) do
+      {:ok, 1} -> true
+      {:ok, 0} -> false


exists?/1 only handles {:ok, 0 | 1}. If Redis/Redix returns {:error, reason} (or any other {:ok, _}), this will raise a CaseClauseError. Add a fallback clause (e.g., return false or {:error, reason}) so the example doesn't crash on connection/command errors.

Suggested change

{:ok, 0} -> false

{:ok, 0} -> false

_ -> false

Copilot · 2026-03-20T01:05:42Z

+
+    pipeline = [
+      ["INCR", key],
+      ["EXPIRE", key, window_seconds]
+    ]
+
+    case Redix.pipeline(@redix_name, pipeline) do
+      {:ok, [count, _expire_result]} when count <= limit ->
+        {:ok, %{allowed: true, count: count, limit: limit}}
+
+      {:ok, [count, _expire_result]} ->
+        {:ok, %{allowed: false, count: count, limit: limit}}
+


This rate limiting pipeline resets the key TTL on every request (EXPIRE always runs), which turns the window into an inactivity timeout rather than a fixed window as described. To implement a fixed window, only set the expiry when the counter is created (e.g., when INCR returns 1), or use a Lua script to INCR + set expiry atomically on first increment.

Suggested change

pipeline = [

["INCR", key],

["EXPIRE", key, window_seconds]

]

case Redix.pipeline(@redix_name, pipeline) do

{:ok, [count, _expire_result]} when count <= limit ->

{:ok, %{allowed: true, count: count, limit: limit}}

{:ok, [count, _expire_result]} ->

{:ok, %{allowed: false, count: count, limit: limit}}

script = """

local current = redis.call("INCR", KEYS[1])

if current == 1 then

redis.call("EXPIRE", KEYS[1], ARGV[1])

end

return current

"""

case Redix.command(@redix_name, ["EVAL", script, "1", key, window_seconds]) do

{:ok, count} when count <= limit ->

{:ok, %{allowed: true, count: count, limit: limit}}

{:ok, count} ->

{:ok, %{allowed: false, count: count, limit: limit}}

Copilot · 2026-03-20T01:05:43Z

+...>   Mnesia.select(:users, [
+...>     {
+...>       {:users, :"$1", :"$2", :"$3", :"$4"},  # Match pattern
+...>       [{'=:=', {:hd, :"$2"}, ?A}],            # Guard (name starts with 'A')
+...>       [:"$$"]                                  # Return entire match
+...>     }


In this select/2 example, the guard uses {:hd, :"$2"} but :"$2" is bound to the name field which is a binary (e.g., "Alice"); hd/1 expects a list and will fail. Use a binary-safe approach (or adjust the example to store names as charlists) so the match spec is valid.

Copilot · 2026-03-20T01:05:43Z

+    # Create schema if it doesn't exist
+    case Mnesia.create_schema([node()]) do
+      :ok -> :ok
+      {:error, {_, {:already_exists, _}}} -> :ok


Blog.Database.setup/0 pattern matches on only two create_schema/1 outcomes; any other error tuple will raise a CaseClauseError. Add a catch-all clause (e.g., return/raise a descriptive error) so the example handles failures like permissions/invalid directory cleanly.

Suggested change

{:error, {_, {:already_exists, _}}} -> :ok

{:error, {_, {:already_exists, _}}} -> :ok

{:error, reason} -> {:error, {:schema_creation_failed, reason}}

Copilot · 2026-03-20T01:05:44Z

+[{:key, "value1"}, {:key, "value2"}]
+```
+
+#### Duplicating Bag


Heading typo: this should be "Duplicate Bag" (or "Duplicate Bag Example") to match the ETS table type name :duplicate_bag and avoid confusion with a different concept.

Suggested change

#### Duplicating Bag

#### Duplicate Bag

Copilot · 2026-03-20T01:05:44Z


+  @table_name :simple_cache
+
+  def start_link do


SimpleCache.start_link/0 doesn't actually start or link a process; it creates an ETS table owned by the caller and returns {:ok, self()}. Under a supervisor this would be misleading (and the table would disappear if the owning process exits). Consider implementing this as a GenServer/Agent which owns the table, or rename the function to reflect that it just initializes the table in the current process.

Suggested change

def start_link do

def init do

Copilot · 2026-03-20T01:05:44Z

+  {:named_table, true},
+  {:type, :set},
+  {:keypos, 1},
+  {:protection, :protected}


The :ets.info/1 output shows {:protection, :protected}, but the cache table is created with :public in SimpleCache.start_link/0. Update either the table options or the sample :ets.info/1 output so they reflect the same configuration.

Suggested change

{:protection, :protected}

{:protection, :public}

Copilot · 2026-03-20T01:05:44Z

+To add Cachex to our project let's add it to our `mix.exs` dependencies:
+
+```elixir
+def deps do


Dependency examples in this repo consistently use defp deps do (see lessons/en/basics/mix.md). This lesson uses def deps do, which is inconsistent with the earlier convention and implies a public function unnecessarily. Update to defp deps do for consistency.

Suggested change

def deps do

defp deps do

Copilot · 2026-03-20T01:05:44Z

+defmodule MyApp.CacheLogger do
+  use Cachex.Hook
+
+  def init(_), do: {:ok, nil}
+
+  def handle_notify({action, _args}, result, state) do
+    Logger.info("Cache #{action}: #{inspect(result)}")
+    {:ok, state}
+  end


This example uses Logger.info/1 inside MyApp.CacheLogger without require Logger. Since Logger calls are macros, the snippet won't compile as-is. Add require Logger in the module (or switch to IO.inspect/1/IO.puts/1 if you want to keep the example dependency-free).

doomspork force-pushed the feat-redix-lesson branch from a671023 to 8bed803 Compare July 13, 2025 17:59

doomspork changed the title ~~feat: New Redix lesson~~ feat: New Redix and Caches lessons, refreshed existing storage lessons. Jul 13, 2025

doomspork force-pushed the feat-redix-lesson branch from 8bed803 to 968cee3 Compare July 13, 2025 18:04

doomspork mentioned this pull request Jul 13, 2025

feat: Update lesson listing elixirschool/school_house#234

Closed

doomspork force-pushed the feat-redix-lesson branch 2 times, most recently from e7a2e00 to e4ced0f Compare August 4, 2025 17:32

brain-geek previously approved these changes Nov 27, 2025

View reviewed changes

doomspork dismissed brain-geek’s stale review via dd19a0f November 27, 2025 17:06

doomspork force-pushed the feat-redix-lesson branch from e418813 to a6b9051 Compare November 28, 2025 01:26

doomspork marked this pull request as ready for review March 16, 2026 00:12

doomspork requested a review from a team as a code owner March 16, 2026 00:12

Copilot AI review requested due to automatic review settings March 16, 2026 00:12

Copilot started reviewing on behalf of doomspork March 16, 2026 00:13 View session

Copilot AI reviewed Mar 16, 2026

View reviewed changes

doomspork force-pushed the feat-redix-lesson branch 2 times, most recently from a76a031 to 7dc1df5 Compare March 16, 2026 00:31

doomspork requested a review from Copilot March 20, 2026 00:59

Copilot started reviewing on behalf of doomspork March 20, 2026 01:00 View session

Copilot AI reviewed Mar 20, 2026

View reviewed changes

doomspork added 4 commits March 20, 2026 09:33

feat: Refresh ETS lesson

8601b28

feat: Refresh Mnesia lesson

5ebe814

feat: New Cachex lesson

468bb28

feat: New Redix lesson

23c634d

doomspork force-pushed the feat-redix-lesson branch from 7dc1df5 to 23c634d Compare March 20, 2026 13:36


		### Building a Connection Pool

		For high-traffic applications, we might want to use multiple Redis connections. Here's a simple connection pool implementation:

	{Redix, name: :redix, host: redis_url}
	{Redix, name: :redix, url: redis_url}

	{:error, {_, {:already_exists, _}}} -> :ok
	{:error, {_, {:already_exists, _}}} -> :ok
	{:error, reason} -> {:error, {:schema_creation_failed, reason}}

Conversation

doomspork commented Jul 13, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

Uh oh!

brain-geek left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

doomspork commented Nov 28, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Mar 20, 2026

Choose a reason for hiding this comment

doomspork commented Jul 13, 2025 •

edited

Loading

doomspork commented Nov 28, 2025 •

edited

Loading