Planet Jabber

by Paweł Długosz at April 03, 2025 10:23 · or

send(pid, "The message")

receive do
 msg -> IO.puts("I've received: #{msg}")
end


# Function to be executed by the new process
def multiply_by_two() do
 receive do
   {reply_to, val} -> send(reply_to, val * 2)
 end
end


# Getting PID of process A
pid_a = self()
# Creating process B
pid_b = spawn(&multiply_by_two/0)


# Sending a message to process B
send(pid_b, {pid_a, 2})
# Receiving a message from process B
receive do
 val -> IO.puts("Result: #{val}")
end

iptables -A OUTPUT -d lethe.matrix.org -j REJECT

ALTER TABLE users ADD COLUMN type smallint NOT NULL DEFAULT 0;
ALTER TABLE users ALTER COLUMN type DROP DEFAULT;
ALTER TABLE users DROP PRIMARY KEY, ADD PRIMARY KEY (username(191), type);

ALTER TABLE users ADD COLUMN type smallint NOT NULL DEFAULT 0;
ALTER TABLE users ALTER COLUMN type DROP DEFAULT;
ALTER TABLE users DROP PRIMARY KEY, ADD PRIMARY KEY (server_host(191), username(191), type);

ALTER TABLE users ADD COLUMN "type" smallint NOT NULL DEFAULT 0;
ALTER TABLE users ALTER COLUMN type DROP DEFAULT;
ALTER TABLE users DROP CONSTRAINT users_pkey, ADD PRIMARY KEY (username, type);

ALTER TABLE users ADD COLUMN "type" smallint NOT NULL DEFAULT 0;
ALTER TABLE users ALTER COLUMN type DROP DEFAULT;
ALTER TABLE users DROP CONSTRAINT users_pkey, ADD PRIMARY KEY (server_host, username, type);

ALTER TABLE users ADD COLUMN type smallint NOT NULL DEFAULT 0;
CREATE TABLE new_users (
    username text NOT NULL,
    type smallint NOT NULL,
    password text NOT NULL,
    serverkey text NOT NULL DEFAULT &apos&apos,
    salt text NOT NULL DEFAULT &apos&apos,
    iterationcount integer NOT NULL DEFAULT 0,
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (username, type)
);
INSERT INTO new_users SELECT * FROM users;
DROP TABLE users;
ALTER TABLE new_users RENAME TO users;

ALTER TABLE users ADD COLUMN type smallint NOT NULL DEFAULT 0;
CREATE TABLE new_users (
    username text NOT NULL,
    server_host text NOT NULL,
    type smallint NOT NULL,
    password text NOT NULL,
    serverkey text NOT NULL DEFAULT &apos&apos,
    salt text NOT NULL DEFAULT &apos&apos,
    iterationcount integer NOT NULL DEFAULT 0,
    created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (server_host, username, type)
);
INSERT INTO new_users SELECT * FROM users;
DROP TABLE users;
ALTER TABLE new_users RENAME TO users;

acl:
  admin:
    user: jan@localhost

api_permissions:
  "adhoc commands":
    from: mod_adhoc_api
    who: admin
    what:
      - "[tag:roster]"
      - "[tag:session]"
      - stats
      - status

modules:
  mod_adhoc_api:
    default_version: 2

ext_api_url: "http://example.org/@VERSION@/api"

define_keyword:
  SCRIPT: "captcha.sh"

captcha_cmd: "tools/@SCRIPT@"

define_macro:
  SCRIPT: "captcha.sh"

captcha_cmd: "tools/@SCRIPT@"

listen:
  -
    port: "unix:sockets/ctl_over_http.sock"
    module: ejabberd_http
    unix_socket:
      mode: &apos0600&apos
    request_handlers:
      /ctl: ejabberd_ctl

CTL_OVER_HTTP=sockets/ctl_over_http.sock

$ time for (( i=100 ; i ; i=i-1 )) ; do ejabberdctl register user-standard-$i localhost pass; done
...
real    0m43,929s
user    0m41,878s
sys     0m10,558s

$ time for (( i=100 ; i  ; i=i-1 )) ; do CTL_OVER_HTTP=sockets/ctl_over_http.sock ejabberdctl register user-http-$i localhost pass; done
...
real    0m2,144s
user    0m1,377s
sys     0m0,566s

     env:
     - name: PORT_HTTP_TLS
       value: 5444

     env:
     - name: EJABBERD_MACRO_ADMIN
       value: administrator@example.org
     - name: REGISTER_ADMIN_PASSWORD
       value: somePass0rd

     env:
     - name: CTL_ON_CREATE
       value: register administrator example.org somePass0rd

