Planet Jabber

by Erlang Solutions Team at May 13, 2025 10:35 · Focus on what matters, build with intent, and treat your MVP not as a throwaway prototype, but as the foundation of everything to come.

Enum.reduce(numbers, [], fn i, result -> [i * 10 | result] end)
|> Enum.reverse()


Enum.map(numbers, & &1 * 10)

Enum.reduce(numbers, 0, fn number, result -> (number * 2) + result end)


Enum.sum_by(numbers, & &1 * 2)


Enum.reduce(numbers, [], fn item, acc ->
  if rem(item, 2) == 0 do
    [item * 2 | acc]
  else
    acc
  end
end)
|> Enum.reverse()


numbers
|> Enum.filter(& rem(&1, 2) == 0)
|> Enum.map(& &1 * 2)

Enum.flat_map(numbers, fn number ->
  if rem(number, 2) == 0 do
    [number * 2]
  else
    []
  end
end)


Enum.reduce(invoices, {[], []}, fn invoice, result ->
  Enum.reduce(invoice.items, result, fn item, {no_tax, with_tax} ->
    if Invoices.Items.taxable?(item) do
      tax = tax_for_value(item.amount, item.product_type)
      item = Map.put(item, :tax, tax)

      if Decimal.equal?(tax, 0) do
        {no_tax ++ [item], with_tax}
      else
        {no_tax, with_tax ++ [item]}
      end
    else
      {no_tax, with_tax}
    end
  end)
end)


invoices
|> Enum.flat_map(& &1.items)
|> Enum.filter(&Invoices.Items.taxable?/1)
|> Enum.map(& Map.put(&1, :tax, tax_for_value(&1.amount, &1.product_type)))
|> Enum.split_with(& Decimal.equal?(&1.tax, 0))


{:credo_unnecessary_reduce, "~> 0.1.0"}

{CredounnecessaryReduce.Check, []}

listen:
  -
    port: 8448
    module: ejabberd_http
    tls: true
    request_handlers:
      "/_matrix": mod_matrix_gw

modules:
  mod_matrix_gw:
    key_name: "xxxxxx"
    key: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
    matrix_id_as_jid: true

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

	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.

Planet Jabber

May 13, 2025

What an MVP should be

Small by design, smart by strategy

A good MVP doesn’t just mean “basic”

Minimise risk, maximise learning

Common MVP mistakes (and how to avoid them)

Overbuilding Before Validation

Why it happens:

How to avoid it:

Choosing the wrong tech stack

Why it matters:

How to avoid it:

Ignoring security and code quality

Why does it happen?

Risks include:

How to avoid it:

What smart MVP development looks like

Built fast, not rushed

Focus on:

Easy to change, because feedback is coming

Make this easier with:

Safe and secure – even if it’s lean

Trust depends on:

A strong MVP is:

Build fast. Build smart. Build for growth.

May 05, 2025

XSF Announcements

XSF Membership

XSF Fiscal Hosting Projects

XMPP Events

XMPP Articles

XMPP Software News

XMPP Clients and Applications

XMPP Servers

XMPP Libraries & Tools

Extensions and specifications

Proposed

New

Deferred

Updated

Last Call

Stable

Deprecated

Rejected

Spread the news

Subscribe to the monthly XMPP newsletter

Newsletter Contributors & Translations

Help us to build the newsletter

Unsubscribe from the XMPP Newsletter

License

May 01, 2025

Keynotes

Industry Stories

Libraries and Frameworks

Deep Dives

And More!

April 24, 2025

Readability

Performance

Good Opportunities for Enum.reduce

Find Cases in Your Own Code with credo_unnecessary_reduce

April 17, 2025

Understanding Big Data in Healthcare

Understanding Digital Wallets

Women in BEAM

Top 5 IoT Business Security Basics

DORA Compliance: What Fintech Businesses Need to Know

To conclude

What’s New

More Changes

Support Gajim

April 16, 2025

mod_muc_occupantid: Fix handling multiple occupant-id

New kick_users API command

Acknowledgments

Improvements in ejabberd Business Edition

ChangeLog

Security fixes

Commands API

Good Opportunities for `Enum.reduce`

Find Cases in Your Own Code with `credo_unnecessary_reduce`