Forem: Mạnh Vũ

Replace JSON by TOON in Phoenix Channel

Mạnh Vũ — Sat, 21 Mar 2026 08:55:13 +0000

Intro

I'm build a realtime system based on Phoenix Channel. After some workload/benchmark test, I realized encode/decode task in JSON is quite expensive tasks for our system 🤔

I have replaced Jason (default Phoenix JSON lib) by native JSON and save tons of CPU and memory resource. I quite happy for this lib but still want to try more and look around.

One day, I found TOON format that can save traffic cost for our system.

TOON format

I found this is quite fun because I saw people use for saving tokens (and money) and improve accuracy for LLM.

The documents of TOON said can save 30-60% tokens, I found an interested thing in here, I can save bandwidth for network (and my server can serve more users). I also found some benchmarks say parsing TOON format is faster than JSON, that's nice 👌

Another interested thing is TOON is compatible with JSON, so that enough for me deep dive to TOON.

Pros:

Very friendly for dev (like yaml)
Reduce size of data (much more than JSON if use array of simple objects)
Don't need to convert to other format and save tokens if you integrate with LLM

Cons:

Some libraries is not optimized
Not reduce size of you use nested objects

Look a way to apply Phoenix Channel

After look to Phoenix implement I see Phoenix is using JSON quite simple. A module for serializing between JSON and Elixir type.

We have two way to replace JSON in Phoenix, one is json library, another is serializer lib for only websocket connections.

Change JSON Library

This module use other library. We can change encoder/decoder just by set config in config.exs file.

config:

# used native JSON lib (built-in Erlang) for save cpu & memory
config :phoenix, :json_library, JSON

After this, I went to find libs that support to encode/decode between string and Elixir type.

I asked on elixir forum and toon_ex is library the member in forum suggested for me, that's nice because toon_ex is quite similar to Jason library.

Change Serializer Module

If we need keep other JSON apis or LiveView, we can update serializer module only for websocket connections.

The first we need to implement a custom serializer like:

defmodule MyApp.CustomSerializer do
  @behaviour Phoenix.Socket.Serializer

  alias Phoenix.Socket.{Broadcast, Message, Reply}

  def fastline
  ...
end

In endpoint.ex file we add our serializer module to socket like:

  socket "/socket", MyAppWeb.ChannelSocket,
    websocket: [
      connect_info: [:peer_data],
      serializer: [{MyApp.CustomSerializer, "~> 2.0.0"}]
    ],
    longpoll: false

Now I can go further.

Apply TOON to Phoenix

Because TOON is compatible with JSON then I though I can replace JSON lib for both Phoenix LiveView and Phoenix Channel. For LiveView it need to integrate with JS in client then I chose to start with Channel first.

After some hours to try toon_ex I found too many bugs and missed a function encode_to_iodata for Phoenix, I decided improve this.

Now toon_ex can run smoothly, I go to integrate with Phoenix and build a client to test.

In client, I built a Websocket client for Phoenix Channel, I also use improved toon_ex library. It works perfectly.

I try with some complex types and this runs smoothly.

In my system, Phoenix Channel run in a different app then I don't need to update LiveView this time.

I published my PoC and my updated toon_ex at:

Conclusion

TOON format is still new and in Elixir ecosystem it's not good enough, I saw on hex.pm just has two libraries and these are not mature.

Phoenix quite easy framework for deep dive and see what happen. From my view the maintainers of the framework can use serializer as plug like other module then user can easy to use with other type than JSON (like MessagePack,...).

I will continue to try to add TOON for LiveView and update this topic later.

I add some features for TOON and published on hex.pm

Thanks for reading!

App power by LLM and Tools in Elixir

Mạnh Vũ — Mon, 03 Nov 2025 12:07:26 +0000

Intro

Recently, I wrote an example for my friend can see and understand how to apply AI to web application. He have used ChatGPT and think AI still unstable & not good enough result.

Actually, He just use chat mode and provides some basic guides for tasks. He doesn't how to declare rules & guide for AI can understand more about task.