affiliations:owner:user1@localhost,member:user2@localhost
affiliations:owner=user1@localhost;member=user2@localhost

ejabberdctl \
  create_room_with_opts \
  room_old_separators \
  conference.localhost \
  localhost \
  "persistent:true,affiliations:owner:user1@localhost,member:user2@localhost"

ejabberdctl \
  create_room_with_opts \
  room_new_separators \
  conference.localhost \
  localhost \
  "persistent:true,affiliations:owner=user1@localhost;member=user2@localhost"

curl -k -X POST -H "Content-type: application/json" \
     "http://localhost:5280/api/create_room_with_opts" \
     -d &apos{"name": "room_old_separators",
          "service": "conference.localhost",
          "host": "localhost",
          "options": [
           {"name": "persistent",
            "value": "true"},
           {"name": "affiliations",
            "value": "owner:user1@localhost,member:user2@localhost"}
          ]
         }&apos

curl -k -X POST -H "Content-type: application/json" \
     "http://localhost:5280/api/create_room_with_opts" \
     -d &apos{"name": "room_new_separators",
          "service": "conference.localhost",
          "host": "localhost",
          "options": [
           {"name": "persistent",
            "value": "true"},
           {"name": "affiliations",
            "value": "owner=user1@localhost;member=user2@localhost"}
          ]
         }&apos

moderate
Ctrl-↑
uv
pipx
uv
class Greeter
  def initialize(name)
    @name = name
  end

  def greet
    "Hello, #{@name}!"
  end
end

greeter = Greeter.new("Ruby")
puts greeter.greet  # => "Hello, Ruby!"

defmodule Greeter do

  def greet(name), do: "Hello, #{name}!"

end
IO.puts Greeter.greet("Elixir")  # => "Hello, Elixir!"

class UserSyncJob
  include Sidekiq::Worker

  # This job fetches user data from an external API
  # and updates the local database.
  def perform(user_id)
    begin
      # 1. Fetch data from external service
      external_data = ExternalApi.get_user_data(user_id)

      # 2. Update local DB (pseudo-code)
      user = User.find(user_id)
      user.update(
        name: external_data[:name],
        email: external_data[:email]
      )

      puts "Successfully synced user #{user_id}"
    rescue => e
      # If something goes wrong, Sidekiq can retry
      # automatically, or we can log the error.
      puts "Error syncing user #{user_id}: #{e.message}"
    end
  end
end

# Trigger the job asynchronously:
UserSyncJob.perform_async(42)


defmodule MyApp.Workers.UserSyncJob do
  use Oban.Worker, queue: :default

  @impl Oban.Worker
  def perform(%{args: %{"user_id" => user_id}}) do
    with {:ok, external_data} <- ExternalApi.get_user_data(user_id),
         %User{} = user <- MyApp.Repo.get(User, user_id) do
      user
      |> User.changeset(%{
        name: external_data.name,
        email: external_data.email
      })
      |> MyApp.Repo.update!()

      IO.puts("Successfully synced user #{user_id}")
    else
      error -> IO.puts("Error syncing user #{user_id}: #{inspect(error)}")
    end

    :ok
  end
end

# Enqueue the job asynchronously:
MyApp.Workers.UserSyncJob.new(%{"user_id" => 42})
|> Oban.insert()


defmodule Worker do
  use GenServer

  def start_link(_) do
	GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
  end

  def init(_), do: {:ok, %{}}

  def handle_call(:risky, _from, state) do
    raise "Something went wrong"
    {:reply, :ok, state}
  end
end

defmodule SupervisorTree do
  use Supervisor

  def start_link(_) do
    Supervisor.start_link(__MODULE__, :ok, name: __MODULE__)
  end

  def init(:ok) do
    children = [
      {Worker, []}
    ]
    Supervisor.init(children, strategy: :one_for_one)
  end
end


defmodule ChatLive do
  use Phoenix.LiveView

  def mount(_params, _session, socket) do
    {:ok, assign(socket, :messages, [])}
  end

  def handle_event("send", %{"message" => msg}, socket) do
    {:noreply, update(socket, :messages, fn msgs -> msgs ++ [msg] end)}
  end

  def render(assigns) do
    ~H"""
    <h1>Chat</h1>
    <ul>
      <%= for msg <- @messages do %>
        <li><%= msg %></li>
      <% end %>
    </ul>

    <form phx-submit="send">
      <input type="text" name="message" placeholder="Type something"/>
      <button type="submit">Send</button>
    </form>
    """
  end
end


