F* Developer Hiring Guide

Hiring Guide for F* Engineers

Ask the right questions to secure the right F* talent among an increasingly shrinking pool of talent.

The F* (F Star) computer programming language is a sophisticated, statically-typed functional programming language developed by Microsoft Research. It was designed for program verification, enabling developers to write annotations expressing properties they want their programs to have. The F* type-checker aims to prove these properties via an automated theorem prover. This language is used in several Microsoft projects, including Project Everest, which aims to build a verified HTTPS stack. Its development and application are documented in numerous research papers published by Microsoft Research.

First 20 minutes

General F* knowledge and experience

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.

What are the basic data types in F*?

F* includes basic data types like integers, booleans, strings, and more complex ones like lists, options, and references.

How would you handle side-effects in F*?

F* has a mechanism known as the 'effect system'. This allows programmers to mark functions with their side-effects, which are then checked during the verification process.

Describe the difference between F* and other functional languages like Haskell or OCaml.

The main difference is that F* has a built-in mechanism for program verification. It allows programmers to write specifications and prove them as part of the program.

What are the benefits of using F* over other languages?

F* provides strong type-checking, effect system, and a powerful system for defining and proving properties about programs.

How would you explain the purpose of F*?

F* is a functional programming language aimed at program verification. It puts forth a mechanism to define the specification of a program and verify the program against the specification.

The hiring guide has been successfully sent to your email address.
Oops! Something went wrong while submitting the form.

What youre looking for early-on

Does the candidate show enthusiasm for the role and the company?

This is important because it indicates that the candidate is likely to be motivated and committed to the job.

Has the candidate displayed an ability to learn and adapt?

This is crucial because technology is always evolving, and developers need to be able to keep up with new trends and tools.

Does the candidate have experience with relevant tools and technologies?

This is important because it shows that the candidate is already familiar with the tools they'll be using in the role.

Is the candidate able to articulate their thoughts and ideas clearly?

This is necessary because effective communication is key in a team environment.

Has the candidate shown problem-solving abilities?

This is important because programming often involves finding solutions to complex problems.

Does the candidate demonstrate a strong understanding of F* programming language?

This is crucial because F* is a functional programming language that requires a unique set of skills and understanding.

Next 20 minutes

Specific F* development questions

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.

What are the limitations of F*?

F* is not as mature or widely used as other languages, so it may lack libraries and tooling. Also, writing specifications and proofs can be time-consuming.

How would you handle a situation where Z3 cannot prove a property?

In such cases, you can provide additional hints or lemmas to help Z3. If that's not possible, you can also use a manual proof mode to guide the proof.

What is the role of the Z3 solver in F*?

F* uses the Z3 solver to automatically prove properties about programs. It translates the verification conditions into logical formulas that Z3 can solve.

How would you use F*'s dependent types to improve a program's correctness?

Dependent types can be used to express precise properties about a program. For example, you can define a type of sorted lists and then write functions that only operate on sorted lists.

Describe the difference between dependent types in F* and traditional type systems.

Dependent types in F* allow types to depend on values, which provides a way to express more precise types and invariants. Traditional type systems usually don't have this feature.

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 F* engineer at this point.

A skilled F* engineer should demonstrate proficiency in formal verification, functional programming, and knowledge of F* syntax and semantics. Red flags include lack of problem-solving skills, inability to explain complex concepts clearly, or unfamiliarity with the F* language and its applications.

Digging deeper

Code questions

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

What does the following F# code do?

let square x = x * x

This code defines a function named 'square' that takes an argument 'x' and returns the square of 'x'.

What will be the output of the following F# code?

let x = 5
let y = 3
printfn "%d" (x % y)

The output will be '2'. The code calculates the remainder of the division of 'x' by 'y'.

What does the following F# code do?

let list1 = [1;2;3;4;5]
let list2 = List.map (fun x -> x * 2) list1

This code creates a new list 'list2' by applying a function that multiplies each element of 'list1' by 2.

What does the following F# code do?

let mutable counter = 0
do while counter < 5 do
    counter <- counter + 1

This code creates a mutable variable 'counter' and increments it in a loop until it reaches 5. The [<System.STAThread>] attribute indicates that the COM threading model for an application is single-threaded apartment.

What does the following F# code do?

type Circle(radius:float) =
    member this.Area = Math.PI * radius * radius

This code defines a class 'Circle' with a constructor that takes a 'radius' as a parameter. It also defines a read-only property 'Area' that calculates the area of the circle.

What does the following F# code do?

let rec factorial n =
    if n = 0 then 1 else n * factorial (n - 1)

This code defines a recursive function 'factorial' that calculates the factorial of a given number 'n'. If 'n' is 0, it returns 1. Otherwise, it multiplies 'n' with the factorial of 'n - 1'.

Wrap-up questions

Final candidate for F* role questions

The final few interview questions for a F* candidate should typically focus on a combination of technical skills, personal goals, growth potential, team dynamics, and company culture.

How would you use F* to improve the security of a system?

F* can be used to verify critical parts of the system, such as cryptographic algorithms, to ensure they are free of bugs. This can significantly improve the system's security.

What are the challenges of using F* in a large codebase?

The main challenges are the time required to write specifications and proofs, and the need to train developers in F* and formal verification.

How would you handle non-termination in F*?

F* has a 'div' effect for non-terminating computations. You can use this effect to explicitly mark non-terminating functions.

Describe the difference between total and partial functions in F*.

Total functions in F* are guaranteed to terminate and not throw exceptions, while partial functions may not terminate or throw exceptions. F* checks totality by default.

How would you use F* to verify a complex algorithm?

First, I would define the specification of the algorithm using F*'s type system. Then, I would write the algorithm and use F*'s verification mechanism to prove that it meets the specification.

The hiring guide has been successfully sent to your email address.
Oops! Something went wrong while submitting the form.

F* application related

Product Perfect's F* development capabilities

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