To help him to understand how AI can process data in an application, I wrote an example by Elixir.

For save time, I used Phoenix + Ash(with AshAi) + Reactor.

Concept of application

I made an Elixir application to help process estimate tour cost from raw data.

I used local LLM & Google Gemini 2.5 Pro for developing.

For integrating AI with application, I write 2 flows.

The first one is using AI for extracting data from raw request (text) and get necessary information for later task. After that application have enough information for collecting suppliers then estimate cost for tour. In this flow, data can be processed without any action from user. AI cost for this flow can be optimized easily.

Some photo from screen of app:

The second one is using chat flow for interactive with user for ask requirement and get supported from tools to query local data. This flow is flexible but take time & cost more than the first one.

Some photo from screen of app:

How I integrate AI with Elixir application

I used Ash framework with AshAi extension & Reactor for fast developing application. This cost 3-4 days for integrating AI (my first app that included AI) and 2 days for declarative domain (database schemas) by Ash and UI for show and input data.

Ash framework is powerful framework if you want to save time and build extensible things.
Recently, I use Ash framework for almost task with database. I don't want to work with database & query too much!

When making this application, I explored Reactor is very nice thing when work with flow of actions. Reactor help me easily define complex flow that can rollback, retry and compose with other flows.

For AshAi, I think is nice but need to improve documents and give community more examples. Don't see any way for export directly tools for using directly in LangChain.

An other library that I tried is Jido, I like style of Jido than AshAi and Reactor but this lib still so young and need to improve for support LangChain better.

Conclusion

Integration AI to Elixir application is simple. For me, I just need to understand how tools are called in LangChain and how to write right guides to help AI can understand task and tools.

Elixir is grown fast and has a lot of nice libraries and frameworks from community.

Solve alias problem in Elixir

Mạnh Vũ — Fri, 24 Oct 2025 03:04:00 +0000

Recently, I must type too much for alias Module for using short name in code(Module name in Elixir is quite long). Problem here is I need to repeat that action over and over.

When posted a proposal for solve this problem I receives an advice very valuation from community. I repost the idea in here for people can read and solve problem if that problem is like mine.

Define a macro and function for supporting centric all aliases like:

defmodule Namespace do
  @moduledoc """
    This module provides a way to define a namespace for a set of modules.
    It can be used to define a set of modules that share a common prefix.

    This version only support for native atom not a alias.

    # usage
    ```


    use Namespace, DataSpace


    ```
  """

  defmacro __using__(namespace) do
    Namespace.get(Macro.expand_once(namespace, __ENV__))
  end

  def get(Suppliers) do
    quote do
      alias MyApp.Domains.Suppliers
      alias Suppliers.Hotel
      alias Suppliers.Transport
      alias Suppliers.Restaurant
    end
  end

  def get(Customers) do
    quote do
      alias MyApp.Structs.Customers
      alias Customers.Address
      alias Customers.Details
    end
  end
end

In other module I can use like:

defmodule MyApp.Data.Processor do
  use Namespace, Suppliers

...

end

This way help me provide a centric way and clean code for alias and avoid to repeat add alias ... action.

Downside of this way is compiler is warning if an alias is unused.

Original idea is from post in Elixir community

Vibe Coding with Elixir/Phoenix

Mạnh Vũ — Thu, 18 Sep 2025 08:49:22 +0000

Intro

I run a startup with 4 members, a full time member and 3 others are part-time (one support for business strategy & documents). It's so hard for us with a ton of tasks (we build a quite big system with numbers of services). We try some ways for speed up development time but still overload for us (limited resources).

Before go to vibe coding I used Copilot (premium version) for almost thing is suggestion and it quite good for this, much better than Language Server. From my view, Copilot can improve my performance around 10-15%.

When we start to build DiSport project, LLM model is still in early stage and limitations for coding (especially for Elixir). After couple years, I see it a lot of improvements for coding and vibe coding is booming then I went to try vibe coding with our project (write by Elixir & Flutter).