fd66aef38d48b6474654cbe87464d7d416d6a5f3
xmpp['feature_mechanisms'].unencrypted_scram = True
timeout_callback
IqTimeout
google
gmail_notify
XMLStream
ClientXMPP
use_ssl
enable_direct_tls
enable_starttls
enable_plaintext
connect()
host
port
connect()
connect()
xmpps-client
xmpp-client
tls_services
starttls_services
ClientXMPP
InvalidJID
False
ssl_cert
BaseXMPP.get
def add(a, b), do: a + b  

IO.puts add(2, 3)      # Works fine
IO.puts add(2, "three") # Causes a runtime error

add :: Int -> Int -> Int
add a b = a + b

main = print (add 2 3)    -- Works fine
main = print (add 2 "three")  -- Compile-time error


join_muc_wait
__contains__
x in y
You should catch Iq… exceptions
STRICT_INTERFACE
stanzabase

	Elixir	Python
Numbers	`4 -2 1_000_000 2.3 1.4e12`	`4 -2 1_000_000 2.3 1.4e12`
Strings	`“Hello”` `“Interpolation: #{var}”`	`‘Hello’f’ Interpolation: {var}’`
Booleans	`true false`	`True False`
Lists	`[1, 2, 3]`	`[1, 2, 3]`
Tuples	`{“banana”, 4}`	`(‘banana’, 4)`
Maps	`%{“key” => “value”}`	`{‘key’: ‘value’}`

	Elixir	Python
Arithmetic	`1 + 2 3.4 - 5.6 7 * 8 9.01 / 2.3 div(8, 3) rem(8, 3)`	`1 + 2 3.4 - 5.6 7 * 8 9.01 / 2.3 8 // 3 8 % 3`
Logical	`true and false false or true not true`	`True and False False or True not True`
Comparison	`9 > 5 1.2 < 2 6 >= 6 1 <= 6.5 “Hello” == “Hello” “Hello” != “World” 1 == 1.0 1 === 1 1 !== 1.0`	`9 > 5 1.2 < 2 6 >= 6 1 <= 6.5 ‘Hello’ == ‘Hello’ ‘Hello’ != ‘World’ 1 == 1.0`
String concatenation	`“Hello “ <> “World!”`	`‘Hello ‘ + ‘World!’`
List concatenation	`[1, 2, 3] ++ [4, 5, 6]`	`[1, 2, 3] + [4, 5, 6]`
Variable assignment	`var = 42`	`var = 42`

if/else	`if condition do “It is true” else “It is false” end`	`if condition: ‘It is true’ else: ‘It is false’`
case/match	`case status do 200 -> “It is ok” 400 -> “Bad request” _ -> “Unknown status” end`	`match status: case 200: ‘It is ok’ case 400: ‘Bad request’ case _: ‘Unknown status’`
cond/elif	`cond do 2 + 2 == 5 -> “False” 2 * 2 == 5 -> “Also false” 1 + 1 == 2 -> “This is true” end`	`if 2 + 2 == 5: ‘False’ elif 2 * 2 == 5: ‘Also false’ elif 1 + 1 == 2: ‘This is true’`
comprehensions	`for i <- 0..9, do: i * 2`	`[i * 2 for i in range(10)]`

	Elixir	Python
defining functions	`def add(a, b) do a + b end`	`def add(a, b): return a + b`
calling functions	`add(1, 2)` or `1 \|> add(2)`	`add(1, 2)`
anonymous functions	`add_fn = fn a, b -> a + b end add_fn.(1, 2)`	`add_fn = lambda a, b: a + b add_fn(1, 2)`

Company name	Key benefits
Bleacher Report	There is a significant reduction in code complexity, a considerable decrease in development time, and significant cost savings. Additionally, time and resources are freed up to address technical debt, and there is excellent availability of coding expertise after converting the Ruby team into Elixir experts.
TV4	Migrated millions of subscribers from an external service to a user management application with zero downtime.Reduced server consumption and decreased infrastructure costs.
BET Software	Code complexity is significantly reduced, development time decreases, and costs are lower. Time and resources are freed to address technical debt, with strong coding expertise after converting the Ruby team to Elixir.
International Registries, Inc. (IRI)	Run highly parallel processes and eliminate system bottlenecks. A distributed data architecture ensuring system availability even during data center failures. An innovative event ingress system capable of processing up to 300,000 market changes on peak days, enabling real-time event processing and live betting.

Platform	Description	Features
Learn Elixir	A dedicated platform for Elixir enthusiasts, offering structured courses to guide learners from basics to advanced topics.	Self-paced learning modules.Interactive coding challenges.Community support and forums.
Exercism	A free platform offering coding exercises across various programming languages, including Elixir. It provides practice problems and mentorship to help learners improve their coding skills.	Interactive exercises with real-world scenarios.Mentorship from experienced developers.Community discussions for collaborative learning.
Educative.io	An interactive learning platform that offers a course on functional programming using Elixir.	In-browser coding environment.Hands-on exercises and quizzes.Text-based lessons with visual aids.

