Hiring guide for Erlang R16B02 Engineers

Erlang R16B02 Developer Hiring Guide

Erlang R16B02 is a computer programming language developed by Ericsson, a leading telecommunications company, for the purpose of building robust, fault-tolerant systems. Released in 2013, it is a version of the Erlang language which was originally created in the late 1980s to improve telecommunication systems' development and operation. The language is highly concurrent and offers hot swapping, allowing code to be changed without stopping the system. It has been widely used in industries such as telecoms, banking, e-commerce, computer telephony and instant messaging. Erlang's open-source software is known for its performance and reliability, making it a vital tool in high availability systems development.

Ask the right questions secure the right Erlang R16B02 talent among an increasingly shrinking pool of talent.

First 20 minutes

General Erlang R16B02 app knowledge and experience

The first 20 minutes of the interview should seek to understand the candidate's general background in Erlang R16B02 application development, including their experience with various programming languages, databases, and their approach to designing scalable and maintainable systems.

What are the key features of Erlang R16B02?
Erlang R16B02 has several key features such as concurrency, fault tolerance, distribution, hot swapping, and support for real-time systems.
How would you describe the process communication in Erlang?
In Erlang, processes communicate using a message-passing mechanism. Messages are sent asynchronously and stored in a mailbox until the receiving process is ready to process them.
What are the benefits of using Erlang for developing concurrent applications?
Erlang's lightweight processes, message-passing concurrency model, and preemptive scheduling make it well-suited for developing concurrent applications. Additionally, its built-in support for fault tolerance and distribution contributes to the reliability and scalability of such applications.
Describe the difference between lists and tuples in Erlang.
In Erlang, lists are used when the number of elements is unknown or can change, whereas tuples are used when the number of elements is known and fixed. Additionally, lists are ordered collections of elements, while tuples are ordered collections of heterogeneous elements.
How would you handle errors in Erlang?
Erlang uses a 'let it crash' philosophy for error handling. This means that instead of trying to catch and handle every possible error, we allow the process to fail and rely on a supervisor process to restart it or take some other appropriate action.
The hiring guide has been successfully sent to your email address.
Oops! Something went wrong while submitting the form.

What you’re looking for early on

Does the candidate demonstrate a deep understanding of Erlang R16B02?
Has the candidate been able to solve complex problems during the interview?
Has the candidate shown a clear understanding of concurrent programming?
How well has the candidate demonstrated their ability to work in a team?

Next 20 minutes

Specific Erlang R16B02 development questions

The next 20 minutes of the interview should focus on the candidate's expertise with specific backend frameworks, their understanding of RESTful APIs, and their experience in handling data storage and retrieval efficiently.

What are the differences between spawn and spawn_link in Erlang?
Both spawn and spawn_link are used to create a new process in Erlang. However, spawn_link also establishes a link between the calling process and the new process, which means that if either process terminates, the other process will also be terminated.
How would you implement a distributed system in Erlang?
Erlang provides built-in support for distributed systems. This can be achieved by creating multiple Erlang nodes and using the ! operator to send messages between processes running on different nodes. Additionally, the global module can be used to register processes that are visible across all nodes.
What is hot code swapping in Erlang and how would you use it?
Hot code swapping is a feature in Erlang that allows you to change the code of a running system without stopping or restarting it. This is done using the module system, where a new version of a module can be loaded while the old version is still running.
Describe the difference between ETS and DETS in Erlang.
ETS (Erlang Term Storage) and DETS (Disk Erlang Term Storage) are two types of storage tables in Erlang. ETS tables are stored in memory and therefore provide fast access times, but are lost if the Erlang node is stopped. DETS tables, on the other hand, are stored on disk and thus persist across node restarts, but have slower access times.
How would you handle shared state in Erlang?
Erlang discourages shared state due to the complexities it introduces in concurrent systems. However, when necessary, shared state can be managed using various mechanisms such as message passing, process dictionaries, ETS tables, or database systems like Mnesia.
The hiring guide has been successfully sent to your email address.
Oops! Something went wrong while submitting the form.

The ideal back-end app developer

What you’re looking to see on the Erlang R16B02 engineer at this point.

At this point, a skilled Erlang R16B02 engineer should demonstrate strong problem-solving abilities, proficiency in Erlang R16B02 programming language, and knowledge of software development methodologies. Red flags include lack of hands-on experience, inability to articulate complex concepts, or unfamiliarity with standard coding practices.

Digging deeper

Code questions

These will help you see the candidate's real-world development capabilities with Erlang R16B02.

What does this simple Erlang code do?

start() ->
    io:fwrite('Hello, World!').
This code defines a module named 'hello' and exports a function named 'start' with zero arguments. The 'start' function prints 'Hello, World!' to the console.
What will be the output of this Erlang code snippet?

start() ->
    X = 5,
    Y = 10,
    Z = X + Y,
    io:fwrite('~p~n', [Z]).
This code defines a module named 'test' and exports a function named 'start' with zero arguments. The 'start' function adds two numbers 5 and 10 and assigns the result to variable Z. It then prints the value of Z to the console. So the output will be '15'.
What does this Erlang code do that manipulates a list?

start() ->
    List = [1,2,3,4,5],
    NewList = lists:reverse(List),
    io:fwrite('~p~n', [NewList]).
This code defines a module named 'listtest' and exports a function named 'start' with zero arguments. The 'start' function creates a list of integers from 1 to 5, reverses the list using the 'lists:reverse' function, and then prints the reversed list to the console.
What does this Erlang code do that involves concurrency?

start() ->
    spawn(fun() -> io:fwrite('Hello from a new process!') end).
This code defines a module named 'concurrency' and exports a function named 'start' with zero arguments. The 'start' function spawns a new process that prints 'Hello from a new process!' to the console.

Wrap-up questions

Final candidate for Erlang R16B02 Developer role questions

The final few questions should evaluate the candidate's teamwork, communication, and problem-solving skills. Additionally, assess their knowledge of microservices architecture, serverless computing, and how they handle Erlang R16B02 application deployments. Inquire about their experience in handling system failures and their approach to debugging and troubleshooting.

What are the differences between function and fun in Erlang?
In Erlang, a function is named and defined in a module, while a fun is an anonymous function that is defined and used within another function. Funs can capture variables from their surrounding scope, a feature known as closure.
How would you handle large amounts of data in Erlang?
Erlang provides several mechanisms to handle large amounts of data, such as using distributed Erlang nodes, ETS or DETS tables for in-memory or disk-based storage, respectively, or the Mnesia database for more complex data storage needs.
Describe the difference between synchronous and asynchronous message passing in Erlang.
In Erlang, synchronous message passing involves a process sending a message and then waiting for a response before it can continue. Asynchronous message passing, on the other hand, involves a process sending a message and then continuing with its execution without waiting for a response.

Erlang R16B02 application related

Product Perfect's Erlang R16B02 development capabilities

Beyond hiring for your Erlang R16B02 engineering team, you may be in the market for additional help. Product Perfect provides seasoned expertise in Erlang R16B02 projects, and can engage in multiple capacities.