Go to vibe coding

The first try, I start with our web site https://ohhi.vn. I tried to improve UI for people can easy to read our post on that. I setup a AI agent with Gemini from Google and setup MCP servers for that. After couple hours our site have totally new UI with much more beautiful & look modern. Agent can run test, migration & compile then fix bugs from our project. Some time it make mistake and loop then a fix with small change then agent can continues task.

The second try, I go to with both Claude Code & Gemini. I see Claude is good for integrating with Zed and CLI is run faster than Gemini (but Gemini has nice & easy to track change from agent). About Elixir Claude Code is done good than Gemini but I think with UI and work with HEEX template Gemini do better.

The third try, I try to build all new service by Claude Code, I don't give agent run full script just step by step for easy tracking what happen. I make new Phoenix project and add Tidewave, UsageRules and config Zed for this repo. Agent is speedup my process much more than anything else, I think at least x3 time when compare with I coding without agent and just using Copilot for suggestion.

I have plan to build our agent for other task by Jido and think again about new way for user interactive with our application.

Cost of vibe coding

I try to build a local LLM with my old PC + couple of GPUs (24 VRAM) that is enough for LLM with 30B (Q4) to run. It's fast for generating new skeleton project but for big project like our it too slow then I go to third party services. For who want to build local LLM I think LLM with 70B enough for almost tasks.

For Gemini, it's quite expensive for us. I spend about around 300$ for improve UI task.

For Claude Code, I see it's cheap than Gemini.

I also try other providers but these are limited their services for Vietnam then I don't use!

Conclusion

Vibe coding is good for experience dev & help any company can save cost & time to develop product. Startups with limited resources are get a lot of benefit from vibe coding.

From my view, vibe coding improve performance at least 10 times for common tasks also help for dev can summarize & understand big project significant faster. I also reduce number of documents because AI can help to generate that any time!

Vibe coding is totally change our way to develop prod but it has a downside that is for new members (with limited knowledge about system & skills is weak) they can't catch up process & other members.

Configs I used:

Gemini 2.5 Pro
Claude Code Sonet 4
Zed IDE
LM Studio for host local LLM on PC (AMD 3700X, 64GB RAM, 2 x Nvidia 3060 12G)
Dev machine Macbook Pro 14 M1 Pro + 16GB RAM

Server Side Render vs Client Side Render - My POV

Mạnh Vũ — Thu, 14 Aug 2025 04:56:21 +0000

Intro

Look back a little of bit, we have several decades with hypertext, from static site to web3 (still too early stage).

I still remember first time I used computer and open a web site. In that time, all things in site is static files with hypertext link. Today, site is wonderful thing with ton of animations & medias.

Web go from static site to server side render(SSR) to client side render(CSR). Today, sound like we back to SSR. I point some different things in this post.

Before go further, I will explain a little of bit about SSR & SCR.

SSR

SSR is bring web to a dynamic world, we can render a site with dynamic content & more useful things. PHP is a famous web development language using SSR.

In the first time, web server with SSR is always render full HTML and work with pure HTTP. Now, SSR support transport content by Websocket & just send different content to client.

Remember in here, we work directly with data and small number of public APIs (almost is HTTP GET/POST).

In SSR, frontend(FE) and backend(BE) are united.

Today, some new framework like Phoenix has ton of improvement like just render different HTML and send to client (over Websocket) to update.

CSR

CSR is bring web to a higher level, web has much more interact site with tons of medias & animations.

In CSR way, frontend(FE) and backend(BE) are separated. Between BE & FE is an API layer (Rest API is the most common thing for CSR).

CSR reduce workload for server but for first time loading site it much more data need to load.

Remember CSR is better for scale but bring a lot of works for create & maintain APIs.

SSR vs CSR

Now, I try to compare SSR and CSR. I will add some uses for easy to understand.

Development phase:

In this phase, SSR is much more simple than CSR. SSR doesn't need to thing to much for design & adding Api layer. A fullstack dev can work smoothly from FE to BE.