Learning type	Description
Meetups are a great way to get inspired by developers in your area. You can check meetup.com if there is a local group of enthusiasts meeting together.	Conferences like ElixirConf, ElixirConf EU, Code Beam Europe, Code Beam America organise workshops with various difficulty levels.
Conference talks	Meetups are a great way to get inspired by developers in your area. You can check meetup.com if there is a local group of enthusiasts meeting together.
Local meetups	Meetups are a great way to get inspired by developers in your area. You can check out on meetup.com if there is a local group of enthusiasts meeting together.

Benefit	Description	Impact
Improved Patient Care	Identifies patterns to predict and prevent diseases, enabling personalised care.	Could save the healthcare industry £230 billion to £350 billion annually through improved care and efficiency.
Cost Reduction	Optimises resource allocation, reduces waste, and improves efficiency.	Predictive analytics can cut hospital readmissions by up to 20%, leading to significant savings.
Enhanced Clinical Outcomes	Integrates data to identify the most effective treatments for patients.	Improves clinical decision-making with real-time insights and evidence-based recommendations.
Accelerated Medical Research	Offers large datasets for faster analysis, cutting clinical trial time and costs.	Reduces clinical trial times by 30% and associated costs by 50%.
Predictive Analytics	Forecasts patient needs, improving outcomes and reducing readmissions.	Helps optimise resources and reduce readmission rates, improving care and reducing costs.
Precision Medicine	Tailors treatments based on individual characteristics like genetics.	Big Data enables more targeted and effective treatment plans.
Population Health Management	Identifies at-risk populations for targeted interventions.	Reduces the prevalence of chronic diseases through early detection and personalised care.
Operational Efficiency	Improves processes like inventory management and reduces waste.	Enhances resource management, reduces costs, and improves service delivery.

Challenge	Details
Outdated Systems	Older systems may have security gaps that hackers can exploit.
Weak Passwords	Simple or reused passwords make it easier for unauthorised people to access sensitive data.
Internal Threats	Employees or contractors could accidentally or intentionally compromise data security.
Mobile and Cloud Security	As healthcare uses more mobile devices and cloud storage, keeping data safe across different platforms becomes harder.

Planet Jabber

April 03, 2025

The basics of Elixir language

Syntax and conventions

Functional programming principles

Elixir’s ecosystem and tools

Elixir language tutorial for beginners

Installation guides across platforms

Step-by-step development process

Advanced Elixir programming tutorial

Processes and message passing

Fault tolerance and scalability

Case studies: Successful Elixir projects

Enhancing team skills with Elixir tutorials

Future-proofing your company with Elixir

To conclude

March 29, 2025

Changelog

Download

March 28, 2025

Changelog

Download

Matrix Gateway with Room Support

Support Multiple Simultaneous Password Types

Update SQL Schema

New mod_adhoc_api module

Macros and Keyword improvements

ejabberdctl: New option CTL_OVER_HTTP

mod_configure: New option access

Container images: Reduce friction, use macros, WebAdmin port

ejabberd container image: admin account

Unix Domain Socket: Relative path

Privileged Entity Bugfixes

mod_muc_occupantid: Enable in the default configuration

mod_http_api returns sorted list elements

create_room_with_opts API command separators

New API commands to change Mnesia table storage

Erlang/OTP and Elixir versions support

Acknowledgments

Improvements in ejabberd Business Edition

ChangeLog

Commands API

Configuration

Container

Core and Modules

Dependencies

Development and Testing

Documentation

Installers

Matrix Gateway

Unix Domain Socket

Full Changelog

ejabberd 25.03 download & feedback

Why This Matters

Take Action to #FederateTheWorld

Features

Fixes

Removals

Links

March 27, 2025

Why I Looked Beyond Ruby

The Mindset Shift: From Objects to Functions

Life Before: Classes and Objects

A New Paradigm in Elixir

Example: Refactoring a Class into a Module

Concurrency: Learning to Trust Processes

Ruby’s approach

Elixir and the BEAM

Example: Background Jobs

Debugging and Fault Tolerance: A New Perspective

Catching Exceptions in Ruby

Supervision Trees in Elixir

LiveView: A Game-Changer for Web Development

Why I Loved Rails

Phoenix + LiveView

My Takeaways

Embracing Immutability

Let It Crash

Less JavaScript, More Productivity

Still Love Ruby