io:format("Hello, World!~n", [])..webp){kind=logo}
Ask the right questions to secure the right Erlang 20 talent among an increasingly shrinking pool of talent.
Erlang 20 is a robust computer programming language, developed by Ericsson in the 1980s for telecommunication systems. It is renowned for its concurrency, fault tolerance, and distribution, making it ideal for real-time systems. The language's name was derived from Agner Krarup Erlang, a Danish mathematician and engineer known for his work in the field of telecommunications. Erlang 20, specifically, introduced new features such as a new way of handling literals and improved performance for large maps. This information is sourced from the official Erlang documentation and historical records from Ericsson.
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 follows the 'let it crash' philosophy for error handling. It uses a system of process supervision where processes monitor each other and handle errors when they occur.
Lists are used when the number of elements is not known in advance or can change over time, while tuples are used when the number of elements is known and fixed.
OTP (Open Telecom Platform) is a collection of middleware, libraries and tools in Erlang. It provides a framework for developing robust, fault-tolerant, distributed applications.
You can create a process in Erlang using the spawn function. For example: Pid = spawn(Module, Function, Args).
Erlang has several key features including concurrency, distribution, fault-tolerance, hot code swapping, and a functional programming style.
Regardless of technical skills, a good candidate should be able to collaborate and communicate effectively with others.
Erlang 20 is known for its fault-tolerance capabilities, which are crucial in building reliable systems.
OTP is a set of Erlang libraries that provides useful features for building applications, so understanding it is crucial.
This will show if the candidate can apply their knowledge in real-world scenarios.
Erlang 20 is known for its concurrent programming capabilities; therefore, the candidate should be familiar with this concept.
This is essential as it is the basic foundation for any programming work in Erlang 20.
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.
A supervisor in Erlang/OTP is a process which monitors other processes, known as its children. It can restart them if they terminate abnormally, providing fault-tolerance.
Messages in Erlang are sent using the ! operator and received using the receive construct. For example: Pid ! Message to send a message and receive Message -> ... end to receive a message.
Pattern matching in Erlang is a powerful feature where variables are bound to values and complex data structures are deconstructed. It is used extensively in function definitions, case expressions, and assignments.
Recursion in Erlang can be implemented by having a function call itself. For example, a factorial function can be implemented as: factorial(0) -> 1; factorial(N) -> N * factorial(N-1).
Erlang supports several data types including integers, floats, atoms, tuples, lists, maps, and binaries.
A skilled Erlang 20 engineer should demonstrate a deep understanding of concurrent programming, error handling in distributed systems, and real-time system design. Red flags would include lack of knowledge in message-passing concurrency or inability to solve problems using Erlang's functional programming paradigm.
io:format("Hello, World!~n", []).lists:reverse([1, 2, 3, 4, 5]).lists:map(fun(X) -> X*X end, [1, 2, 3, 4, 5]).spawn(fun() -> io:format("Hello, World!~n", []) end).-module(my_module).
-export([my_function/0]).
my_function() -> io:format("Hello, World!~n", []).lists:foldl(fun(X, Sum) -> X + Sum end, 0, [1, 2, 3, 4, 5]).The final few interview questions for a Erlang 20 candidate should typically focus on a combination of technical skills, personal goals, growth potential, team dynamics, and company culture.
Hot code swapping in Erlang can be implemented using the code module. You can load a new version of a module using code:load_file(Module) and switch to it using code:purge(Module) and code:load(Module).
ETS (Erlang Term Storage) and DETS (Disk Erlang Term Storage) are both storage systems in Erlang. The main difference is that ETS is in-memory and therefore faster, while DETS is disk-based and can store larger amounts of data.
Erlang has built-in support for distributed computing. You can spawn processes on remote nodes using spawn(Node, Module, Function, Args) and send messages to them just like local processes.
Erlang has two types of schedulers: CPU schedulers and IO schedulers. CPU schedulers run Erlang processes while IO schedulers handle IO tasks.
A gen_server in Erlang can be implemented by defining a module that exports the required callback functions such as init/1, handle_call/3, handle_cast/2, and handle_info/2.
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)