A lot of api that mean we need more work to check compatible & security.

If you have a multi teams work same project, CSR is better for separating work between teams.

If you develop site with complex state, SSR is matched with you (doesn't require to sync state between server and client).

Deployment phase:

CSR bring complex to deploy we need to setup & verify thing like api gateway & api version.

For site need to get data from several BEs, CSR is the best choice.

With SSR we need more resource in server side.

CSR is easy to scale & isolation but its downside is hard to troubleshooting.

Maintain phase:

CSR has more APIs to maintain.
SSR almost code run in server side then we don't need care about compatible.

Now we have ton of devices, I will try to figure out.

Security

CSR has a lot of work to make sure sites is safe.

SSR is much more simple than CSR.

PC/Laptop

In this type of device, good resource (RAM/CPU) and user behaviors (open a site in long time for work) then CSR is good for this.

SSR is good for short live site.

Mobile

Sound like CSR has it limitations, bandwidth of network is an issue. Limited resource of low end device can impact performance for CSR.

User behavior (short live) is good for SSR (and reduce code 4/5G for user).

IoT

I think CSR has a big issue in here, not much resource for CSR can run.

SSR is good for IoT, it doesn't require good resource for loading sites.

Today web tech

Both SSR & CSR have use new tech to improve like using websocket for reduce data need to transfer between server & client).

SSR has improve the way of render like just check changed state and render different contend and update it in client side.

CSR has reduce data (js/css) need to load in the first time.

Conslusion

SSR is better in small team (with fullstack devs), small product and large range of devices. Better for stateful site.

CSR is better in large site (complex & scalable site) or web app with workload run in client side.

Ash framework and our journey to it!

Mạnh Vũ — Fri, 25 Jul 2025 14:35:25 +0000

Intro

We're a startup with all our system with Elixir (except mobile app).

Our journey

We start build our MVP with Elixir from craft with our knowledge. We have a good background about Erlang but still have a lot of things for us. We will talk about some rounds we faced with.

First round, we start with almost built-in library of Elixir & Erlang (we came from Erlang world). Still fast for us when compare time to develop with other tech stack like Node or Go (Go cannot match with Elixir for build a realtime & reactor system except performance!). In this time, we use Ets for memcache (we have built a cache library based on Ets) and Mnesia for storage (or things that need transaction). Yep, it's nature with dynamic type and we free of mind to work with that. It is fast lane for us, PoC is done so quick! In this time, we put all apps in an umbrella project.

Second round, we decouple our system for better development phase & can get ready for scale in the future. Yes, dynamic type + cluster (built-in) help us a lot! No other things like Elixir and it ecosystem, we can decouple our system in a week! (benefit from distributed system) Now we have dynamic cluster on K8s, nice job!

Third round, we start using Ecto + Postgres for better performance & other benefits like code generation, form, validate,... We still happy with Phoenix/Ecto but we see a problem that is we need to write boilerplate code for query and our Apis. We don't use regular Api like Rest Api because it not match with our realtime system and overload for header, security check,...

Fourth round, we want to try a new thing to reduce time to develop and think about Domain Driven Design system. We changed our system several times and see a problem, we need to reduce change business logic and presentation layer. We have a look with Ash framework and try it. It's so amazing thing for us. Ash framework uses declarative for code generation. From my view, that way help us to reduce time for write & test our code. Ash is extensible that is important thing for us. Ash and LiveView are nice things we found when work with Elixir ecosystem!

Benefits of us when work with Ash

Ash framework has a lot of other benefits but in here we only talk things we used and got benefits.

The first, we can easy to move from this persist storage system to other. In Ecto we can do that but only with SQL type, in Ash we can build our storage to any type of storage system. Currently, we using Postgres but in the near future we need to move to other things like Cassandra, ClickHouse,... when work with Ash we don't need to rework too much!

The second, we don't use regular api like Rest api then we need to add a layer for converting from this type of data to other type, with Ash we can easy to create and extension for our api and reduce boilerplate code and have us easy to trace any issue if our system have.

