8a. Overview and Goals

This chapter focuses on the role of type stability in achieving high performance. Its importance for Julia can't be overstated: any attempt to generate fast code without ensuring type stability is destined to fail. Because of this, type stability should be the starting point of the optimization process, before pursuing any further performance improvements.

The formal definition of type stability is provided in Section 8b. Its importance becomes clear when we understand how computers execute operations. At the most basic level, the process for internal computation differs depending on the data types involved. Integer arithmetic, for instance, follows an entirely different execution path than floating-point arithmetic. Because computers must implement distinct operations for different types, performance hinges on identifying concrete types for all variables before code execution.

Julia addresses this requirement through type inference, where Julia analyzes the code and tries to deduce the concrete type of each variable. However, inference is only performed inside function bodies. Consequently, wrapping your code in a function is a necessary first step toward type stability. Importantly, though, this alone doesn't guarantee type stability. That's why we'll also explore the additional conditions needed.

The roadmap of the chapter is as follows:

• Section 8c considers how to achieve type stability when functions operate with two of the most common objects in Julia: scalars and vectors.

• Section 8d demonstrates how asserting variable types at the global scope ensures type stability. This technique is especially valuable for variables that act as constants throughout a program, letting us work with global variables without sacrificing performance.

• Section 8e provides a general technique to address type instability based on "barrier" functions. When a variable inside a function has ambiguous type information, the technique involves calling a second function (the "barrier" function) from within the original one. This triggers a new round of type inference, thereby restoring stability.

• Section 8f moves to the analysis of type stability when tuples are involved. Because tuples encode richer type information, their analysis requires more nuanced considerations.

• Section 8g deals with type stability when a function calls a higher-order function, which is a function that takes another function as an argument (e.g., the map function). Julia avoids specialization in this case, so that the higher-order function runs without considering the type of the variable being transformed. We explore several ways to retain type stability in this case.

• Section 8h addresses subtle scenarios where type instability can unexpectedly arise. These cases are referred to as "gotchas" and can surprise even experienced users.