2026/11/16

EEP 73 (Zip Generators)

在 List Comprehension 中可同時遍歷多個列表,而不需要先手動把它們先合併到一個 list 裡面。在舊版的 erlang 可透過 lists:zip/2 lists:zipwith/3 或是遞迴函數處理類似的問題。

Names = ["Alice", "Bob", "Charlie"].
Scores = [85, 92, 78].

%% 使用 zipwith 處理
Result = lists:zipwith(fun(Name, Score) -> {Name, Score} end, Names, Scores).
%% 結果為 [{"Alice",85},{"Bob",92},{"Charlie",78}]

% 必須先合併,再處理
Zipped = lists:zip(Names, Scores).
Combined = [{Name, Score} || {Name, Score} <- Zipped].
%% 結果為 [{"Alice", 85}, {"Bob", 92}, {"Charlie", 78}]

用遞迴方法

zip_names_scores([], []) -> [];
zip_names_scores([N|Ns], [S|Ss]) ->
    [{N, S} | zip_names_scores(Ns, Ss)].

% 呼叫時
Combined = zip_names_scores(Names, Scores).

%% [{"Alice",85},{"Bob",92},{"Charlie",78}]

EEP 73 可直接在 List Comprehension 裡面處理

直接在一個推導式中使用 && 來同步 iterate 兩個列表。

Combined = [{Name, Score} || Name <- Names && Score <- Scores].

EEP73 可讓程式碼減少,增加可讀性,並能支援超過 2 個以上的 list


如果兩個 list 長度不一致, Zip Generator 會產生 error

[A * B || A <- [1, 2] && B <- [10, 20, 30]].
** exception error: bad generators: {[],[30]}

可同時處理多個 generator

Names = ["Alice", "Bob"].
Ages = [25, 30].
Roles = ["Dev", "Ops"].

Result = [Name ++ " is " ++ integer_to_list(Age) ++ " as " ++ Role 
          || Name <- Names && Age <- Ages && Role <- Roles].
%% 結果: ["Alice is 25 as Dev", "Bob is 30 as Ops"]

用逗號 , 就能搭配使用其他 list comprehension 的條件

[C + D || C <- [1, 10] && D <- [2, 20], C + D > 10].
%% 結果  [30]

2026/11/09

erlang:hibernate/3

在 erlang OTP 的每一個 process 都有自己的 heap 與 stack,當有上萬個 process 時,如果 process 處於空閒等待狀態,會佔用很多記憶體。erlang:hibernate/3 的用途就是強制釋放 process 佔用的記憶體,進入休眠模式,直到真的收到下一個 message,會再被喚醒呼叫。

呼叫 erlang:hibernate 時,erlang 會進行下列步驟

  1. Garbage Collection,強制對該 process 進行一次 GC

  2. 釋放記憶體

    釋放 process 使用的 heap, stack,恢復到 process 最小化的狀態

  3. 休眠

    進入休眠模式,從 scheduler 的 queue 裡面移除,不在消耗 CPU

  4. 自動喚醒

    當收到新的 message 時,會呼叫指定的模組函數{Module, Function, Args},重新開始執行,並將 message 放入 mailbox 等待處理

最常見的應用是 server loop,當 process 進入 receive 等待時,如果預期會等待很久,就可以呼叫 hibernate 節省資源

-module(my_server).
-export([start/0, loop/0]).

%% 啟動一個簡單的處理循環
start() ->
    spawn(fun() -> loop() end).

loop() ->
    receive
        {process_data, Data} ->
            %% 執行繁重的運算
            Result = heavy_computation(Data),
            io:format("Result: ~p~n", [Result]),
            
            %% 處理完後,不直接進入 loop(),而是進入休眠
            %% 這樣當下一次有訊息進來,會自動呼叫 my_server:loop([])
            erlang:hibernate(?MODULE, loop, []);
            
        stop ->
            ok
    end.

heavy_computation(Data) ->
    %% 模擬繁重工作
    timer:sleep(1000),
    Data * 2.

等待很久的意思,是類似 MQTT 客戶端,在長時間連線下等待新的訊息資料。或是有上萬個 process 在監控硬體狀態,但大部分的時間,狀態都沒有變化

雖然 hibernate 能節省記憶體,但也有對應的缺點

  1. CPU resource

    因為重新喚醒都需要重新設定 CPU 執行環境,且會觸發 GC,如果 process 常常收到訊息,hibernate 反而會讓系統變慢

  2. context

    因需要指定固定的 {Module, Function, Args} ,這表示程式的設計,必須要是 stateless,或是把狀態資料放在 Args 裡面

以下這個例子,就是將 Count 數值,透過 Args 參數傳送到下一次執行的 function 裡面

-module(counter_server).
-export([start/0, init/1]).

start() ->
    spawn(?MODULE, init, [0]). %% 初始狀態為 0

init(Count) ->
    loop(Count).