The third, with Ash, we keep our system around DDD style for expert domain can understand & talk with dev.

Downside of Ash

Yes, Ash have a downside for us!

Need to learn (new style for us but not much because we have worked with Ecto before).

Error that raised by Ash also is a thing that made us to think because it is raised by macro then we need time to understand this (actually, Ash has Spark library and it raise error quite good).

Run slow than normal when we work directly with Ecto.

We will come back and talk more about Ash. Thank you for reading!

Zed - New universal IDE for me

Mạnh Vũ — Fri, 25 Jul 2025 03:04:06 +0000

Totally, I have new IDE that is the best fit for me!

Before Zed, I usually use VS Code for work. It's quite good for universal IDE if you don't need to care about your computer's resource.

Sometimes, I tried other text editor/IDE but no one is good enough me almost because lack of extensions and language server, I usually work with two or three languages in same time. I have tried Neovim & Emacs (actually, I worked with Emacs for Erlang before) but that is not match for my work flow.

Zed is the best fit for me, it can keep my mindset from time when I worked with VS Code, move from VS Code to Zed without effort that is nice!

I can get almost things (extensions, LS) like when I worked with VS Code and save tons of resource for me. When working with VS Code I opened 4-5 repos in same times and 2-3 languages and switch between them for me my Macbook Pro 14' with 16GB almost full of RAM (and around >10GB swap disk) and 10-15% cpu for VS Code processes. Now, with Zed I have almost no swap disk and almost zero cpu for Zed, that's amazing! After switch to Zed, I have more resources and battery life for other things!

An other things, you still using Copilot and other AI for suggesting & solve problems in IDE!

Resource before & after

My Macbook Pro 14 (M1 Pro + 16GB Ram) resource before & after:
Before: Ram 80-85% + 10-15 GB swap file. CPU 20-30%
After: Ram 65-72% + 900MB swap file. CPU 10-15%

(Note: I usually work with 4-7 repos in same time with Elixir + Dart/Flutter).

Conclusion

Yes, Zed save a lot resources for me and electric bill (and save Earth)!

Migrate to Phoenix 1.8 guide

Mạnh Vũ — Mon, 28 Apr 2025 11:33:13 +0000

Intro

Phoenix is amazing web framework. Now Phoenix released new version, it's RC version but I think it's ok for try a new thing that will bring for us some benefits with daisyUI for supporting add themes & new features (like auth, scopes,...). For more info about v1.8 release please go to this blog

Installation

You can install Phoenix follow regular cmd:

mix archive.install hex phx_new 1.8.0

Migration

This guide help you migrate Phoenix from 1.7 to 1.8 version

Before continue, we need create a simple Phoenix app with new version for copy some scripts to our project.

mix phx.new --no-ecto hello

Update assets folder

New version of Phoenix has some new scripts, folders & files look like:

If you don't have any customized script in old project just override all files from new Phoenix app, excepted one file is app.css need to update a path:

/* Update this follow your app */
@source "../../lib/hello_web";

Update layouts

Now Phoenix uses single layout, we can remove app.html.heex in template folder of Layouts.

Copy root.html.heex & layouts.ex from new app or update your old code.

<Layouts.app flash={@flash}>
<:breadcrumb>
<.link patch={~p"/"}>HOME</.link>
</:breadcrumb>

...

</Layouts.app>

If you don't need navigation in your pages you just need to add <Layouts.flash_group flash={@flash} /> to top of your template.

Some other modules like router maybe has plug put_root_layout like put_root_layout, {YourApp.LayoutView, :root} please update to new {YourApp.Layouts, :root}.

Update core_components.ex

We need update a little of bit follow new thing in the new version of Phoenix or if you don't have any customized code in here just copy from new app then update module name.

You can see from above photo we need remove phx-feedback-for & update errors for input component.

Update app_web.ex

Now using a single layout we can remove layout option from live_view function in AppWeb from:

use Phoenix.LiveView,
  layout: {AppWeb.Layouts, :app}

to:

