Erlang OTP: Distributed & Fault-Tolerant Systems Programming · Ders

Erlang Süreçleri ve İleti İletişimi

Erlang Süreçleri ve İleti İletişimi, CoddyKit'te ücretsiz bir Erlang OTP: Distributed & Fault-Tolerant Systems Programming dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Erlang OTP: Distributed & Fault-Tolerant Systems Programming öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Erlang OTP: Distributed & Fault-Tolerant Systems Programming kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

Erlang's Core: The Process

The fundamental unit of Erlang concurrency is the process: a tiny, independent program running alongside others, far lighter than an OS thread.

Why Erlang Processes?

Erlang processes are lightweight (millions per machine), isolated (no shared memory), concurrent, and talk only via async messages.

Spawning a New Process

You create a process with spawn, passing a module, function, and args. It returns a unique PID identifying the new process.

-module(process_spawn).
-export([start/0, hello_world_process/0]).

hello_world_process() ->
    io:format("Hello from a new Erlang process!~n").

start() ->
    % Spawns a new process running hello_world_process/0
    Pid = spawn(process_spawn, hello_world_process, []),
    io:format("Spawned process with PID: ~p~n", [Pid]).

Understanding Process IDs (PIDs)

Every process gets a unique PID — its postal address. You need that PID to send it any message; it looks like <0.80.0>.

Sending Messages with '!'

Processes talk by messages, never shared memory. Send one with the ! operator: Pid ! Message, where the message is any Erlang term.

-module(message_sender).
-export([start/0, receiver_process/0, sender_process/1]).

receiver_process() ->
    io:format("Receiver process ~p started.~n", [self()]),
    % This process will just print its PID for now.
    % It doesn't receive messages in this version.
    timer:sleep(1000). % Keep process alive for a moment

sender_process(ReceiverPid) ->
    io:format("Sender process ~p sending message to ~p...~n", [self(), ReceiverPid]),
    ReceiverPid ! {hello, "from sender"},
    io:format("Message sent!~n").

start() ->
    ReceiverPid = spawn(message_sender, receiver_process, []),
    io:format("Receiver spawned with PID: ~p~n", [ReceiverPid]),
    sender_process(ReceiverPid).

Receiving Messages: 'receive'

A process pulls messages from its mailbox with receive, which pattern-matches each one and waits (or times out) until a match arrives.

-module(message_receiver).
-export([start/0, my_receiver/0, my_sender/1]).

my_receiver() ->
    io:format("Receiver ~p waiting for messages...~n", [self()]),
    receive
        {hello, Msg} ->
            io:format("Receiver ~p received: ~p~n", [self(), Msg]);
        _AnyOtherMessage ->
            io:format("Receiver ~p received an unexpected message: ~p~n", [self(), _AnyOtherMessage])
    end,
    io:format("Receiver ~p finished.~n", [self()]).

my_sender(ReceiverPid) ->
    io:format("Sender ~p sending message to ~p.~n", [self(), ReceiverPid]),
    ReceiverPid ! {hello, "World"},
    io:format("Sender ~p sent message.~n", [self()]).

start() ->
    ReceiverPid = spawn(message_receiver, my_receiver, []),
    timer:sleep(100), % Give receiver time to start
    my_sender(ReceiverPid).

A Full Messaging Example

Here is the full flow in one example: spawn a server, the client sends a request, and the server receives and replies.

-module(full_message_example).
-export([start/0, server_loop/0, client_action/1]).

server_loop() ->
    io:format("Server ~p started, waiting for requests...~n", [self()]),
    receive
        {request, ClientPid, Message} ->
            io:format("Server ~p received request from ~p: ~p~n", [self(), ClientPid, Message]),
            ClientPid ! {response, self(), "Got your message!"};
        _Other ->
            io:format("Server ~p received unexpected: ~p~n", [self(), _Other])
    end.

client_action(ServerPid) ->
    io:format("Client ~p sending request to server ~p...~n", [self(), ServerPid]),
    ServerPid ! {request, self(), "Can you hear me?"},
    receive
        {response, ServerPid, Reply} ->
            io:format("Client ~p received reply from ~p: ~p~n", [self(), ServerPid, Reply])
    end.

start() ->
    ServerPid = spawn(full_message_example, server_loop, []),
    timer:sleep(100), % Give server time to start
    client_action(ServerPid).

Asynchronous Communication

Erlang messaging is asynchronous: the sender drops the message in the mailbox and keeps going, never blocking on the receiver.

The Process Mailbox

Each process has a private mailbox where incoming messages queue. A receive scans it for a pattern match, usually in arrival order.

Knowing Your Own PID: `self()`

The built-in self() returns the current process's PID — handy for messaging yourself or embedding a reply address in a message.

-module(self_example).
-export([start/0, print_self/0]).

print_self() ->
    io:format("Hello, my PID is: ~p~n", [self()]).

start() ->
    io:format("Parent process PID: ~p~n", [self()]),
    spawn(self_example, print_self, []).

Quick Check: Message Flow

Consider the following sequence of events in Erlang:

Process A spawns Process B.
Process A sends a message to Process B.
Process B receives the message.

Which of the following statements about this interaction are true?

Recap: Processes & Messaging

Recap: processes communicate by async messages — spawn returns a PID, ! sends, receive matches, each has a mailbox, and self() gives your own PID.

Sıkça Sorulan Sorular

“Erlang Süreçleri ve İleti İletişimi” dersi ücretsiz mi?

Evet — “Erlang Süreçleri ve İleti İletişimi” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Erlang OTP: Distributed & Fault-Tolerant Systems Programming kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Erlang OTP: Distributed & Fault-Tolerant Systems Programming kursu toplamda 4 dersten oluşur.

“Erlang Süreçleri ve İleti İletişimi” dersinde ne öğreneceğim?

Erlang'ın temel eşzamanlılık ilkeli olan süreci anlayın. Süreçlerin eşzamansız ileti aktarımıyla nasıl haberleştiğini öğrenin ve yalıtılmış, hafif eşzamanlı birimler oluşturun. Erlang OTP: Distributed & Fault-Tolerant Systems Programming ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Erlang OTP: Distributed & Fault-Tolerant Systems Programming öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Erlang OTP: Distributed & Fault-Tolerant Systems Programming, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Erlang Süreçleri ve İleti İletişimi” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Erlang OTP: Distributed & Fault-Tolerant Systems Programming dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Erlang OTP: Distributed & Fault-Tolerant Systems Programming dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Erlang OTP: Distributed & Fault-Tolerant Systems Programming Sayfasına Dön