loop(Count) ->
    receive
        increment ->
            NewCount = Count + 1,
            io:format("Count is now: ~p~n", [NewCount]),
            %% 帶領新狀態進入休眠
            %% 醒來後會自動呼叫 counter_server:loop([NewCount])
            erlang:hibernate(?MODULE, loop, [NewCount]);

        {get_count, From} ->
            From ! {count, Count},
            %% 查詢不改變狀態,同樣可以休眠以節省資源
            erlang:hibernate(?MODULE, loop, [Count]);

        stop ->
            ok
    end.

gen_server 如果要支援 hibernate,只需要在回傳的資料加上 hibernate。

在 handle_call 或 handle_cast 的回傳值中,最後一個元素加上 hibernate ,這就是告訴 gen_server 要把訊息回傳後,並對此 process 處理一次 erlang:hibernate/3。

雖然進入了 hibernate,但 #state{} 裡面的 data ,會自動被保存,下次呼叫 get_value 時,該 process 會自動被喚醒,並能正確取得 state 裡面的 data 資料。

在一般的 gen_server 框架下,不需要手動檢查 Mailbox,因為框架已經幫你處理好了。也就是框架會自動檢查 mailbox,如果還有訊息,就不會進入 hibernate。

-module(settings_cache).
-behaviour(gen_server).

%% API
-export([start_link/0, set_value/2, get_value/1]).

%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2]).

-define(SERVER, ?MODULE).

%% 狀態定義
-record(state, {
          data = #{} :: map()
         }).

%% --- API 介面 ---

start_link() ->
    gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).

%% 非同步更新設定
set_value(Key, Value) ->
    gen_server:cast(?SERVER, {set, Key, Value}).

%% 同步取得設定
get_value(Key) ->
    gen_server:call(?SERVER, {get, Key}).

%% --- Callback 實作 ---