use Phoenix.LiveView

And add an alias for Layouts to html_helpers

  defp html_helpers do
    quote do
      # ...

      alias Phoenix.LiveView.JS
      alias AppWeb.Layouts

      # ...
    end
  end

If you don't have any custom code in this module, you can copy from new app template and update module name.

Update config.exs

You need to update config for TailwindCSS follow:

config :esbuild,
  version: "0.17.11",
  hello: [
    args:
      ~w(js/app.js --bundle --target=es2022 --outdir=../priv/static/assets/js --external:/fonts/* --external:/images/*),
    cd: Path.expand("../assets", __DIR__),
    env: %{"NODE_PATH" => Path.expand("../deps", __DIR__)}
  ]

config :tailwind,
  version: "4.0.9",
  hello: [
    args: ~w(
      --input=assets/css/app.css
      --output=priv/static/assets/css/app.css
    ),
    cd: Path.expand("..", __DIR__)
  ]

Note: Taiwind's config & Relative paths are changed! Need make sure you update correct paths for new version.

Update mix.exs

We need update deps to new version:

  defp deps do
    [
      {:phoenix, "~> 1.8.0-rc.3", override: true},
      {:phoenix_html, "~> 4.1"},
      {:phoenix_live_reload, "~> 1.2", only: :dev},
      {:phoenix_live_view, "~> 1.0.9"},
      {:phoenix_live_dashboard, "~> 0.8.3"},
      {:esbuild, "~> 0.9", runtime: Mix.env() == :dev},
      {:tailwind, "~> 0.3", runtime: Mix.env() == :dev},
      {:req, "~> 0.5"},
      {:heroicons,
       github: "tailwindlabs/heroicons",
       tag: "v2.1.1",
       sparse: "optimized",
       app: false,
       compile: false,
       depth: 1},
      # ...
    ]

Add listeners: [Phoenix.CodeReloader] to def project

Update Gettext to new version if needed. Remove finch deps because now Phoenix using req instead if you need to use HTTP client.

Update your templates

Some core components of Phoenix are changed or remove, you need to update your templates.

Verify & Test

Run mix assets.setup & mix assets.build to test our update.

Test simple daisyUI component from daisyUI to make sure daisyUI is included in our app.

Note: Phoenix bring some new features you can try like: scopes, magic link,...

This is my guide based on my migration our projects to Phoenix 1.8 for using daisyUI. I hope it can help you!

Updated: Changed from RC version to official release.

Solve problem for dynamic Elixir cluster - ClusterHelper

Mạnh Vũ — Sun, 23 Mar 2025 07:45:22 +0000

Intro

I'm deploying a cluster of Elixir with 5 to 7 nodes (dev env, in prod each node is a deployment and have 1 or more replicas) on Kubernetes(K8s), our system is using EasyRpc (a :erpc wrapper) in internal Elixir cluster for save time to develop. It's perfect for case static/fixed cluster but hard for case run a Elixir cluster(dynamic cluster) on K8s.

Why it so hard?

K8s is designed for dynamic things like web service (usually, stateless & not join a cluster like Elixir cluster). IP and hostname of Pod is dynamic it's changed every time pod is restarted an node name of Elixir will be changed follow. It's not match with our system. Of course, we can workaround by using headless service or using Gossip strategy of :libcluster then using prefix of app name for check it in runtime but it's more complicated and sound not good for thing work well with distributed system like Elixir.

Of course, we can use other thing like broker or bus message or wrap to gRPC/Rest API but that make more complicated for development & deployment. We want to use rpc of Elixir for fast develop (benefit from dynamic type language).

Our way

We made a library has name ClusterHelper to map role to Elixir node name in runtime. If a node join to cluster it will auto update all roles of that node for other nodes in cluster. The library run in every Elixir node in our cluster, now we can lookup Elixir node name by role. Each role has one or more nodes depended in our scale strategy.

In our system, a node can have one or several roles and a role can have several nodes. Information about roles & nodes are auto synced & cached in every node.

Based on role can bring for us some benefits like scale in/out easily, we don't need to care about node name of Elixir and how to map it on K8s. It's easy to scale a service by add more nodes for that service.

We have another library with name EasyRpc help us work smoothly with number of nodes have same a role.

Elixir Macro - How it save time & keep code clean for us

Mạnh Vũ — Wed, 26 Feb 2025 14:43:32 +0000

Intro

I have worked with macro (meta-programming) in C, Delphi & Erlang language but with Elixir it is different, meta-programming in Elixir is really fun & useful.

You can made a DSL style like Plug and Ecto library in your code if you want it isn't hard.

For us, we call rpc in Elixir cluster so much. In regular way we can call directly to rpc function in :erpc module (Erlang module) but this way is not convenience because: The first we need code a separated function or module to handle rpc call. The second we always need to find target node to call. And more, if we have a ton of nodes that has same function (for HA & scale out) that is painful for dev is not good about distributed computing.

For reduce time & also support scale out, I made a wrapper module for rpc call, then other devs just need to use with some options and use same way with local function. Our wrapper module also support change name of target function just by declare in config file.

This is very efficient way for us, add rpc just in seconds. Every complex thing is behind the scene.

I will show how I made this.

How I use macro

In config file of project user need to declare like:

config :my_app, :my_rpc,
   node_list: [...], # or {mod, fun, args}
   module: RemoteModule,
   funtion_list: [
     {:function_1, 1},
     {:funtion_2, :new_name, 0}
   ]

In local module dev need use my module with config option (and other options if needed). When compiling macro will inject to local module with function name in config (target name or new name) then local module or other modules can call rpc look like local function.

local module example:

defmodule ModA
use RpcHelper, otp_app: :my_app, config: :my_rpc
end

# usage
ModA.function_1("hello")

Dev can have several remote modules in same app if needed.

So with macro we can cut down a lot of duplicated code and make it easy for dev who not friendly with distributed system.

I also provided basic technique for select target node for better scalable and HV.

Conclusion

This way help us so much, reduced time for write call rpc code, keep our code clean and easy to maintain!

Updated: We published our first release! You can get code from Github or on Hex.pm.

PhoenixGenApi a general APIs for Channel - Our way to reduce time & cut down cost for developing backend by Elixir

Mạnh Vũ — Sat, 01 Feb 2025 03:54:12 +0000

Intro

To reduce time & cost of development we develop a new way to call api from mobile to backend system for develop real-time application. That is based on Elixir & Phoenix channel, we call it is phoenix general api(phoenix_gen_api). phoenix_gen_api supports for distributed system that help us don't need to care too much about a lot of things.

How it's work

For regular type, has several steps to add a api for mobile or web app. Usually, develop internal functions and add to a interface for other service can call. For this way we need to integrate between service & api gateway, this required effort & time.

For real-time system, develop a system with a lot of services is complexity for traditional/regular type. Chain of apis from public to target service is thing that made us think about new way.

phoenix_gen_api, we develop our system with Elixir/Phoenix then we can use distributed system of Elixir (Erlang cluster) and real-time of Phoenix channel for develop api for frontend. Imagine you can cut down some steps in the chain of api from public to target service or automate it!

Public side, we develop a lib that verify & validate data (from json, go to Phoenix is map type) from public then convert it to Elixir struct for internal use. Request from public need to indicate api that want to call & arguments (all of request is a json object) of its api.

Internal side, we develop a lib that can understand api & its argument from client, after verify data it will call rpc to target node (service) in internal cluster. Lib also support multi nodes with some kind of load balancing for scaling. Chain from api gateway to target service, we can automate this phase by add auto scan (active/passive) & add new api/updated api to api gateway. After api is added gateway can service public without touch from dev then we don't need to care about integrate too much.

Validation & security, With Phoenix channel we verify user for each connection (WebSocket) then we just need to care about permission & validation for api. Actually, api gateway just read declared api function and execute it. Dev who develop api need to declare argument type, size/length or use default config of api. We don't need too much effort to integrate for every new api.

Type of response for phoenix_gen_api, we support regular request/response style (sync), async call (result will send later) & stream for continuing send result to client.

Benefit of phoenix_gen_api

For dev, dev doesn't need to care about how complex of api gateway, how client interact with server just think about data need to receive & send. Data in internal is Elixir struct then can help dev can easy to develop. For some special type of Elixir we add a protocol to convert it between json & struct.

For devops, sound bad for them, no more task like integration & configuration (include scaling). Dev help them go to retired early 😎

For startup, save time & cost for build a new system. We don't need to much engineer for build a big system.

The future of lib

We are still developing more feature for lib. We will add macro for more convenience & reduce time for declare configuration of api. We will support for lib can be and a app that can run independence by wrap Phoenix & add some functions for verify security of connection.

We have published our library on Hex.pm or you can get code on Github repo.

Conclusion

We hope can help dev who that develop system by Elixir can have a way to save time & cost.

Thank you for reading!

// we will comeback and update more details in the future.

SuperCache - An in-house cache we build for our product

Mạnh Vũ — Sun, 26 Jan 2025 07:36:03 +0000

SuperCache Intro

For build a realtime & low latency application by using Phoenix & Elixir we make a library for cache data in memory. In time we started to build our product we didn't find a good cache library then we desired to build a new cache library with name SuperCache by Elixir.

SuperCache is simple library based on Ets table (from Erlang), each table for each partition for improving performance in case a lot of processes access to.

Almost functions are same style with Ets function for people can easy to use (if people have worked with Ets before).

Why we build cache that based on Ets? It's because in the early of our product, we using tuple a lot then it is perfect for us build a cache with Ets style, we can query with key/value style or by pattern matching. And another reason is Ets has a long time and it is stable & fast enough for us.

With SuperCache we are easy to share data between processes or between applications (we will add support cluster in the future). This important thing help us so much for reduce time to develop & reduce complexity of our system.

Belong with Ets style we add support for Key/Value, Stack, Queue struct with multi instances of each for convenience when working with shared global data.

Features

Cache with Ets style and have partitions that can configuration in runtime. Cache is a global data in node then any process from any application run on node can access. You can choose a Ets table type if need.

Key/Value memory database for simple tasks, supported multi instance of key/value with easy to use and can access from any process in node. Key/Value spreads all it data in all partitions by key (calculated by hash order of Erlang).

Queue (FIFO), supported multi global queues with much more simple to use. Remember one thing, that is a queue store all it data in a partition then you can access it by match/match_object if need!.

Stack (FILO), same with Queue.

Note: For Key/Value, Queue, Stack when get data it can have default value (nil if you don't put to argument) for case no data in it.

Guide

It's very easy to use.

First, add to deps:

def deps do
  [
    {:super_cache, "~> 0.6.0"}
  ]
end

Second, start the cache:

SuperCache.start!()

Default, number of partitions is a number of online_schedulers of Erlang VM.

You can run with options like:

opts = [key_pos: 0, partition_pos: 1, table_type: :bag, num_partition: 3]
SuperCache.start!(opts)

Now, you can use the APIs of lib.


SuperCache.put!({:hello, :world, "hello world!"})

SuperCache.get_by_key_partition!(:hello, :world)

SuperCache.delete_by_key_partition!(:hello, :world)

KV example (after started cache lib):

alias SuperCache.KeyValue, as: KV
KV.add("my_kv", :key_a, "Hello")
data = KV.get("my_kv", :key_a)
IO.puts "#{inspect data}"

Queue example (after started cache lib):

alias SuperCache.Queue, as: Q
Q.add("my_queue", "new_task")
task = Q.out("my_queue")
IO.puts "new task: #{inspect task}"

Stack example (after started cache lib):

alias SuperCache.Stack, as: S
S.push("my_stack", :hello)
data = S.pop("my_stack", :no_data)
IO.puts "data: #{inspect data}"

Library is still developing and battle test before go to product but you can try!

Source is available on Github