Visual Basic.CodeCompared.To/Elixir

No module, no entry point, no imports. An Elixir script runs its expressions top to bottom. Console.WriteLine becomes IO.puts, where IO is a module and puts a function in it — that Module.function shape is how everything in Elixir is called, because there are no objects with methods.

$"...{name}..." becomes "...#{name}...", with no prefix on the string, and any expression may go inside. There are no format specifiers: rounding is a function call. The one to learn early is IO.inspect, which prints the structure of any value and returns it unchanged — so it can be dropped into the middle of a pipeline to see what is flowing through without altering the result.

Module becomes defmodule and Function becomes def, both closed by end — no braces anywhere. Visibility is in the keyword rather than a modifier: def is public and defp is private. There is no Return: a function returns its last expression. Module names are CamelCase and everything else is snake_case, which is a convention the compiler will warn you about.

An atom is written :name and its value is its own name. It is what a Visual Basic Enum member is reaching for, without declaring the enum first, and it is used everywhere: :ok and :error as result tags, :active as a state, and map keys via the %{status: :active} shorthand. true, false and nil are themselves atoms. Module names are atoms too, which is why they can be passed around as values.

' becomes #, and there is no block comment. '''<summary> becomes @doc, which is not a comment: it is a module attribute stored in the compiled artifact, readable by h Maths.twice in the shell and by the documentation generator. @spec declares types — checked by the dialyzer tool rather than by the compiler, which makes it the same kind of promise as a Python type hint.

Every value in Elixir is immutable. add_item cannot change the list it was given — it builds and returns a new one — so no function can surprise its caller by mutating an argument, and no second reference can be changed out from under you. That removes a whole category of bug that Visual Basic makes easy, and it is what allows the processes section later to run things concurrently with no locks at all: there is no shared mutable state to protect.

A name may be rebound to a new value, so total = total + 1 works and reads normally. What cannot happen is the value changing: String.upcase(text) returns a new string and leaves text alone. The difference from Visual Basic shows when something has already captured the old value — a spawned process, an anonymous function — which keeps seeing what it captured rather than what the name now points to.

x |> f(a) means f(x, a) — it feeds the value on the left in as the first argument. That is why every function in Enum and String takes its data first, and why a pipeline reads top to bottom in the order the work happens, exactly like a method chain but built from plain functions. It is the single most characteristic thing in Elixir code, and the reason immutability does not become tedious: each step returns a new value and hands it on.

= is the match operator. {status, message} = {:ok, "loaded"} checks that the right side is a two-element tuple and binds the names to its parts. It is not assignment: 1 = 1 is a legal expression, and 2 = 1 raises a MatchError. This is how tuples, lists and maps are taken apart everywhere in Elixir, and it is why the language needs no Item1/Item2 and no destructuring syntax bolted on — matching is the syntax.

A function may be defined several times with different patterns, and Elixir tries them top to bottom. Case Is < 0 becomes a guard, when count < 0. _count matches anything and the leading underscore says the value is unused. do: on one line is the short form of do ... end. This replaces both overloading (which Elixir has, by arity) and most if ladders, and it is the shape most Elixir code takes.

case matches one value against patterns — Select Case that can destructure. cond takes boolean branches and is the closest thing to an If/ElseIf chain, with true -> as the Else. with is the one worth learning: it chains steps that must each match, and jumps to else the moment one does not — which is exactly the "check, check, check, then do the work" shape the anchor column writes as a run of early returns.

An Elixir list is an immutable singly-linked list. [head | tail] prepends in constant time and shares the rest of the list, which is why Elixir code builds lists front-to-back and reverses at the end. ++ appends by copying the left side, so it is O(n) and wrong inside a loop. There is no Add, no index assignment, and Enum.at walks from the front — a list is not an array, and reaching for a random index is a sign the data wants to be a map or a tuple.

Dictionary(Of K, V) becomes a map, written %{key => value}. When the keys are atoms there is a shorthand, %{host: "localhost"}, and those maps allow dot access — settings.port. TryGetValue splits into Map.get(map, key, default) and Map.fetch(map, key), which returns {:ok, value} or :error. %{map | key => value} updates an existing key and raises if it is not there, which catches typos that Map.put would silently accept.

A tuple is a fixed-size group written in braces, held contiguously, and matched on constantly. The convention {:ok, value} / {:error, reason} is what the whole ecosystem returns from anything that can fail, so there is no output parameter and the failure carries a reason. Note the zero-denominator case is a separate function head rather than an if — that is idiomatic, and it is why a guard clause rarely appears in the body.

Where→Enum.filter, Select→Enum.map, Any→Enum.any?, All→Enum.all?, FirstOrDefault→Enum.find, OrderBy→Enum.sort_by, Aggregate→Enum.reduce, GroupBy→Enum.group_by. The trailing ? is part of the name and means the function returns a boolean, by convention throughout. Enum is eager; its lazy twin is Stream, which builds the pipeline and runs it only when something forces it — that is the one closest to LINQ.

Function(value) value * 2 becomes fn value -> value * 2 end, and &(&1 * 3) is the terse capture form where &1 is the first argument. Calling one requires a dot: twice.(21), not twice(21) — the distinction exists because a bare twice(21) would mean a named function in the current module. &String.duplicate/2-style capture is Elixir's AddressOf, and there is no Func/Action type to declare.

