io:format("Hello, World!~n", [])..webp){kind=logo}
Ask the right questions to secure the right Erlang 23 talent among an increasingly shrinking pool of talent.
Erlang 23 is the latest version of the open-source programming language, Erlang. Developed by Ericsson in 1986 for telecommunication systems, it has evolved to support distributed, fault-tolerant, soft-real-time systems with requirements on high availability. The new release brings several enhancements including improved performance and scalability features. It also introduces a new concept called "dirty schedulers" that helps in handling long-running native code without blocking system operations. This version continues to uphold Erlang's reputation as a robust choice for concurrent programming.
The next 20 minutes of the interview should attempt to focus more specifically on the development questions used, and the level of depth and skill the engineer possesses.
Open Telecom Platform (OTP) is a set of libraries that ships with Erlang. It provides reusable modules to structure applications, handle error recovery, manage distribution, concurrency and others.
Erlang uses a 'let it crash' philosophy for error handling. This means that when a process encounters an error, it crashes and sends a message to a supervising process, which then decides how to handle the error.
Lists are dynamic and can change their size, but access time is linear. Tuples are fixed in size and offer constant time access, but changing them involves copying the whole tuple.
Erlang shines in real-time systems and serves well for hot swapping, where code can be changed without stopping a system. It's also known for its built-in support for concurrency, distribution and fault tolerance.
Erlang's core philosophy is built around the concepts of concurrency, distribution, and fault-tolerance. Its design emphasizes the creation of numerous lightweight processes that communicate via message passing.
Erlang is a functional programming language, and a strong understanding of functional programming principles is key to writing effective Erlang code.
Erlang is often used for building distributed and fault-tolerant systems, so experience in these areas is a strong indicator of a qualified candidate.
Debugging is a critical skill for any developer, and being able to effectively troubleshoot and resolve issues in Erlang code is a must.
Erlang is known for its designs around concurrent programming. Understanding this is crucial for building robust, scalable applications.
OTP is a set of Erlang libraries and design principles providing middle-ware to develop these systems. It includes its own distributed database, applications to interface towards other languages, debugging and release handling tools.
This is important because a developer must have a deep understanding of the language's syntax and semantics to write efficient and error-free code.
The next 20 minutes of the interview should attempt to focus more specifically on the development questions used, and the level of depth and skill the engineer possesses.
Erlang is often used in real-time systems where high availability is required. It's commonly used in telecom routing or chat servers, distributed databases, and massively multiplayer online games.
Hot code swapping is the ability to change code in a running system without stopping or restarting it. Erlang supports hot code swapping natively, which is a significant advantage in systems requiring high availability.
Erlang does not support traditional looping constructs like 'for' or 'while'. Instead, it uses recursion where a function would call itself to achieve looping.
Both spawn and spawn_link create a new process. The difference is that spawn_link also creates a link to the new process. If either process terminates, the other process will also be terminated.
In Erlang, there are bound and unbound variables. Bound variables have been assigned a value, while unbound variables have not. Once a variable is bound to a value, it cannot be changed.
At this point, a skilled Erlang 23 engineer should demonstrate excellent problem-solving abilities, deep understanding of concurrency and fault-tolerance mechanisms in Erlang, and exceptional coding skills. Red flags include lack of knowledge about OTP design principles or inability to troubleshoot common Erlang errors.
io:format("Hello, World!~n", []).io:format("~p~n", [1+2*3]).lists:map(fun(X) -> X*X end, [1,2,3,4,5]).spawn(fun() -> io:format("Hello, World!~n", []) end).-module(my_module).
-export([start/0]).
start() -> io:format("Hello, World!~n", []).-module(my_module).
-export([start/0]).
start() -> io:format("~p~n", [catch throw(my_error)]).The final few interview questions for a Erlang 23 candidate should typically focus on a combination of technical skills, personal goals, growth potential, team dynamics, and company culture.
A supervisor in Erlang's OTP framework is a process which supervises other processes, known as its children. Supervisors are used to build a hierarchical process structure called a supervision tree, which is used to monitor and restart child processes in case of failures.
Erlang facilitates concurrency through the use of lightweight processes. These processes do not share any state with each other and communicate via message passing.
In synchronous message passing, the sender waits for the receiver to process the message. In asynchronous message passing, the sender just sends the message and continues its process.
ETS, or Erlang Term Storage, is a robust in-memory database available in Erlang. It allows you to store large amounts of data in Erlang's memory space and access it very quickly.
In Erlang, processes maintain state by keeping state data in their stack and passing it to themselves in recursive calls.
Back-end App Developer
Front-end Web Developer
Full Stack Developer (Java)
Full Stack Developer (.Net)
Full Stack Developer (MEAN)
Full Stack Developer (MERN)
DevOps Engineer
Database Engineer (AzureSQL)
Database Engineer (Oracle)
Database Engineer (General)
Solution Architect (.NET)
Solution Architect (Java)
Solution Architect (Ruby)
Solution Architect (Python)
AI Engineer (Python)
Sr. AI Engineer (Python)
AI Strategist (Python)
Business Intelligence Engineer
Systems Analyst
Mainframe Developer (COBOL)
Mainframe Developer (General)