init([]) ->
    %% 初始化時也可以選擇直接進入 hibernate
    {ok, #state{}, hibernate}.

handle_call({get, Key}, _From, State = #state{data = Map}) ->
    Reply = maps:get(Key, Map, undefined),
    %% 回傳結果後進入 hibernate,釋放堆疊與壓縮堆積
    {reply, Reply, State, hibernate};

handle_call(_Request, _From, State) ->
    {reply, ok, State, hibernate}.

handle_cast({set, Key, Value}, State = #state{data = Map}) ->
    NewMap = maps:put(Key, Value, Map),
    %% 更新狀態後進入 hibernate
    {noreply, State#state{data = NewMap}, hibernate};

handle_cast(_Msg, State) ->
    {noreply, State, hibernate}.

handle_info(_Info, State) ->
    %% 收到非預期訊息(例如喚醒訊息)處理完後繼續休眠
    {noreply, State, hibernate}.

也可以加上一個延遲,短暫暫停,讓框架自動檢查這一段時間有沒有新的訊息。這樣才不需要一直頻繁檢查 mailbox size

handle_info(timeout, State) ->
    {noreply, State, hibernate}; %% 只有在一段時間沒封包時才休眠

handle_cast(Msg, State) ->
    %% 正常處理,並設定 5000 毫秒後觸發 timeout
    {noreply, NewState, 5000}.

在 {noreply, NewState, 5000} 後,5000ms 內,如果又收到新的 message,gen_server 會自動取消 timeout

修改gen_server 套用 timeout 機制

-module(settings_cache).
-behaviour(gen_server).

%% API
-export([start_link/0, set_value/2, get_value/1]).

%% gen_server callbacks
-export([init/1, handle_call/3, handle_cast/2, handle_info/2]).

-define(SERVER, ?MODULE).
-define(IDLE_TIMEOUT, 5000). %% 定義閒置 5 秒後休眠

-record(state, {
          data = #{} :: map()
         }).

%% --- API 介面 ---

start_link() ->
    gen_server:start_link({local, ?SERVER}, ?MODULE, [], []).

set_value(Key, Value) ->
    gen_server:cast(?SERVER, {set, Key, Value}).

get_value(Key) ->
    gen_server:call(?SERVER, {get, Key}).

%% --- Callback 實作 ---

init([]) ->
    %% 初始化後等待 5 秒,若無動作則休眠
    {ok, #state{}, ?IDLE_TIMEOUT}.

handle_call({get, Key}, _From, State = #state{data = Map}) ->
    Reply = maps:get(Key, Map, undefined),
    %% 回傳結果並重新計時 5 秒
    %% 如果 5 秒內又有 call/cast,此計時器會被重置
    {reply, Reply, State, ?IDLE_TIMEOUT};

handle_call(_Request, _From, State) ->
    {reply, ok, State, ?IDLE_TIMEOUT}.

handle_cast({set, Key, Value}, State = #state{data = Map}) ->
    NewMap = maps:put(Key, Value, Map),
    %% 更新狀態後重新計時 5 秒
    {noreply, State#state{data = NewMap}, ?IDLE_TIMEOUT}.

%% 關鍵修改:處理逾時訊息
handle_info(timeout, State) ->
    %% 只有在連續 ?IDLE_TIMEOUT 毫秒沒收到訊息時才會執行到這裡
    io:format("進程已閒置 ~p ms,執行 hibernate 壓縮記憶體...~n", [?IDLE_TIMEOUT]),
    {noreply, State, hibernate};

handle_info(_Info, State) ->
    %% 收到其他訊息(如原生訊息)後也重新計時
    {noreply, State, ?IDLE_TIMEOUT}.

測試

erlc settings_cache.erl

過程中發現,如果間隔超過 5s 沒有呼叫 settings_cache function,就會呼叫 timeout

> erl
1> l(settings_cache).
{module,settings_cache}
2> settings_cache:start_link().
{ok,<0.87.0>}
進程已閒置 5000 ms,執行 hibernate 壓縮記憶體...
3> settings_cache:set_value(<<"key1">>, <<"value1">>).
ok
進程已閒置 5000 ms,執行 hibernate 壓縮記憶體...
4> settings_cache:get_value(<<"key1">>).
<<"value1">>
進程已閒置 5000 ms,執行 hibernate 壓縮記憶體...
5> settings_cache:set_value(<<"key2">>, <<"value2">>).
ok
6> settings_cache:set_value(<<"key1">>, <<"value1">>).
ok
7> settings_cache:get_value(<<"key1">>).
<<"value1">>
8> settings_cache:get_value(<<"key2">>).
<<"value2">>
進程已閒置 5000 ms,執行 hibernate 壓縮記憶體...
9> settings_cache:get_value(<<"key2">>).
<<"value2">>
進程已閒置 5000 ms,執行 hibernate 壓縮記憶體...

2026/11/02

12-Factor App

12-Factor App 是 Cloud Based 軟體開發的方法。它最初由 Heroku 的共同創辦人 Adam Wiggins 於 2011 年提出,總結當時在該平台上開發與部署應用程式後所獲得的寶貴經驗。2010 年代,系統正在從傳統伺服器,轉向 PaaS 與 SaaS。Heroku 的工程團隊整理出這套規範,讓開發者能建構出更具 Scalability 及 Portability 易於維護的應用程式。

方法的目標:

  • 標準化

    以宣告方式 declarative,建立自動配置,減輕新的開發人員初次參與專案的時間與成本

  • 可移植性

    有clean contract 明確的定義,確認作業系統,並能提供在不同執行環境運作的最大彈性

  • 可部署在 cloud platforms

    適合部署在先進的雲端系統,減少伺服器與系統的管理問題

  • 持續部署

    減少開發與正式環境的差異,能夠持續部署,以達成 agility 最大化

  • scale up

    不需要改變工具、架構、開發環境,就能快速因應大流量

1. Codebase

One codebase tracked in revision control, many deploys

一份在 vevision control 管理的程式碼,可部署在多個執行環境

2. Dependencies

Explicitly declare and isolate dependencies

明確地宣告及隔離相依性

3. Config

Store config in the environment

在執行環境中儲存設定配置,不要寫在程式裡面

4. Backing services

Treat backing services as attached resources

把DB,Cache, MQ,SMTP 等等外部資源,透過 URI 的方式存取

5. Build, release, run

Strictly separate build and run stages

嚴格分離 Build, Release, Run 階段

  • build 是編譯成服務元件

  • release 是將元件發佈到 registry,提供給外部執行環境下載

  • run 是在執行環境取得元件,搭配部署設定執行該元件

6. Processes

Execute the app as one or more stateless processes

以一到多個無狀態程序執行app

7. Port binding

Export services via port binding

透過 service port binding 對外提供服務

8. Concurrency

Scale out via the process model

透過 process model 水平擴充

  • 每一個 service app 都是獨立的 process,可啟動多個 thread 分散 process 性能壓力

  • 同一個 service app 也可以啟動多個 instances

9. Disposability

Maximize robustness with fast startup and graceful shutdown

快速啟動/優雅終止 app,最大化系統穩定度

10. Dev/prod parity

Keep development, staging, and production as similar as possible

盡可能保持dev、pre-release、prod環境相同

11. Logs

Treat logs as event streams

將 logs 視為事件串流

  • 微服務應該建立統一的服務來管理日誌(ELK、Graylog、Cloudwatch...)

  • 每個運行的微服務都直接透過Stdout和Stderr來輸出日誌。開發時期透過console來查看時間排序下的Event log。正式環境,則是透過 log 管理服務,來收集、聚合、索引、分析這些Log

12. Admin processes

Run admin/management tasks as one-off processes

把維護/管理任務當作一次性process執行

  • 例如 db migration, db snapshot, schema/table更動,定期renew憑證等等

  • 把這些一次性作業寫成腳本或是Shell,當成一般程式來執行,也進到Git做版控

References

The Twelve-Factor App

[12 Factor原則簡介