Elixir has no loop constructs at all. Iteration is either recursion, with the state carried as arguments and a base-case clause to stop, or — far more often — a function from Enum. Tail calls are optimized, so sum_to runs in constant stack space and a recursive loop over a million items is fine. In practice you will write Enum.sum(1..10) and reach for explicit recursion only when no Enum function fits.

There are no classes and no methods. defstruct declares a map with known keys and a default for each; functions that work on it live in the same module and take it first, which is what makes person |> Person.describe() read like person.Describe(). Note the pattern in the function head — %Person{name: name} destructures the argument on the way in — and that had_birthday returns a new person, because nothing can be modified.

A behaviour is a list of @callback declarations; a module claims it with @behaviour, and the compiler warns about a missing or misspelled callback when @impl true is present. Since module names are atoms, a module can be stored in a variable and called dynamically — module.greet(...) — which is how polymorphism works without objects. This is what GenServer and Supervisor are: behaviours whose callbacks you fill in.

spawn starts a lightweight process: a few hundred bytes, scheduled by the VM, with its own heap and no shared memory at all. Millions can run at once. Because nothing is shared there is nothing to lock — Thread, Mutex and ManualResetEvent have no counterpart and no purpose. Processes communicate with send and receive, and self() is the current process's identifier. The after clause is the timeout, which is always worth writing.

A GenServer is a process that holds state and answers messages, which is what a stateful object is. State changes by returning the new state from a callback rather than by assignment. Because only that one process ever touches the state, no lock is needed and no race is possible — the SyncLock in the anchor column has nothing to translate to. call waits for a reply, cast does not, and the split between the public functions and the callbacks is the standard shape.

The BEAM philosophy is let it crash: rather than defending every call site with a Try, let a process fail and have a supervisor restart it in a known-good state. Process.monitor arranges the {:DOWN, ...} message shown here; a real application uses Supervisor with a restart strategy instead. The ^ before reference is the pin operator, meaning "match against this existing value" rather than rebinding the name — a small piece of syntax with no Visual Basic counterpart.

A function that can fail returns {:ok, value} or {:error, reason}, and the caller matches on it — no output parameter, and the failure carries a reason rather than a bare False. Note that Integer.parse("12x") returns {12, "x"}, the number and the leftover text, so matching {number, ""} is what insists the whole string was consumed. Many functions come in pairs: Map.fetch returns a tuple, Map.fetch! raises.

Try→try, Catch e As T→rescue e in T, Finally→after, Throw→raise. The whole try is an expression, so it can sit on the right of a =. The cultural difference matters more than the syntax: an Elixir codebase uses {:ok, _}/{:error, _} for anything it expects and reserves raise for bugs and unrecoverable states — which is also why a try block is a much rarer sight here than in .NET.

mix.exs is the .vbproj, Hex is nuget.org, mix deps.get is dotnet restore, and mix.lock pins versions. mix test, mix format and mix docs all ship with the language. The one with no equivalent is iex -S mix: an interactive shell attached to your running application, where you can call any function, inspect any process and — on a production node — hot-load new code. That is a debugging capability .NET simply does not have.

Phoenix is the web framework and Ecto the data layer, and both are essentially the only choice — which is a simplification rather than a limitation. What is genuinely different is what needs no library: background jobs are supervised processes, real-time updates are built into the runtime, and connecting several nodes into a cluster is a runtime feature rather than an infrastructure project. LiveView is worth naming for this reader specifically: it renders a server-driven interactive UI with no JavaScript, which is closer to the WinForms mental model than anything in the JavaScript world.

Rebinding a bare name always succeeds, so value = 2 behaves exactly as expected. But = is a match, so the moment the left side is a pattern rather than a plain name it can fail: {:ok, _} = {:error, :nope} raises MatchError. That is often what you want — an assertion that a call succeeded — and it is startling the first time a line that reads like an assignment ends the process.

As in Visual Basic, / always produces a float and integer division has its own name: \ becomes div(a, b) and Mod becomes rem(a, b). No truncation trap. The detail worth noticing is that 4 / 2 is 2.0, not 2 — the result is a float even when it divides evenly, which matters when the value is about to be matched against an integer pattern or used as a list index.

The for in Elixir is a comprehension, not a loop: it collects what each iteration returns and hands back a list. It does not repeat a block for its side effects. So the very common Visual Basic shape — declare an empty list, add to it in a loop — cannot work, because nothing can be added to a list and the outer name is never reassigned. collected is still [] after the second block, with no error. Use the comprehension's result, or Enum.reduce when the accumulation is more complicated.

A double-quoted string is a binary (UTF-8 bytes) and is what you want. A ~c sigil — historically single quotes — produces a charlist, a list of code points, which exists for Erlang interoperability and turns up unexpectedly when calling Erlang libraries. IO.inspect showing ~c"..." where you expected text is the usual symptom. Note also that byte_size and String.length differ for anything non-ASCII: "café" is 5 bytes and 4 characters.

IsNumeric becomes an Integer.parse match, My.Computer.FileSystem becomes File and Path, and node() names the current BEAM node. Now becomes DateTime.utc_now() or Date.utc_today() in ordinary Elixir — the example reaches for the lower-level :erlang.system_time/1 instead, because the calendar functions are among the things the small in-browser VM does not carry. The honest summary: Elixir has no desktop GUI story. A WinForms application does not port. What it is exceptionally good at is long-running server work — web applications, real-time systems, message handling — so the decision to weigh is whether the thing you maintain is that kind of thing, not whether the syntax appeals.