A computer is primarily a device that can run computer programs, by following instructions about how to manipulate data.

Nearly all the computers currently in use, from the tiny ones integrated into electronic gadgets, the well-known desktop computers (PCs), to large and powerful supercomputers filling out entire rooms, work internally with digital data only.^[4] Digital data are basically integer (whole) numbers encoded in binary form, which are represented by sequences of the symbols 0 and 1. We will discuss the term digital in the next section in more detail.

The most important part of a digital computer is the CPU, the Central Processing Unit. That tiny device is built of digital electronic circuits and can perform very basic mathematical and logical operations on numbers, like adding two numbers or deciding if a number is larger or smaller than another number. Most computer CPUs can only store very few numbers internally, and forget the numbers when the power is switched off. So the CPU is typically electrically connected to a RAM module, a Random Access Memory, which can store many more numbers and allow fast access to these numbers, and to a Hard disk or SSD device, which can permanently store the numbers but does not allow such fast access. The stored numbers are most often called just data — basically, that data is nothing more than numbers, but it can be interpreted in many ways, such as pictures, sounds, and much more.

The traditional hard disk drives (HDD), which store data electromechanical on rotating magnetic disks, as well as the more modern variants, the solid-state-devices (SDD), which store data using modern semiconductor technologies, can store data persistently for longer time periods, even when no electric power supply is available. Both, SSDs and HDDs, can be optionally split into multiple partitions, e.g. one or multiple OS partitions for executable programs or pure data partitions for passive data like text files or pictures. Before use, each partition is generally formatted and a file system (FS) is created. These two steps create an internal structure on the storage device, which allows us to store and retrieve individual data blocks like programs, text files, or pictures.

Nearly all of today’s desktop computers, and even most notebooks and cellphones contain not only a single CPU, but multiple CPUs, also called "Cores", so they can run different programs in parallel, or a single program can run parts of it on different CPUs, to increase performance or reduce total execution time. The so-called supercomputers can contain thousands of CPUs. Besides CPUs, most computers have also at least one GPU, a Graphic Processing Unit, that can be used to display data on a screen or monitor, maybe for doing animations in games or for playing video. The distinction between CPU and GPU is not really sharp; usually, a CPU can also display data on screens and monitors, and GPUs can do also some data processing that CPUs can do. But GPUs are optimized for the data display task.

More visible to the ordinary computer user are the peripheral devices like keyboard, mouse, screen, and perhaps a printer. These enable human interaction with the computer, but are in no way a core component of it; the computer can run well without them. In notebooks or laptop computers or in cellphones, the peripheral devices are closely integrated with the core components. All the physical parts of a computer are also called hardware, while the programs running on that hardware are called software.

A less visible but also very important class of computers are microcontrollers and so-called embedded devices, tiny pieces with typically a hull of black plastic with some electrical contacts. The devices can contain all necessary elements, that is the CPU, some RAM, and persistent storage that can store programs and data when no electric power supply is available. These devices may be restricted in computing power and the amount of data that they can store and process, but they are contained in many consumer devices. They control your washing machine, refrigerator, television, radio, and much more. Some devices in your home may even contain multiple microcontrollers and often the microcontrollers can already communicate with each other by RF (Radio-Frequency), or access by WLAN the internet, which is sometimes called the Internet of Things (IoT).

Another class of large and very powerful digital computers is called mainframe computers or supercomputers, which are optimized to process large amounts of data very fast. The key to their gigantic computing power is that many fast CPUs work in parallel — the problem or task is split into many small parts that are solved by one CPU each, and the final result is then the combination of all the solved sub-tasks. Unfortunately, it is not always possible to split large problems into smaller sub-tasks.

Digital computers are usually driven by a clock signal that pulses at a certain frequency. The CPU can do simple operations like the addition of two integers at each pulse of the clock signal. For more complicated operations like a multiplication or a division, it may need more clock pulses.

So a rough measure for the performance of a computer is the clock rate, that is the number of clock pulses per second, divided by the number of pulses that the CPU needs to perform a basic operation, multiplied by the number of CPUs or Cores that the computer can use.

A totally different kind of computers are Quantum Computers, large, expensive high-tech devices, which use the rules of quantum mechanics to calculate many computations in parallel. Today only a few of them exist, for research at universities and some large commercial institutes. Quantum computers may at some time in the future fundamentally change computing and our whole world, but they are not the topic of this book.

Whenever we measure a quantity based on some tiny base unit, then we work in the digital area, and we measure with some granularity. Our ordinary money is digital in some way, as the cent is the smallest base unit; you will never pay a fraction of a cent for something. Time can be seen as a digital quantity as long as we accept the second as the smallest unit. Even on so-called analogue watches, the second hand will generally jump forwards in steps of a second, so you can not measure fractions of a second with that watch.

An obvious analogue property is the thermodynamic temperature and its classic measurement device is the well-known capillary thermometer consisting of a glass capillary filled with alcohol or liquid mercury. When temperature increases, the liquid in a reservoir expands more than the surrounding glass and partly fills the capillary. That filling rate is an analogue measure for the temperature.

While the hourglass works digitally (you can count the tiny sand grains), the sundial does not.

Most of the quantities in our real world seem analog, and digital quantities seem to be some sort of arbitrary approximation.

But quantum mechanics has taught us that many quantities in our world really have a granularity. Physically, quantities like energy or momentum are indeed multiple of the tiny Planck constant. Or consider electric charge, which is always a multiple of the elementary charge unit of one electron. Whenever an electrical current is flowing through an electrically conducting wire, an ionized gas, or an electrolyte like saltwater, there are flowing multiple of the elementary charge only, never fractions of it. And of course, light and electromagnetic radiation also have some form of granularity, which the photoelectric effect, as well as Compton scattering, proves.

An important and useful property of digital signals, and digital data, is that they map directly to integral numbers.

The simplest form of digital data is binary data, which can have only two distinct values. When you use a mechanical switch to turn the light bulb in your house on, or of, you change the binary state of the bulb. And your neighbor, when watching your house, receives binary signals.^[5]

Digital computers are generally using binary electric states internally — voltage or current on or off. Such an on/off state is called a bit. We will learn more about bits and binary logic later. One bit can store obviously only two states, which we may map to the numbers 0 and 1. Larger integer numbers can be represented by a sequence of multiple bits.

The Morse code was an early application to transmit messages encoded in binary form.

A very important property of digitally encoded numbers (data) is that they can be copied and transmitted exactly without loss of precision. The reason for this is that digital numbers have a well-defined clean state, there is no noise that overlays the data and may accumulate when the data is copied multiple times. Well, that statement is not really true — under bad conditions, the noise can become so large that it changes the binary state of signals. Imagine we try to transfer some whole numbers encoded in binary form, maybe by binary states encoded as voltage level 0 Volt and 5 Volts, over an electric wire and a long distance. It is clear that the long wire can pick up some electromagnetic noise that can change the true 0 Volt data to a voltage that is closer to 5 Volts than to the true 0 Volt level, so it is received incorrectly. To catch such types of transmission errors, checksums are added to the actual data. A checksum is derived by a special mathematical formula from the original data and transferred with it. The receiver applies the same formula to the received data and compares the result with the received checksum. If it does not match, then it is clear that the data transmission is corrupted, and a resend is requested.

The opposite of digital is generally called analogue, a term that is used for data that have or seems to have no granularity. For example, we speak of an analogue voltage when the voltage can have each value in a given range and when the voltage does not "jump" but change continuously.^[6] For observing analogue voltages or currents, one can use a moving coil meter, a device where the current flows through a coil in a magnetic field and the magnetic force moves the hand/pointer.

We said in the previous section that nearly all of our current computers work with digital data only. Basically, that is that they work internally with integer numbers, stored in sequences of binary bits. All input for computers must have the form of integer numbers, and all output has the form of integer numbers. Whenever we want to feed computers with some sort of analogue data, like an analogue voltage, we have to convert it into a digital approximation. For that task, special devices called analog to digital converters (ADC) exist. And in some cases we have to convert the digital output data of computers to analogue signals, like when a computer plays music: The computer output in form of digital data is then converted by a device called digital to analog converter (DAC) into an analogue voltage, that generates an analogue current through a coil in the speakers of our soundbox, and that electric current in the coil generates a magnetic field which exercises mechanical forces and moves the membrane of the speaker, resulting in oscillating motions, which generates air pressure variations that our ear can detect and that we finally hear as sound.

Most computers, from cellphones to large supercomputers, use an operating system (OS). A well-known OS is the GNU/Linux kernel. Operating systems can be seen as the initial program, that is loaded and started when we switch the computer on and that works as some kind of supervisor:^[7] it can load other programs, and it distributes resources like CPU cores or RAM between multiple running programs. It also controls user input by keyboard and mouse, displays output data on the screen — as text or graphics, controls how data is loaded and stored to nonvolatile storage media like hard-disk or SSD, manages all the network traffic, and many more tasks. An important task of the OS is to allow user programs to access all the various hardware components from different vendors in a uniform, high-level manner. An OS can be seen as an intermediate layer between user programs, like a text processor or a game, and the hardware of the computer. The OS allows user programs to work on a higher level of abstraction, so they do not need to know much about the low-level hardware details.

An important ability of most modern operating systems is to run multiple system and user programs concurrent or parallel. Concurrent execution of programs means, that the execution switches very fast between all the active programs. That way the user does not notice when programs do pause for a short time interval, and all of them seem to be running all the time, but not at full speed. True parallel execution of programs indicates, that all of them can permanently run at full speed — this is only possible when the computer has multiple CPUs or a CPU with multiple physical cores.

Computer operating systems have generally a close relation to software libraries, which are collections of data types and functions working with that data types. Libraries can be a part of the OS or can be more or less independent of the OS. Libraries are software components that provide data types and functions with a well-defined interface (API, Application Programming Interface) and behavior.

Libraries can be used as shared libraries, which are single binary files stored on the file system of a computer, often with the file extension .so or .dll, which can be accessed from different computer programs simultaneously, or as static libraries, which are part of single programs. Shared libraries have some advantages: we need only one instance on the file system of the computer, and the library is loaded only once into the computer memory (RAM), even when it is used by different apps simultaneously. This saves space, and when the library has serious errors, it is in principle possible to replace the library with a corrected version, which is then used by all the software on the computer. Shared libraries often come in numbered versions, where a higher number denotes a newer, improved, or extended library version. Sometimes some of the programs we use may need still an older library version, while other software needs already a never one. In that case, our file system has to provide multiple versions of a shared library, which can be used independently. On the other hand, statically linked libraries are directly glued with a single computer program. That makes the distribution of the program easier, as it can be shipped as a single entity, and we do not have to ensure that all the needed dynamic libraries are available on the destination computer. But if a statically linked library has serious errors, then we have to replace all the programs that are linked statically with that corrupted library.

Small microcontrollers and embedded devices often do not need to use an operating system, as they generally run only one single user program and because they usually do not have a large variety of hardware components to support.

To interact with the OS and with application programs running on the computer, we need some form of a user interface. Traditional user interfaces are text-centric and often provided directly by the OS as one single text screen filling the whole display: The user has to enter textual commands, and the computer reacts with textual messages. For entering commands and data, a keyboard is used, which layout was heavily inspired by the classical mechanical typewriter. For desktop computers, the textual user interfaces have been mostly replaced or at least supported by graphical user interfaces (GUIs) for about a half-century now, and even cellphones and other electronic gadgets now use some form of a GUI for user interaction. For large mainframe computers, the textual user interface is still common. Graphical user interfaces present the user with a set of icons or widgets, often arranged in rectangular graphical boxes called windows. These windows can be moved around, resized, and can partly or fully overlap other windows. A special type of windows is called terminal-, shell- or console-windows, which behave like the traditional full-screen textual user interfaces. Graphical user interfaces allow it to interact with the computer by simple actions like clicking on buttons or by drag or wipe gestures, performed directly on a touch-sensitive display or with a device called a mouse, which mirrors its mechanical movement on the table to a graphical cursor on the computer display, and provides a set of pushbuttons which are used to initiate a click action when the mouse pointer hovers over an icon or widget. The main advantage of graphical user interfaces is, that the user does not have to remember and type in long command sequences. A set of on-screen buttons labeled with single letters can even simulate a traditional keyboard, but when the input of longer textual data is required, the physical keyboard is still used. Graphical user interfaces are sometimes even supported by speech recognition systems, which are used to enter commands or textual messages vocally. Graphical user interfaces may be very strongly coupled with the OS but are basically still system programs executed by the OS. For the Microsoft Windows OS or the macOS, this distinction is not that obvious, as the same GUI is running permanently. For other operating systems like Linux, it is more obvious, as these operating systems are sometimes used without a GUI, and because various GUI tool kits like Gnome, KDE, and many more are available.

Computer programming includes the creation, testing, and optimizing of computer programs.

A computer program is basically a sequence of numbers, which make some sense to a computer CPU, in such a way that the CPU recognizes the numbers as so-called instructions or numeric machine code, maybe the instruction to add two numbers.

The first computers, built in the 1950s, were indeed programmed by feeding sequences of plain numbers to the device. The numbers were stored on so-called punch cards, consisting of strong paper, where the numbers were encoded by holes in the cards. The holes could be recognized by electrical contacts to feed the numbers into the CPU. As plain numbers do not match well with human thinking, soon more abstract codes were used. A very direct code, which matches numerical instructions to symbols, is the assembly language. In that language, for example, the character sequence "add A0, $8" may map directly to a sequence of numbers which instructs the CPU to add the constant integer number 8 to CPU register A0, where A0 is a storage area in the CPU where numbers can be stored. As there exist many different types of CPUs, all with their own instruction sets, there exist many different assembly instruction sets, with similar, but not identical instructions. The rules that describe how these basic instructions have to look are called the syntax of the assembly language.

The numerical machine code, or the corresponding assembly language, is the most basic instruction set for a CPU. Every instruction that a CPU can execute maps to a well-defined assembly instruction. So, each operation that a computer may be able to perform can be expressed in a sequence of assembly instructions. But complicated tasks may require millions of assembly instructions, which would take humans very long to write, and even much longer to modify, proof, and debug.^[8]

Just a few years after the invention of the first computers, people recognized that they would need even more abstract instruction sets, like repeated execution, composed conditionals, or other data types than plain numbers as operands. So higher-level programming languages like Algol, Fortran, C, Pascal, or Basic were created.

An algorithm is a detailed sequence of more or less abstract instructions to solve a specific task or to reach a goal. Cooking recipe books and car repair instructions are examples of algorithms.

The basic math operations kids learn in school — to add, multiply or divide two numbers with paper and pencil — are algorithms too. Even starting a car follows an algorithm — when the temperature is below zero, and snow covers the vehicle, then you first have to clean the windows and lights. And when you first drive again after a long break, you would have to check the tires before you start the engine. The algorithm can be carried out by strictly following the instructions — it is not necessary to really understand how and why it works.

So an algorithm is a perfect fit for a computer, as computers are excellent at following instructions without really understanding what they are trying to accomplish.

A math algorithm to sum up the first 100 natural numbers may look like this:

Most traditional programming languages were created to map algorithms to elementary CPU instructions. Algorithms typically contain nested conditionals, repetition, math operations, recovery from errors, and maybe plausibility checks. A more complicated algorithm generally can be split into various separate logical parts, which may include reading in data at one point, multiple processing steps at another, and storing, or displaying data as plain text, graphic, or animation at yet another point. This splitting into parts is mapped to programming languages by grouping tasks into subroutines, functions, or procedures which accept a set of input parameters and can return a result.

As algorithms often work not only with numbers but also with text, it makes sense to have a form of textual data type in a programming language too. And all the data types can be grouped in various ways, for example, as sequences of multiple data of the same type, like lists of numbers or names. Or as collections of different types, like name, age, and profession of a citizen in an income tax database. For all these use cases, programming languages provide some sort of support.

We already learned that the CPU in the computer can execute only simple instructions, which we call numeric machine code or assembly instructions.

To run a program written in a high-level language with many abstractions, we need some sort of converter to transform that program into the basic instructions that the CPU can execute. For the conversion process, we have basically two options: We can convert the entire program into machine code, store it on disk, and then run it on the CPU. Or we can convert it into small portions, maybe line by line, and run each portion whenever we have converted it. Tools that convert the whole program first are called compilers. Compilers process the program that we have written, include other source code like needed library modules, check the code for obvious errors and then generate and store the machine code that we then can run.

Tools that process the source code in small portions, like single statements, are called interpreters. They read in a line of source code, investigate it to check if it is a valid statement, and then feed the CPU with corresponding instructions to execute it. It is similar to picking strawberries: you can pick one and eat it at once, or you can put them all into a basket and eat them later. Both interpreters and compilers have advantages and disadvantages for special use cases. Compilers can already detect errors before the program is run, and compiled programs generally run fast, as all the instructions are already available when the programs run. The compiling step takes some time, of course, at least a few seconds, but for some languages and large programs, it may take much longer. That can make the software development process slow because as you add or change code, you have to compile it before you can execute and test your program. That may be inconvenient for unskilled programmers, as they may have to do much testing. Some use a programming style that is: change a tiny bit of the source code, then run it and see what it does. But more common practice is that you think about the problem first and then write the code, which then in most cases does nearly that of what you intended. For this style of programming, you do not have to compile and execute your code that often. Compilers have one important benefit: they can detect many bugs, mostly typing errors, already in the compile phase, and they give you a detailed error message. Interpreters have the advantage that you can modify your code and immediately execute it without delay. That is nice for learning a new language and for some fast tests, but even simple typing errors can only be detected when they are encountered while running the program. If your test does not try to run a faulty statement, there will be no error, but it may occur later. Generally, interpreted program execution is much slower than running compiled executables, as the interpreter has to continually process the source code in real-time as it’s being run, while the compiler does it only once before the program is run. At the end of this section, a few additional notes:

Compilers are sometimes supported by so-called linkers. In that case, the compiler converts the source code, which can be stored in multiple text files, each in a sequence of machine code instructions, and finally the linker joins all these machine code files to the final executable. Some compilers do not need the linking step or call the linker automatically. And some interpreters convert the textual source code in one very fast, initial pre-processing step ("on the fly") to a so-called byte code, that can then be interpreted faster. The languages Ruby and Python do that. Some languages, like Java, can compile and optimize the source code while the program is running. For that process, a so-called virtual machine is used, which builds an intermediate layer between the hardware and the user program.

There are many different styles that software can be written. A programming paradigm is a fundamental style of writing software, and each programming language supports a different set of paradigms. You’re probably already familiar with one, or more of them, and at the very least, you know what object-oriented programming (OOP) is because it’s taught as part of many introductory computer science courses.

We already mentioned the assembly languages, which provide only the basic operations that the CPU can perform. Assembly languages provide no abstractions, so maybe we should not even call them programming languages at all. Then there are low-level languages like Fortran or C, with some basic abstractions, which still work close to the hardware and which are mostly designed for high performance and low resource consumption (RAM), but not to detect and prevent programming errors or to make life easy for programmers. These languages already support some higher-order data types, like floating-point numbers or text (strings), homogeneous, fixed-size containers (called arrays in C), or heterogeneous fixed-size containers (called structs in C).

A different approach is taken by languages like Python or Ruby, which try to make writing code easier by offering many high-level abstractions and which have better protection against errors but are not as efficient. These languages also support dynamic containers, which can grow and shrink, or advanced data structures like hash tables (maps) or support textual pattern matching by regular expressions (regex).

Another way to differentiate programming languages is if they are statically or dynamically typed. Ruby, Python, and JavaScript are all examples of dynamically typed languages, that is, they use variables that can store any data type, so the variable’s type of data that it accepts can therefore dynamically change during program execution. That seems comfortable for the user, and sometimes it is, especially for short programs, which may be written for one-time use only and are sometimes called scripts. But dynamic typing makes the discovery of logical errors harder — an illegal addition of a number to a letter may be detected only at run-time. And dynamically typed languages generally waste a lot of memory and their performance is not that great. It is as if we would own a set of large, equally sized moving boxes, and we would store all of our goods in it, each piece in one box.

For statically typed languages, each variable has a well-defined data type like integer number, real number, a single letter, a text element, and many more. The data type is either assigned by the author of the program with a type declaration, or is detected by the compiler itself when processing the program source code, called type inference, and the variable’s type does never change. In this way, the compiler can check for logical errors early in the compile process, and the compiler can reserve memory blocks exactly customized to the variables that we want to store, so total memory consumption and performance can be optimized. Referring again to our boxes example, statically typing is like using customized boxes for all your goods.

All these types of programming languages are often called imperative programming languages, as the program describes detailed what to do. There are other types of programming languages too, for example, languages like Prolog, which try to give only a set of rules and then let the computer try to solve a problem with these rules. And of course, there are the new concepts of artificial intelligence (AI) and machine learning (ML), which are less based on algorithms and more on neural nets, which are trained with a lot of data until they can provide the desired results. Nim, the computer language this book is about, is an imperative language, so we will focus on the imperative programming style in this book. But of course, Nim can be used to create AI applications.

Further still, we can differentiate between languages like C, C++, Rust, Nim, and many more that compile to native executables and can run directly on the hardware of the computer, contrasted with languages like Java, Scala, Julia, and some more, that use a large Virtual Machine (VM) as an intermediate layer between the program and the hardware, and interpreted languages like Ruby and Python. Languages using a virtual machine generally need some startup time when a program is invoked, as the VM must be loaded and initialized, and interpreted languages are generally not very fast.^[9] The distinction between languages that compile to native executables, and those that are executed on a virtual machine, is not really sharp. For example, Kotlin and Julia were executed on a virtual machine initially but now can compile the source code to native executables.

An important class of programming languages is the group of so-called Object-Oriented-Programming (OOP) languages, which use inheritance and dynamic dispatch and become popular in the 1990s. For some time, it was assumed that Object-Oriented-Programming was the ultimate solution to manage and structure really large programs. Java was the most prominent example of the OOP languages. Java forces the programmer to use OOP design, and languages like C++, Python, or Ruby strongly push the programmer to use the OOP design. The practice has shown that OOP design is not the ultimate solution for all computing problems, and OOP design may prevent optimal performance. So newer languages, like Go, Rust, and Nim, support some form of OOP programming but use it only as one paradigm among many others.

Another popular and important class of programming languages is JavaScript and its more modern cousins like TypeScript, Kotlin or Dart, and others. JavaScript was designed to run in web browsers to support interactive web pages and programs and games running in the browser. In this way, the program became nearly independent of the native operating system of the computer. Note that unlike the name may indicate, JavaScript is not closely related to the Java language. Nim can compile to a JavaScript backend, so it supports web development well.

Three well-known traditional programming languages are C, Java, and Python. C is basically a simple, close-to-the-hardware language created in 1972, for which compilers can generate fast, highly optimized native machine code, but it has cryptic syntax, some strange semantics, and is missing higher concepts of modern languages. Java, created in 1995, forces you strongly to the object-orientated style of programming (OOP) and runs on a virtual machine, which makes it unsuitable for embedded systems and microcontrollers. Python, created in 1991, is generally interpreted instead of compiled, which makes program execution not very fast, and it does not really allow writing low-level code which operates close to the hardware. As many libraries of the Python language are written in highly optimized C, Python can appear really fast if a standard task, like sorting data, processing CSV or JSON files, or website crawling is performed. So Python is not a bad solution when we use it mostly for calling library functions, but it reveals its low performance when we have to write some actual Python code in order to solve a problem. Of course, there are many more programming languages, each with its own advantages and disadvantages — with some optimized for special use cases.

Nim is a state-of-the-art programming language well suited for systems and application programming. Its clean Python-like syntax makes programming easy and fun for beginners, without applying any restrictions to experienced systems programmers. Nim combines successful concepts from mature languages like Python, Ada, and Modula with a few established features of the latest research. It offers high performance with type and memory safety while keeping the source code short and readable. The compiler itself and the generated executables support all major platforms including Windows, Linux, BSD, and Mac OS X. Cross-compiling to Android and other mobile and embedded devices and microcontrollers is possible, and the JavaScript backend allows creating web apps and to run programs in web browsers. The custom package managers, Nimble or Nimph, makes use and redistribution of programs and libraries easy and secure. Nim supports various "backends" to generate the final code. The C, C++ and LLVM-based backends allow easy OS library calls without additional glue code, while the JavaScript backend generates high-quality code for web applications. The integrated "Read/Eval/Print Loop" (REPL), "Hot code reloading", incremental compilation (expected for version 1.8), and support of various development environments including debugging and language server protocols make working with Nim productive and enjoyable.

To keep our motivation, we will present the first tiny Nim program now. Actually, we should have delayed this section until we have installed the Nim compiler on our computer, but we can already run and test the program by just copying it into one of the available Nim online playgrounds like

https://play.nim-lang.org/

In the section What is an Algorithm? we described an algorithm to sum up the first 100 natural numbers. Converting that algorithm into a Nim program is straightforward and results in the text file below. You can copy it into the playground and run it now if you want. The program is built using some elementary Nim instructions, for which we will give only a very short description here. Everything is explained in much more detail in the next part of this book.

We write Nim programs with an editor tool in the form of plain text files, and you will learn how to create them soon. We call these text files the source code of the program. The source code is the input for the compiler. The compiler processes the source code, checks it for obvious errors, and then generates an executable file, which contains the final CPU instructions and can be run. Executable files are sometimes called executables or binary files. The term binary is misleading, as all files on computers are indeed stored as binary data, but the expression "binary" is used to differentiate the executable program from text files like the Nim source code which we can read, print, and edit in an editor. Don’t try to load the executable files generated by the Nim compiler into a text editor, as the content is not plain text, but numeric machine code that may confuse the editor. On the Windows OS, executable files typically get a special name extension .exe, but on Linux, no special name extensions are used.

Nim source code files are processed by the Nim compiler from the top to the bottom, and for the generated executable the program execution also starts in principle at the top. But for the program execution there exist some exceptions, e.g. program code enclosed in functions is not immediately executed where it appears in the program source code file, but later when the function is called. And the program execution is not a linear process — we can use conditional expressions to skip parts of the program, or various loop constructs to repeat the execution of some program segments. Actually, the program execution in Nim is more similar to languages like Python or Ruby than to the C language: A C program always needs a main() function with exactly this name, and the execution of a C program always starts with a compiler-generated call of this function.

Elementary entities of computer programs are variables, which are basically named storage areas in the computer. As Nim is a compiled and statically-typed language, we have to declare each variable before we can use it. We do that by choosing a meaningful name for the variable and specifying its data type. To tell the compiler about our intention to declare a variable, we start the line with the var keyword, followed by the chosen name, a colon, and the data type of our variable. We have to put at least one space character between the var keyword and the name of the variable, to allow the compiler to recognize the two separate entities. Usually, we also put a space after the colon, that separates the variable name from its data type. But this is only a convention to improve the readability of the source code, for the compiler the colon already separates the variable name from the data type. The first line of our program declares a new variable named sum of data type int. Int is short for integer and indicates, that our variable should be able to store negative or positive integer numbers. The var at the start of the line is a keyword. Keywords are reserved symbols that have a special meaning for the compiler. Var indicates that we want to introduce a new variable. The compiler will recognize that and will reserve a memory location in the RAM of the computer which can store the actual value of the variable.

The second line is nearly identical to the first line: we declare another variable, again with int type and plain name i. Variable names like i, j, k are typically used when we have no idea for a meaningful name and when we intend to use that variable as a counter in a loop.

In the lines 3 and 4 of our program, we initialize the variables, that is, we give them a well-defined initial value. To do that, we use the = operator to assign a value to the variable. Operators are special symbols like +, -, *, or / to indicate our desire to do an addition, a subtraction, a multiplication, or a division. Note that the = operator is used in Nim like in many other programming languages for assignment, and not like in traditional mathematics as an equality test. The reason for that is, that in computer programming, assignments occur more frequently than equality tests. Some early languages like Pascal used the compound := operator for assignment, which may be closer to mathematics use, but is more difficult to type on a keyboard and looks not too nice for most people. An expression like x = y assigns the content of variable y to x, that is, x gets the value of y, the former value of x is overwritten and lost, and the content of y remains unchanged. After that assignment, x and y contain the same value. In the above example, we do not assign the content of a variable to the destination, but instead, use a literal numeric constant with the value 0. When the computer has executed lines 3 and 4 the variables sum and i each contain the start value 0. When we use the = operator for an assignment, we usually put a space character on both sides of the operator, but this is only a convention to improve the readability of the source code, and not really necessary. Actually, convention is to put a space on both sides of most Nim infix operators whenever we use them, this includes the arithmetic operators, the assignment operator, or relational operators like < or >. And when we use a colon or a semicolon to separate two entities from each other, we usually put also a space after the punctuation character, in the same way as we would do it in ordinarily text files.

Line 5 of our code example is much more interesting: it contains a while condition. The line starts with the term while, which is again a reserved keyword, followed by the logical expression i < 100 and a colon. An expression in Nim is something that has a result, as a math expression as 2 + 2 which has the numeric result 4 of type integer. A logical expression has no numerical result, but a logical (boolean) one, which can be true or false. The logical expression i < 100 depends on the actual content of variable i. The two lines following the line with the while keyword are each indented by two spaces, meaning that these lines start with two spaces more than the line before. This form of indentation is used in Nim (and Python) to indicate blocks. Blocks are grouped statements. The complete while loop consists of the line containing the while keyword followed by a block of statements. The block after the while condition is executed as long as the while condition evaluates to the logical value true. For the first loop iteration i has the initial value 0, the condition i < 100 evaluates to the boolean value true, and the block after the while condition is executed for the first time. In this block, we have the inc() instruction. Inc is short for increment. Inc(a, b) increases the value of variable a by b, b remains unchanged. So in the above block, i is increased by one, and after that, sum is increased by the current value of i. So when that block has been executed for the first time, i has the value 1 and sum also has the value 1. At the end of that block, execution starts again at the line with the while condition, now testing the expression i < 100 with i containing the value 1. Again it evaluates to true, the block is executed again, i gets the new value 2, and sum gets the value 3. This process continues until i has the value 100, so the condition i < 100 evaluates to false and execution proceeds with the first instruction after the while block. That instruction is an echo statement, which is used in Nim to write values to the terminal or screen of the computer. Some other languages use the term print or put instead of echo. You may still wonder about the colon that terminates line five with the while condition. That colon is (only) a marker to indicate the end of a conditional statement.

Don’t worry if you have not understood much of this short explanation, we will explain all that in much more detail later.

When we write numbers in ordinary life we typically use the decimal system with base 10 and the 10 available digits 0, 1, …​ 9. To get the value of a decimal number, we multiply each digit with powers of 10 depending on the position of the digit and sum the individual terms. The rightmost digit is multiplied with 10^0, the next digit with 10^1, and so on. A literal decimal number like 7382 has then the numerical value 2 * 10^0 + 8 * 10^1 + 3 * 10^2 + 7 * 10^3. We have used here the exponential operator ^ — with 10^3 = 10 * 10 * 10. Current computers use binary representation internally for numbers. Generally, we do not care much about that fact, but it is good to know some facts about binary numbers. Binary numbers work nearly identically to decimal numbers. The distinction is that we have only two available digits, which we write as 0 and 1. A number in binary representation is a sequence of these two digits. Like in the decimal system, the numerical value results from the individual digits and their position: The binary number 1011 has the numerical value 1 * 2^0 + 1 * 2^1 + 0 * 2^2 + 1 * 2^3, which is 11 in decimal notation. For binary numbers, the base is 2, so we multiply the binary digits by powers of two. Formally, the addition of two binary numbers works as we know it from the decimal systems: we add the matching digits and take carry into account: 1001 + 1101 = 10110 because we start by adding the two least significant digits of each number, which are both 1. That addition 1+1 results in a carry and result 0. The next two digits are both zero, but we have to take the carry from the former operation into account, so the result is 1. For the next position, we have to add 0 and 1, which is just 1 without a carry. And finally, we have 1 + 1, which results in 0 with a carry. The carry generates one more digit, and we are done. In the decimal system with base 10, a multiplication with 10 is easily calculated by just shifting all digits one place to the left and writing a 0 at the now empty rightmost position. For binary numbers it is very similar: a multiplication by the base, which is two in the binary system, is just a shift left, with the rightmost position getting digit 0.^[20]

In the binary system, we call the digits typically bits, and we number the bits from right to left, starting with 0 for the rightmost bit — we say that the binary number 10010101 is an 8-bit number because writing that number in binary representation needs 8 digits. Often we imagine the individual bits as small bulbs, a 1 bit is imagined as a lit bulb, and a 0 bit is imagined as a dark bulb. For lit bulbs we say also that the bit is set, meaning that in the binary number 10010101, bits 0, 2, 4, and 7 are set, and the other bits are unset or cleared.

Groups of 8 bits are called a byte, and sometimes 4 bits are called a nibble.

One, two, four, or 8 bytes are sometimes called a word, where a word is an entity that the computer can process in one single instruction. When we have a CPU with 8-byte word size, this means that the computer can for example, add two variables, each 8 byte in size, in one single instruction.

Let us investigate some basic properties of binary numbers. Let us assume that we have an 8-bit word (a byte). An 8-bit word can have 2^8 different states, as each bit can be set or unset independently of the other bits. That corresponds to numbers 0 up to 255 — we assume that we work with positive numbers only for now, we will come to negative numbers soon. An important property of binary numbers in computers is the wrapping around, which is a consequence of the fact that we have only a limited set of bits available to store the number. So when we continuously add 1 to a number, at some point all bits are set, which corresponds to the largest number that can be stored with that number of bits. When we then add again 1, we get an overflow. The run-time system may catch that overflow, so we get an overflow error, or the number is just reset to zero, as it may happen in our car when we manage to drive one million miles, or when the ordinary clock jumps from 23:59 to 00:00 of the next day. A useful property of binary numbers is the fact that we can easily invert all bits, that is, replace set bits with unset ones and vice versa. Let us use the prefix ! to indicate the operation of bit inversion, then !01001100 is 10110011. It is an obvious and useful fact that for each number x we get a number with all bits set when we add x and !x. That is x + !x = 11111111 when we consider an 8 bit word. And when we ignore overflow, then it follows that x + !x + 1 = 0 for each number x. That is a useful property, which we can use when we consider negative numbers.

Now, let us investigate how we can encode negative numbers in binary form. In the binary representation, we have only two states available, 0 or 1, a set bit or an unset bit. But we have no unitary minus sign. We could encode the sign of a number in the topmost bit of a word — when the topmost bit is set, that indicates that the number is regarded as negative. Generally, a modified version of this encoding is used, called two’s complement: a negative number is constructed by first inverting all the bits — a 0 bit is transferred into a 1 bit and vice versa — and finally the number 1 is added. That encoding simplifies the CPU construction, as subtraction can be replaced by addition in this way:

Consider the case that we want to do a subtraction of two binary encoded numbers. The operation has the symbolic notation A - B for arbitrary numbers A and B. The subtraction is by definition the inverse operation of the addition, that is A + B - B = A for each number A and B, or in other words, B - B = 0 for each number B.

Assume we have a CPU that can do additions and that can invert all the bits of a number. Can we do subtraction with that CPU? Indeed, we can. Remember the fact that for each number X X + !X + 1 = 0 as long as we ignore overflow. If that relation is true for each number, then it is obviously true for each B in the expression A - B, and we can write A - B = A + (B + !B + 1) - B = A + (!B + 1) when we use the fact that in mathematics addition and subtraction is associative, that is we can group the terms as we want. But the term in the parenthesis is just the two’s complement, which we get when we invert all bits of B and add 1. So to do a subtraction we have to invert the bits of B, and then add A and !B and 1 ignoring overflow. That may sound complicated, but a bit inversion is a very cheap operation in a CPU, which is always available, and adding 1 is also a very simple operation. The advantage is that we do not need separate hardware for the subtraction operation. Typically, subtraction in this way is not slower than addition because the bit inversion and the addition of 1 can be performed at the same time in the CPU as an ordinary addition.

From the equation above, indicating A - B = A + (!B + 1) it is obvious that we consider the two’s complement (!B + 1) as the negative of B. Note that the two’s complement of zero is again zero, and two’s complement of 00000001 is 11111111. All negative numbers in this system have a bit set to 1 at the leftmost position. This restricts all positive numbers to all the bit combinations where the leftmost bit is unset. For an 8-bit word, this means that positive numbers are restricted to the bits 00000000 to 01111111, which is the range 0 to 127 in decimal notation. The two’s complement of decimal 127 is 10000001. Seems to be fine so far, but note that there exists also the bit pattern 10000000, which is -128 in decimal. For that bit pattern, there exists no positive value. If we try to build the two’s complement of that bit pattern, we would get the same pattern again. This is an asymmetry of two’s complement representation, which can not be avoided. It generally is no problem, with one exception. We can never invert the sign of the smallest available integer; that operation would result in a run-time error.^[21]

Summary: when we work only with positive numbers, we can store in an 8-bit word, which is called a byte, numbers from 0 up to 255. In a 16-bit word, we could store values from 0 up to 2^16 - 1, which is 65535. When we need numbers that can be also negative, we have for 8-bit words the range from -128 to 127 available, which is -2^7 up to 2^7 - 1. For a signed 16-bit word, the range would be -2^15 up to 2^15 - 1.

While we can work with 8 or 16-bit words, for PC programming the CPU usually supports 32 or 64-bit words, so we have a much larger number range available. But when we program microcontrollers or embedded devices we may indeed have only 8 or 16-bits words available, or we may use such small words size intentionally on a PC to fit all of our data into a smaller memory area.

One important note at the end of this section: whenever we have a word with a specific bit pattern stored in the memory of our computer, then we can not decide from the bit pattern directly what type of data it is. It can be a positive or a negative number, but maybe it is not a number at all but a letter or maybe something totally different. As an example, consider this 8-bit word: 10000001. It could be 129 if we have stored intentionally positive numbers in that storage location, or could be -127 if we intentionally stored a negative value. Or it could be not a number at all. Is that a problem? No, it is not as long as we use a programming language like Nim which uses static typing. Whenever we are using variables, we declare their type first, and so the compiler can do bookkeeping about the type of each variable stored in the computer memory. The benefit is, that we can use all the available bits to encode our actual data, and we do not have to reserve a few bits to encode the actual data type of variables. For languages without static typing, that is not the case. In languages like Python or Ruby, we can use variables without a static type, so we can assign whatever we want to them. That seems to be comfortable at first, but can be confusing when we write larger programs and the Python or Ruby interpreter has to do all the bookkeeping at run-time, which is slow and wastes memory for the bookkeeping.

To say it again in other words: for deciding if an operation is valid, it is generally sufficient to know the data type of the operands only. We do not have to know the actual content. The only exception is if we invert the sign of the most negative integer number or if we do an operation with causes an overflow, as there are not enough bits available to store the result — we may get a run-time error for that case.^[22] In a statically-typed language, each variable has a well-defined type, and the compiler can ensure at compile time that all operations on that variable are valid. If an operation is not valid, then the compiler will give an error message. Then when these operations are executed at run-time they are always valid operations, and the actual content, like the actual numeric value, does not matter.

This number type with base 16 is by far not as important as the binary numbers, and it has not really a technical justification to exist, but you may get in touch with these numbers from time to time. Hexadecimal numbers are mostly a legacy from the early days of computers, where computer programming was done not in real programming languages but with numeric codes. To represent the 16 hexadecimal digits, the 10 decimal digits are supported by the characters 'A' .. 'F'. The most significant property of a hexadecimal digit is that it can represent four bits, a unit half of a byte, which is called sometimes a nibble. In old times, when it was necessary to type in binary numbers, it was sometimes easier to encode a nibble with a hexadecimal digit:

The only location where we hear about hexadecimal characters again in this book should be when we introduce the character and string data types — there control characters like a newline character are sometimes specified in hexadecimal form like "\x0A" for a newline character.

We will not describe in too much detail how you can install the Nim compiler, because that strongly depends on your operating system, and because the installation instructions may change in the future. We assume that you have a computer with an installed operating system and internet access, and you are able to do at least very basic operations with your computer, such as switching it on, logging in, and opening a web browser or a terminal window. If that is not the case, then you really should ask someone for help with this basic step, and maybe for some more help for other basic tasks.

Detailed installation instructions are available on the Nim internet homepage at https://nim-lang.org/install.html. ^[23] Try to follow those instructions, and when they are not sufficient, then please ask at the Nim forum for help: https://forum.nim-lang.org/

If you are using a Linux operating system, then your system usually provides a package manager, which should make the installation very easy.

For example, for a Gentoo Linux system, you would open a root terminal and simply type emerge -av nim. That command would install Nim, including all necessary dependencies, for you. It may take a few minutes as Gentoo compiles all packages fresh from source code, but then you are done. Similar commands exist for most other Linux distributions. This installation by a package manager installs Nim system-wide, so all users of the computer can now use Nim.

Another solution, which is preferable when you want to ensure that you get the most recent Nim compiler, is compiling directly from the latest git sources. That process is also easy and is described here: https://github.com/nim-lang/Nim. But before you can follow those instructions, you have to ensure that the git software and a working C compiler are available on your computer.

Nim source code, as most source code of other programming languages, is based on text files. Text files are documents saved on your computer that contain only ordinary letters, which you can type on your keyboard. No images or videos, no HTML content with fancy CSS styling. Generally, source code should contain only ordinary ASCII text, that is, no umlauts or Unicode characters.

To create source code, we typically use a text editor, which is a tool designed for creating and modifying plain text files. If you do not have a text editor yet, you may also use a word processor for writing some source code, but then you have to ensure that the file is finally saved as plain ASCII text. Editors typically support syntax highlighting, that is keywords, numbers, and such are displayed with a unique color or style to make it easier to recognize the content. Some editors support advanced features like checking for errors while you type the program source code.

A list of recommended editors is available at https://nim-lang.org/faq.html

If you do not want to use a special editor now, then for Linux Gedit or at least Nano should be available. For Windows, maybe something like Notepad.

Typically, we store our Nim source code files in their own directory, which is a separate section of your hard disk. If you work on Linux in a terminal window, then you can type

You type these commands in the terminal window and press the return key after each of the above lines — that is, you type cd on your keyboard and then press the return key to execute that command. The same for the next three commands. What you have done is this: you went to your default working area (home directory), then created a subarea named mynimfiles, then you went into that subarea, and finally you launched the gedit editor — the argument test.nim tells gedit that you want to create a new file called test.nim. If gedit is not available, or if you work on a computer without a graphical user interface, then you may replace the gedit command with nano. While gedit opens a new window with a graphical interface, nano opens only a very simple interface in the current terminal. An interesting editor without a GUI is Vim or NeoVim. That is a very powerful editor, but it is difficult to learn, and it is a bit strange as you have a command mode and an ordinary text input mode available. For NeoVim there is very good Nim support available.

If you do not want to work from a terminal, or if you are using Windows or macOS, then you should have a graphical user interface that enables you also to create a directory and launch an editor.

When the editor is opened, you can type in the Nim source code from our previous example and save it to a file named test.nim. Then you can terminate the editor.

Note that the return key behaves differently in editors than in the terminal window: In the terminal window, you type in a command and finally press the return key to "launch" or execute the command. In an editor, the return key is not that special: if you press ordinary keys in your editor, then that key is inserted and the cursor moves one position to the right. And when you press the return key, then an invisible newline character is inserted and the cursor moves to the start of the next line.

If you are working from a Linux terminal, then you can type

That is, you first show the content of your directory with the ls command, and then display the content of the Nim source code file that you just have typed in with the cat command.

Now type

That invokes the Nim compiler and instructs it to compile your source code. The "c" letter is called an option or a sub-command, it tells the Nim compiler to compile your program and to use the C backend to generate an executable.

The compiler should display nearly immediately a success message. If it displays some error messages instead, then you launch Gedit or Nano again, fix your typing error, save the modified file and call the compiler again.

Finally, when the source text is successfully compiled, you can run your program by typing

In your terminal window, you see a number now, which is the sum of the numbers 1 to 100.

If you have not managed to open a terminal where you can invoke the compiler — well, maybe then you should install some advanced editors like VS-Code. They should be able to launch the compiler and run the program from within the editor directly.

The command

is the most basic compiler invocation. The extension .nim is optional, the compiler can infer that file extension. This command compiles our program in default debug mode, it uses the C compiler back end and generates a native executable. Debug mode means that the generated executable contains a lot of checks, like array index checks, range checks, nil dereference checks, and many more. The generated executable will run not very fast, and it will be large, but when your program has bugs, then the program will give you a meaningful error message in most cases. Only after you have tested your program carefully, you may consider compiling it without debug mode. You may do that with

The compiler option -d:release removes most checks and debugging code and enables the backend optimization by passing the option "-O3" to the C compiler backend, giving a very fast and small executable file. The option -d:danger removes all checks, it includes -d:release. You should be aware that compiling with -d:danger means that your program may crash without any useful information, or even worse, may run, but contain uncatched errors like overflows and so may give you wrong results. Generally, you should compile your program with plain nim c first. When you have tested it well, and you may need the additional performance, you may switch to -d:release option. For games, benchmarks, or other uncritical stuff, you may try -d:danger.

There exist many more compiler options, you can find them explained in the Nim manual, or you may use the command nim --help and nim --fullhelp to get them displayed. One important new option is --gc:arc to enable the new deterministic memory management. You may combine --gc:arc with -d:useMalloc to disable Nim’s own memory allocator, this reduces the executable size and enables the use of Valgrind to detect memory leaks. Similar to --gc:arc is the option --gc:orc, which can deal with cyclic data structures. Finally, a very powerful option is --passC:-flto. This option is for the C compiler backend and enables link time optimization (LTO). LTO enables inlining for all procedure calls and can significantly reduce the final program size. For a recent Nim compiler version, instead of --passC:-flto also -d:lto can be used. We should mention that you can also try the C++ compiler backend with the cpp sub-command instead of the plain c command, and that you may compile with the CLang backend instead of the default GCC backend with the --cc:clang option. You can additionally specify the option -r to immediately run the program after a successful build. For testing small scripts, the compiler invocation in the form nim r myfile.nim can be used to compile and run a program without the generation of a permanent executable file. Here is an example of how we use all these options:

In this example, we additionally pass -march=native to the C compiler backend to enable the use of the most efficient CPU instructions of our computer, which may result in an executable that will not run on older hardware. Of course, we can save all these parameters in configuration files, so that we don’t have to actually type them for each compiler invocation. You may find more explanations for all the compiler options in the Nim manual, or in later sections of this book, this includes the options for the JavaScript backend.

We can declare constants, variables, procedures, or our custom data types. Declarations are used to give information to the compiler, for example, about the name and data type of a variable that we intend to use.

We will explain the type and procedure declarations in later sections. Currently, only constant and variable declarations are important.

A constant declaration in its simplest form maps a symbolic name to a value, like

We use the reserved word const to tell the compiler that we want to declare a constant which we have named Pi, and we assign it the numeric decimal value 3.1415. Nim has a small set of reserved words like var, const, proc, while, and others, to tell the compiler that we want to declare a variable, a constant, a procedure, or that we want to use a while loop for some repeated code execution. Reserved words in Nim are special symbols that have a special meaning for the compiler, and we should avoid using these symbols as names for other entities like variables, constants, or functions, as that would confuse the compiler. The = is the assignment operator in Nim, it assigns the value or expression on the right side of it to the symbol on the left. You have to understand that it is different from the equal sign we may use in mathematics to express an equality relation. Some languages like Pascal initially used the compound operator := for assignments, but that is not easy to type on the keyboard and looks a bit angry for sensible people. And source code usually contains a lot of assignments, so the use of = makes some sense. For the actual equality test of two entities, which is not used that often, we use the compound == operator in Nim, as in most other programming languages including C and Python. We call = an operator. Operators are symbols that perform some basic operation, like + for the addition of two numbers, or = for the assignment of a value to a symbol. Most operators are used as infix operators in between two arguments, as in the expression 2 * Pi to denote the multiplication of the constant Pi with the literal number 2, resulting in the floating-point value 6.29. But operators can also be used as unitary operators, like in -Pi to invert the sign of a numeric value. When we declare named constants, we must always assign a value immediately. That value can never change, but of course, we can use the named constant in expressions to create different values as in

We mentioned in part I of the book already, that we usually put a space on both sides of an operator when we use it in an infix notation between two operands, but this is only a convention to improve the readability of the source code. We also mentioned that in Nim spaces can in some cases change the interpretation of expression: Nim follows the traditional notations of handwritten text, e.g a + -b is very different from a+-b. We will discuss these notations in later sections of the book in more detail.

With the above constant declaration, we can use the symbol Pi in our program’s source code and don’t have to remember or retype the exact sequence of digits. Using named constants like our Pi above makes it easy to modify the value — if we notice that we need more precision, we can look up the exact value of Pi and change the constant declaration at one place in our source code, we don’t have to search for the digit sequence 3.14 in all our source code files.

For numeric constants like our Pi value, the compiler will do a substitution in the source code when the program is compiled, so where we write the symbol Pi the actual numeric value is used.

For constant declarations, it must be possible to determine its value at compile time. Expressions assigned to constants can contain simple operations like basic math, but some function calls may not be allowed.

Variable declarations are more complicated, as we ask the compiler to reserve a named storage location for us:

Here we put the reserved keyword var at the beginning of the line to tell the compiler that we want to declare a variable, then we give our chosen name for that variable followed by a colon and the data type of the variable. The int type is a predefined numeric data type indicating a signed integer. The storage capacity of an integer variable depends on the operating system of your computer. On 32-bit systems, 32 bits are used, and on 64-bit systems, 64 bits are used to store one single integer variable. That is enough for even large signed integer numbers: the range is -2^31 up to 2^31 - 1 for 32-bit systems and -2^63 up to 2^63 - 1 for 64-bit systems.

For variables, we generally use lower case names, but names of constants may start with an upper case letter.

Variables declared by use of the var keyword are some form of a simple container, they store a value, which we can access or change later. We can assign to the variable immediately an initial value when we declare it, in a similar way as we have to do it for constants, or we assign the value later. As long as we do not assign an actual value, the variable has the default value, which is zero for numeric variables:

In lines one and two, we declare two variables called start and stop, which initially have the default integer value zero. In line three, we declare a different integer variable called delta, to which we assign an initial value 3. And finally, in line four, we assign to variable stop an integer expression. For variable declarations Nim offers some more variants, which we will discuss soon: We can use type inference, when we immediately assign an initial value, we can use var sections to introduce multiple variables without the need to type the var keyword multiple times, we can list multiple names of the same data type in front of the colon separated by commas, or we may use the let keyword to declare immutable variables.

Statements, or instructions, are a core component of Nim programs: they tell the computer what it shall do. Often statements are procedure calls, like the call of the echo() or inc() procedure, which we have already seen in part I of the book. We will learn what procedures exactly are in later sections. For now, we just regard procedures as entities that perform a well-defined task for us when we call (or invoke) them. We call them by just writing their name in our source code file, followed by a list of parameters, also called arguments. When we write echo 7 then echo is the procedure which we call, and 7 is the argument, an integer literal in this case. When the parameter list has more than one argument, then we separate the arguments with a comma each, and generally, we put an optional space after that comma. The effect of our procedure call is that the decimal number 7 is written to the terminal when we run the program after compilation. While in languages like C the parameter list has to be always enclosed in brackets, in Nim we can frequently leave the brackets out, which is called command invocation syntax.

The command invocation syntax is often used with the echo() procedure, or when a procedure has only one single argument. For multiple arguments, or when the argument is a complicated expression, the use of brackets may be preferable. Some coding styles of other programming languages, like C, sometimes put a space between the procedure name and the opening bracket. For Nim, we should not do that, the reason will become clear when we later explain the tuple data type. A few procedures have no parameters at all. When we call these functions, we have to use always the syntax myProc() with an empty pair of brackets, to make it for the compiler clear that we want to call that function. res = myProc() assigns the result of the proc call to res, while res = myProc would assign the proc itself to res, which is very different.

A special form of procedures are functions, which are procedures that perform operations to return a value or a result. In mathematics, sin() or cos() would be functions — we pass an angle as an argument and get the sine, or cosine as a result.

Let’s look at this minimal Nim program:

The Nim program above consists of a variable declaration and three statements: in the first line, we declare the variable we want to use. In the next line, we assign the value 2 + 3 to it, and finally, in line 3 we use the procedure echo() to display the content of our variable in the terminal window. In the last line, we use again the echo procedure with an ordinary parameter list enclosed in brackets. The parameter list has only one parameter, which is the sum of a function call and the literal value 2. Here the compiler would first call cos(0) and then add the literal value 2 to that result before finally the sum is passed to the echo proc to print the value.^[24]

Nim programs are generally processed from top to bottom by the compiler, and when we execute the program after successful compilation, then it also executes from top to button. A consequence of this is that we have to write the lines of the above program exactly in that order. If we moved the variable declaration down, then the compiler would complain about an undeclared variable because the variable is used before it has been declared. If we exchanged lines 2 and 3, then the compiler would be still satisfied, and we would be able to compile and run the program. But we would get a very different result because we would first try to display the value of variable a, and later assign a value to it.

When we have to declare multiple constants or variables, then we can use a block, that is we write the keyword var or const on its own line, followed by the actual declarations like in

These blocks are also called sections, e.g. const section or var section, as known from the wirthian languages. Note the indentation — the lines after const and var start with some space characters, so they build a block that allows the compiler to detect where the declaration ends. Typically, we use two spaces for each level of indentation. Other numbers would work also, but the indentation scheme should be consistent. Two spaces are the general recommendation, as it is clearly recognizable for humans in the source code, and because it doesn’t waste too much space, that is, it would not generate long lines which may not fit onto the screen.

Also note, that in Nim we generally write each statement onto its own line. The line break indicates to the compiler that the statement has ended. There are a few exceptions — long mathematical expressions can continue on the next line (see the Nim manual for details). We can also put multiple statements on a single line when we separate them by a semicolon:

We can also declare multiple variables of the same type in one single declaration, like

or we can assign an initial start value to a variable like in

Currently, Nim allows also to initialize multiple variables with the same value:

Here, i and j would both get the initial value 1. Most people avoid this notation, as it is not that clear.

Finally, for variable declarations we can use type inference when we assign an initial start value, that is we can write

The compiler recognizes in this case that we assign an integer literal to that variable, and so silently gives the variable the int type for us. Type inference can be comfortable but may make it harder for readers to understand the code, or the type inference may not always do exactly what we want. For example, in the above code, year gets the data type int, which is a signed 4 or 8-byte number. But maybe we would prefer an unsigned number or a number that occupies only two bytes in memory. So use type inference with some caution.

Note: For integral data, we mostly use the int data type in Nim, which is a signed type with a 4 or 8-byte size. It usually does not make sense to use many different integral types — signed, unsigned, and types of different byte sizes. Mixing them in numerical expressions can be confusing and potentially even decrease performance, because the computer may have to do type conversion before it can do the math operation. For unsigned types, another problem is that math operations on unsigned operands could have a negative result. Consider the following example, where we use a hypothetical data type "unsigned int" to indicate unsigned integers:

The true result would be -4, but a is of unsigned type and can never contain negative content. So what should happen — an incorrect result or a program termination?

Related to variable declarations is the initial start value of variables. Nim clears for us all the bits of our variables when we declare them, that is, numbers always get the initial start value of zero if we do not assign a different value in the variable declaration.

In this declaration

both variables get the initial value of zero.

There exists a variant for variable declarations which uses the let keyword instead of the var keyword. Let is used when we need a variable that only once gets a value assigned, while var is used when we want to change the content of the variable during program execution. Let seems to be similar to const, but in const declarations, we can use only values that are known at compile time. Let allows us to assign to variables values that are only available at program run time, maybe because the value is a result of a prior calculation. But let indicates, at the same time, that the assignment occurs only once, the content does not change later, during the program’s execution. We say that the variable is immutable. The use of the let keyword may help the human reader of the source code with understanding what is going on, and it may also help the compiler doing optimizations to get faster, or more compact code. For now, we can just ignore let declarations and use var instead — later, we may use let where appropriate, and the compiler will tell us when let will not work, and we have to use var.

With what we have learned in this section, we can rewrite our initial Nim example from part I in this form:

In the code above, we declare both variables of type int in a single line and take advantage of the fact that the compiler will initialize them with 0 for us. And we use a named constant for the upper loop boundary. Another tiny fix is that we write inc(i) instead of inc(i, 1). We can do that because there exist multiple procedures with the name inc() — one which takes two arguments, and one which takes only one argument and always increases that argument by one. Procedures with the same name, but different parameter lists, are called overloaded procedures. Instead of inc(i) we could have written also i = i + 1 and instead of inc(sum, i) we could write sum = sum + i. That would generate identical code in the executable, so we can use whatever we like better.

We have already used the echo() procedure for displaying textual output in the terminal window. In the code examples of the previous sections, we always passed arguments of integer type to the echo() proc, and the echo() proc automatically converted the integer numbers to a textual sequence of decimal digits so that we could read it in the terminal. In the Nim programming language, text is a predefined, built-in data type that is called string. We will learn all the details of the string data type in the next section, for now, it is sufficient that it exists and that we can use the echo() proc to print text strings. The echo() proc has the ability to convert other data types like numbers or the boolean data type (true/false) automatically to human-readable text strings, so that we can read the output in the terminal. Recall that most data types are stored internally in our computer as bits and bytes, which have no true human-readable representation by default. Numbers, like most other data types stored in the computer, are actual abstract entities. We have learned already that all data in the computer is internally stored in binary form, that is, as a bit pattern of 0 and 1. But even that bit pattern is still an abstraction, we would require a procedure that prints a 0 for each unset bit and a 1 for each set bit to display the content of an internally stored number in binary form in the terminal or elsewhere. In the same way, we require a procedure to print an internally stored number as a human-readable sequence of decimal digits. Even text strings are internally stored as abstract bit patterns, and we need conversion procs to print the content for us as ordinary text. All that can be done by the echo() proc, but we do not care for the actual details at this point of the book.

For our further experiments, we may also want to be able to enter some user data in the terminal. As we do not know much about the various available data types and the procs that can be used to read them in, we will just present a procedure that can read in a text string that the user has typed in the terminal window. We use a function with the name readLine() for this task.

Note that you have to press the return key after you have entered your text.

The first line of our program shows how we can print a text literal string with the echo() proc. To mark text literals unambiguously and to separate them from other literals like numeric literals or from variables, the string literals have to be enclosed in quotation marks. In the second line of our example program, we use the readLine() function to read textual user input. Note that we call readLine() a function, not a procedure, to emphasize that it returns a value. The readLine() function needs one parameter to know from where it should read — from the terminal window or from a file, for example. The stdin parameter indicates that it should read from the current terminal window — stdin is a global variable of the system (io) module and indicates the standard input stream. Finally, in line 3 we use again the echo() procedure to print some text. In this case, we pass two arguments to echo(), a literal text enclosed in quotes, and then separated by a comma, the mytext variable. The mytext variable has the data type string. We used type inference in this example to declare that data type: the readLine() procedure always returns a string, the compiler knows that, so our mytext variable is automatically declared with type string. We will learn more about the data type string and other useful predefined data types in the next section.

When you try the example code from above, you may want a variant of it that does read in the textual input not on its own line, but directly after the prompt like "What is your name: Nimrod". As the echo proc always writes a newline character after the last argument has been written, we have to use a different function to get the input prompt on the same line. We can use the write() proc from the system module for this. As write() can not only write to the terminal, but also to files, it needs an additional parameter that specifies the destination. We can pass the variable stdout from the system module to indicate that write() should write to our terminal window. Another desire of beginners is, generally, to have the ability to read single character input without the need to press additional the return key. For that, we can use the getch() function from the terminal module — that function waits (blocks) until a key is pressed and returns the ASCII character of the pressed key:

Don’t get confused by the fact that the first write() call and the following readline() call does not appear on the same line in our example. The actual format of our source code does in this case not influence the program output. We could write both function calls on a single line, separated by a semicolon. But that would make no difference for the program output. The significant difference beteen the code above is just, that write() prints the text, but does not move the cursor in the terminal window to the next line, while echo() moves the cursor to the next line when all arguments have been printed. We say that echo() prints automatically a '\n' character, which we call a newline character, after all the arguments have been printed.

Nim is a statically typed programming language, which indicates that all variables have a well-defined data type, and this data type does not change during program execution. Further, we say that Nim is a strongly typed language, which means that Nim does nearly no automatic type conversions when variables are assigned to each other or are used in expressions or as arguments in function calls. Automatic type conversion may appear nice at first, but it can easily introduce errors or decrease the performance of our programs.

The most fundamental data type — in real life and in computer science — are integer (whole) numbers. All other numeric data types, like fractional, floating-point, or complex numbers, and other fundamental types like the boolean type with its two values true and false, or character and text string types, can be represented as integers. For that reason, the early computers built in the 1950s as well as today’s tiniest microcontrollers work internally only with integer numbers. The integer data type is not only very important for arithmetic operations, but is also used as an index to access elements in containers like arrays, and the integer numbers are often interpreted as bit vectors to represent set-like data types. As all CPUs are able to do basic bit operations like setting or clearing individual bits, and as bit patterns map well to mathematical sets, set data types are well-supported by all CPUs, and so set operations are generally very efficient. Advanced computers built in the 1980s got support for the important class of floating-point numbers by special floating-point processors for fast numerical computations. These floating-point units are today typically integrated into the CPU, and GPUs can even process many floating-point operations in parallel, where the precision is typically restricted to ranges needed for games and graphics animation, that is 32 or even 16 bit. Modern CPUs have often also some form of support for vector data types to process multiple values in one instruction (SIMD, single instruction, multiple data).

None numeric types like characters or text strings are internally represented by integer numbers — in the C language the data type to present text strings is called char, but it is indeed only an 8-bit integer type that supports all the mathematical operations defined for ordinary integer types. In Nim and the wirthian languages, most math operations are not directly allowed for the char data type, which should prevent misuse and allows catching logical errors by the compiler.

Nim supports also some built-in homogeneous container types like arrays and sequences, and many built-in derived types like enumeration types, sub-ranges and slices, distinct types, and view types (experimental). The built-in inhomogeneous container types object and tuple, which allow grouping other types, are supported by a variant type container, which allows instances of that type to contain different child types at runtime. These inhomogeneous container types are similar to the struct and union types from the C programming language.

Other basic and advanced data types like complex and fractional numbers, types with arbitrary-precision arithmetic as well as hash sets and hash tables, dynamically linked list or tree structures are available through the Nim standard library or external packages. And of course, we are able to define our own custom data types with our own operators, functions, and procedures working on them.

Note that all the data types that are built into the language, like the primitive types int, float, or char, as well as the built-in container types like tuple, object, seq, and string, are written in lower case, while data types that are defined by the Nim standard library or that we define our self, by convention, starts with a capital letter like the CountTables type defined in the tables module. Some people may regard this as an inconsistency, others may say that in this way we can differentiate built-in types from types defined by libraries. At least we may agree that using capital notation for common types as in Int, Float, or String would be more difficult to type and would look not that nice.

You have already seen a few examples of simple Nim source code. The code is basically a plain text file consisting of ASCII characters, that is, the ordinary characters that you can type on your keyboard. Generally, Nim source code can also contain Unicode utf-8 characters, so instead of using names consisting of ASCII characters for your symbol names, you could just use single Unicode characters or sequences of Unicode characters. But typically that makes not much sense, entering Unicode is not that easy with a keyboard, and it is displayed only correctly on the screen or in the terminal when the editor or terminal supports Unicode properly and when all necessary fonts are installed. That may be the case for your local computer, but what when someone others may edit your source code?

Starting with Nim version 1.6, we got some support for Unicode operators, which may be useful for some applications. For details, please see the Nim compiler manual.

Nim currently does not allow inserting tabular characters (tabs) in your source code, so you have to do the indentation of blocks by spaces only. Typically, we use two spaces for each indentation level. Other numbers work also, but you should stick to a fixed value.

Names in Nim, as used for modules, variables, constants, procedures, user-defined types, and other symbols, may contain lower and upper case letters, digits, Unicode characters, and additional underscores. But the names are not allowed to start with digits or to start or end with an underscore, and one underscore may not follow directly after another underscore.

Generally, we use camel-case like leftMargin for variable names, not snake-case like left_margin.

Current Nim has the special property that names are case-insensitive and that underscores are simply ignored by the compiler. The only exception is the first letter of a name, that letter is case-sensitive. So the names leftMargin, leftmargin, and left_margin are identical for the compiler. But LeftMargin is different from all the others because it starts with a capital letter. This may sound a bit strange at first but works well in practice. One advantage is, that a library author may use snake_case in his library for names, but the users of the library can freely decide if they prefer camelCase. But still, you may think that all this generates confusion. In practice, it does not, it prevents confusion. Imagine a conventional programming language, fully case-sensitive and not ignoring underscores: In a larger program, we may then have names like nextIteration and next_Iteration or keymap and keyMap. What when both names are visible in the current scope, and we type the wrong one. The compiler may not detect it when types match, but the program may do strange things. Nim would not allow that similar-looking names, as the compiler would regard them as identical and would complain about a name redefinition.

You may ask why the first letter is case-sensitive. That is to allow for user-defined types to use capital type names and then write something like var window: Window. So we can declare a variable named window of a user-defined data type named Window. That is a common practice.

The case-insensitivity and the ignoring of underscores may not be the greatest invention of Nim, but it does not really hurt. The only exception is when we make bindings to C libraries, where leading or trailing underscores are used, which can make some renamings necessary.

The only minor disadvantage of Nim’s fuzzy names is when you use tools like grep or your editor search functionality: You could not be sure if a search for "KdTree" would give you all results, you would have to try "Kd_Tree" or "KDTree" and potentially some more variants too. For that task, Nim provides a tool called nimgrep that does a case- and style-insensitive search. And possibly your editor supports that type of search also. You can also enforce a consistent naming scheme when you call the compiler with the command line argument --styleCheck:error or --styleCheck:hint.

Larger computer programs generally consist not only of code that is executed linearly but contain code for conditional or repeated execution.

The most important control structures of Nim are the if statement for conditional execution, the related case statement, and the while and for loops for repetitions. All these statements control the actual program execution at program runtime. Syntactically very similar to the if statement is Nim’s when statement, which is already evaluated at compile-time, and can be used to adapt our program code for various operating systems or to compile our code with special options, e.g. for debugging or testing purposes.

All these control structures can be nested in arbitrary ways, so we can have in one if branch other if conditions or while loops, and in while loops again other control structures including other loops.

We have worked with basic data types like numbers, characters, and strings already. Often it makes sense to join some variables of these basic data types to more complex entities. Assume you want to build an online store to sell computers, and you want to build a database for them. The database should contain the most important data of each device type, like the type of CPU, RAM and SSD size, power consumption, manufacturer, quantity available, and actual selling price.

We can create a custom object data type with fields containing the desired data for this purpose:

In the first line, we use the type keyword to tell the compiler that we want to define a new custom type. Writing the type keyword on its own line begins a type section where we can declare one or more custom data types. All type declarations in a type section must be indented. In the next line, we write our type name, an equal sign, and the keyword object. That indicates that we want to declare a new object type named Computer. Here Computer is a type name, in Nim we use the convention that user defined type names start with a capital letter. In the following indented block we specify the desired fields of this object, each line contains the name of a field, and a colon followed by the needed data type. That is similar to a plain variable declaration.

Objects in Nim are similar to structs in C. Unlike classes in Java, Nim objects contain only the fields, sometimes also called member variables, but no procedures, functions, or methods, and no initializers or destructors as in C++. In Nim, we keep the data objects, and the procedures, functions, methods, and also optional initializers and destructors that work with that data objects, separated.

Now, that we have defined our own new object type, we can declare variables of that type and store content in its fields.

Of course, in real applications, we would fill the fields not in this way, but we would maybe read the data from a file, from a terminal, or maybe from a graphical user interface.

It may look a bit ugly that we have to write computer. before each field when we access the fields. Indeed, in recent Nim versions that is not necessary, you may use the with construct now instead.

We can use the fields like ordinary variables:

As you already know, the right side of the assignment operator is evaluated first, then the result is stored in the variable on the left side. But we can also just write computer.quantity -= 1 or dec(computer.quantity).

Objects, like all other data types that we have already used, are value types, which means that when an object is assigned to a new variable, all its components are copied as well. In this way, objects behave like strings — assignment copies the content, and the entities remain independent of each other. We will learn about reference types soon, which behave differently.

To initialize object variables, we can use the object type names as a constructor with a syntax like Foo(field: value, …​). Unspecified fields get the field type’s default values:

To initialize the variable computer1 we used the constructor syntax. In line five, we use the assignment operator to copy the content of variable computer1 into variable comp2, and finally, we overwrite the price field of comp2. As both variables are distinct instances, the fields of variable computer1 are not modified this way.

Typically, a computer store would offer many different types of computers, so it would make sense to store all the different devices in a container like a sequence, called short seq in Nim. In the next section, we will learn how we can do that.

Sequences and arrays are homogeneous containers, they can contain multiple other elements of the same data type, while a plain variable like a float or an int only contains a single value. In some way, we could regard objects also as containers, because objects contain multiple fields. The same holds for tuples — tuples are a very simple, restricted form of objects and also contain fields. But more typical container data types are the built-in arrays and sequences, or for example, hash tables, which are provided by the Nim standard library. Arrays, sequences, and hash tables can contain multiple elements, but all elements must have the same data type, which we call the base type.^[34] The data type of the base type is not restricted, it can be even again array or sequence types, so we can build multidimensional matrices in this way. Arrays have a fixed, predefined size, they can not grow or shrink during the runtime of our program. Sequences and hash tables can grow and shrink.

Arrays and sequences appear very similar, a sequence appears even more powerful because it can change its size, that is the number of elements that it contains, at runtime, while an array has a fixed size. So why do we have arrays at all? The reason is mostly efficiency and performance. An array is a plain block of memory in the RAM of the computer, which can be accessed very fast and needs not much care by the runtime system. Sequences take much more effort, especially when we add elements and the sequence has to grow. When we create sequences, we can specify how many elements should fit in it at least, and the runtime system reserves a block of RAM of the appropriate size. But when our estimation was too small, and we want to append or insert even more elements, then the runtime system may have to allocate a larger block of memory first, copy the already existing elements to the new location, and then release the old, now unnecessary memory block. And this is a relatively slow operation. The reason why this process can be necessary is, that the initially allocated memory block may not increase in size because the neighborhood in the RAM is already occupied by other data. Now, let us see what we can do with arrays and sequences:

In the second line of the code above, we declare a variable named a of array type — we want to use an array with exactly 8 elements, and each element should have the data type int. To declare a variable of array data type we use the array keyword followed in square brackets by the number of the elements, and separated by a comma, the data type of the elements. We can also specify the range of the indices explicitly by specifying a range like array[0 .. 7, int] or array[-4 .. 3, int]. The first specification is identical to the one in the above example program, and the second one would allow us to access array elements with index positions from -4 up to 3.^[35] or [int, 8]. It may help to remember that for plain variables the data type comes last also like in var i: int.]

The first for loop of the above program fills our array — that is, for each of the 8 storage places in the array, we fill in some well-defined data. We use the mitems() iterator here because we want to modify the content of our array — we fill in numbers 1 .. 8. In the next for loop, we square each storage location, and finally, we print the content. In the last for loop, we do not modify the content, so a plain items() instead of mitems() would work, but we already learned that we have not to write the plain items() at all in this case.

Sequences work very similar to arrays, but they can grow:

We start with an empty seq here, and use the add() procedure to append elements. After that, we can iterate over the seq as we did for the array.

In the same way, as we access single characters of a string with the subscript operator [], we can use that operator to access single elements of an array or a seq, like in a[myPos]. The slice operator is available for arrays and sequences too and can be used to extract sub-ranges or to replace multiple elements. As arrays have a fixed length, the slice operator can only replace elements in arrays, but not remove or insert ranges. The first element position is generally 0 for arrays and sequences. Arrays can even be defined in a way that the index position starts with an arbitrary value, but that is not used that often. Whenever you use the subscript or slice operator, you have to ensure that you access only valid positions, that is, positions that really exist. a[8] or s[8] would be invalid in our above example — the array has only places numbered 0 .. 7, and for the seq, we have added 8 values which now occupy positions 0 .. 7 also, position 8 in the seq is still undefined. We would get a runtime error if we would try to access position 8 or above, as well, when we would try to access negative positions. You might think that an assignment for a seq like s[s.length] = 9 is the same as s.add(9), but only the add() operation works in this case.

Note that in some languages like Julia arrays start at position 1.^[36] Nim arrays can have an arbitrary integral start position, including negative start positions, but the start position as well as the highest subscript position are determined in the program source code and can not change at runtime. We say that arrays have fixed compile-time bounds. Sequences always start at position 0, we can specify an initial size, and we can always add more elements at runtime.

Arrays and sequences allow fast access to its elements: All the elements are stored in a contiguous memory block in RAM, and the start location of that memory block is well-known. As all the elements have the same byte size, it is an easy operation to find the memory location of each element. The compiler uses the start location of the array or seq, and adds the product of subscript index and element byte size. The result is the memory location of the desired element, which was selected by the index used in the subscript operator. When the array should not start at position 0, then the compiler would have to adjust the index, by subtraction of the well-known start index. This operation takes not much time, but still arrays starting at position 0 may be a bit faster. We said that the compiler has to do a multiplication of index position and element size — that is an integer multiplication, which is very fast. When the element size is a power of two, then the compiler can even optimize the multiplication by using a simple shift operation, which may be even faster, depending on your CPU.

It should be not surprising that the internal structure of sequences is a bit more involved than arrays. Arrays are indeed nothing more than a block of memory, generally allocated on the stack for local data, or allocated in the BSS segment for global data. Don’t worry when you have not yet an idea what the stack, the heap, and a BSS segment are, we will learn that soon. The Nim seq data type has a variable size, so it is clear that it needs not only a storage location for its elements, but also a counter to store how many elements it currently contains, and another counter for how many it could contain at most. The element counter must be updated when we add or delete elements, and when the counter tells that there is currently no more space available for more elements, then a new block of memory must be allocated, and the existing elements must be copied from the old location into the newly allocated memory region before the old memory region can be released.^[37] Due to this additional effort appending elements to a seq by using the add() procedure is not extremely fast. You may wonder why we have not to save a size information for arrays. Well arrays have fixed sizes, so it is obvious that we never have to adjust something like a size counter, simple because the size would never change. But would we have to save the desired initial size of the array? Well, in some way yes. But it is a constant value. During the compile process, the compiler can catch some errors already for us — when we have an array as above with size 8, then the compiler would be able already at compile time to recognize some invalid access to array elements — a[9] would be a compile-time error for sure. But at runtime, when we execute our program, access to not existing index position may occur, for example, by constructs like var i = 9; a[i] = 1 when the array is declared as var a: array[8, int]. For catching that type of error, the compiler has to store the fixed array size somewhere and check against that value when an array access by using the subscript operator with a non-constant argument occurs, as the a[i] above. One related remark: Accessing array elements is as fast as ordinary variable access when we use a constant value as index, that is a constant literal or a named constant. The reason for this is, that when the index is a constant, then the compiler just knows the exact position of that array element in memory, just as it knows the address of plain variables, so there is no need for address calculations at runtime. Actually, to access an array element with a given constant index position, the compiler only has to add a constant value to the current stack pointer, as arrays are stored on the stack. To access a constant position in a seq, the compiler would have to add a constant to the base address of the memory block that contains the seq data.

We said that appending elements to sequences is not extremely fast — indeed, it is a few times slower than access to an array element by its index using the subscript operator. So when we know that our seq will have to contain at least an initial amount of elements, then it can be useful for maximum performance, that we allocate the seq from the beginning for this size and then fill in the content by use of the subscript operator instead that we append all the elements one by one. Here is one example:

We use the newSeq() procedure to initialize the sequence for us, the content of the square brackets tells the newSeq() procedure that we want a sequence with base type int, and the number 8 as an argument tells it that the newly created sequence should have 8 elements with the default value (0). This procedure is a so-called generic procedure, it needs additional information, which is the data type that the elements should have. Don’t confuse the square bracket in the newSeq[int]() call with the subscript operator a[i] which we have used for array access, both are completely unrelated. Note that the initialization of the seq above does not restrict its use in any way, we can still use it like an uninitialized seq, that is we can use the add() operator to add more elements, we can insert or delete elements, and all that.

Deleting elements from an array or from a sequence can be very slow.^[38] It is slow when we use the naive approach and move all the elements located after the element that should be removed one position forward. This would obtain the order in the container, so sometimes this is the only solution, but of course moving all the entries is expensive for large containers. Nim’s standard library provides the delete() function for this order maintaining delete operation. A much faster way to delete an entry in a seq or array is to remove the last entry and replace the one that should be deleted with that last entry. This operation moves the last entry to the front, so the order of elements is not maintained. Nim’s standard library provides the del() function for this faster, but order changing delete operation. Of course, whenever the order is not important, we should use del(). The delete() and del() functions are actually only available for sequences, as arrays have a fixed size — but in principle, we could do similar operations with arrays as well, we have just to store the actual used size somewhere. ^[39]

Nim slices are objects of type Slice with two fields, a lower bound a and an upper bound b. The system module also defines the HSlice object, called heterogeneous slice, for which the lower and upper bound can have different data types:

As the Slice and HSlice objects are not built-in types, their names start with capital letters. Slices are not used that often directly, but mostly indirectly with the .. range operator, e.g. to access sub-ranges of strings and other containers.

One example of its direct use from the system module is

Slices are used by functions of the standard library or by user-defined functions to access sub-ranges of strings, arrays, and sequences. Typically, we do not use an explicit Slice object, but we create the Slice by use of the infix .. operator, which takes two integers and returns a Slice with these bounds:

Applied to container data types, slices look syntactically like sub-ranges:

In line two we use the slice to replace the sub-string "is difficult.", which starts at position 19, with another string. Note that the replacement can be a longer or a shorter string, that is, the slice supports not only overwriting characters but also inserting or deleting operations. In line two, the actual Slice object is constructed by the .. operator and the two integer bounds. In line four, we use the slice to access a sub-string and create a new string with it. As we learned earlier in the Strings section already, we can use the ^ operator to access elements counted from the end of the container, so we could have written line two also as m[19 .. ^1] = "not easy.". The last two lines in the above example show that we could have used a real HSlice object to access the sub-string instead.

Slices can be used in a similar way for arrays, strings, and sequences. But we have to remember that Slices are only objects with a lower and an upper bound, so there must be always a procedure that accepts the container and the Slice as arguments to do the real work.

When we care for utmost performance, then we have to be a bit careful with Slices, as the use of Slices can generate copies. Consider this example:

Here, we use the slice construction operator .. to exclude the first element from our summing operation. Unfortunately, when we use the slice operation in this way, the Nim compiler may create a copy of our sequence, which increases the run-time and memory consumption. At least for Nim versions up to 1.6, this was the case, never versions may use view types instead to avoid the copy. We may try to use the new toOpenArray() expression and try a construct like

but that does currently not compile.

One option is currently that we create a custom iterator like

and use

Or we may do the summing in a procedure and pass that proc an openArray created with toOpenArray() like

But this is a work in progress, so the situation may improve, see

+ https://forum.nim-lang.org/t/4823

+ https://forum.nim-lang.org/t/4582#28715

We have already used different types of variables — integers, floats, characters, the custom Computer object, and some more. We said that variables are named memory regions, where the content of our variables is stored. We call these types of variables also value types.

Value types always imply copies when we do an assignment:

Here we have 3 assignments, first, we assign the integer literal 7 to the variable i, then we assign the content of variable i to variable j, and finally, we overwrite the old content of variable i with the new literal value 3. The output of the echo() statement should be 3 and 7, because in line 3 we copy the content of variable i, which is currently the value 7, into variable j. The new assignment in line 4 in no way touches the content of variable j.

In section Objects we saw that the fields of object types like our Computer data type behave in the same way — assignments copy the content. The tuple data type, which has some similarities to objects, and which we will introduce later in the book, behaves the same. All these data types are stack-allocated, and we say that the data types have value or copy semantic. Even strings and sequences, which use actually a heap-allocated data buffer, behave in the same way in Nim.

Whenever possible, we should use this simple form of variables, as they are fast and easy to use.

Maybe that is not too surprising for you, but when we would have references instead of plain variables, then the situation would be different, as we will see soon. Actually, some other programming languages use reference semantics for entities like strings by default, for example in Ruby an assignment of a string variable to another variable does not copy the content, so that both variables still use the same data buffer — when we then modify one variable, the content of the other changes too.

But there exist situations where we need some sort of indirection, and then references and pointers come into play. For example, when the data entities depend in some form on each other, the elements may build linked lists, trees, or other structures. The entities may have some neighborhood relation, also called some one-to-many relation.

Indeed, value objects and references occur in real life also:

Imagine you have baked a cake for your family, and you know that your friendly neighbor loves cakes too. As you have still a lot of all the necessary ingredients and because the oven is still hot, you make one more identical cake to give it later to your neighbor. We can think of the cake as a value type, and your second cake can be considered as a copy. When you give the copy to your neighbor, then you have still your own, and when you or the neighbor eats the cake, then the other one still exists.

Now imagine that you know a good car repair shop. You can give the telephone number or location of that car repair shop to your neighbor, so he can use that shop too. So you gave him a reference to the shop, but you gave him not a copy. You can also give some of your other friends each a reference to that shop, which is nearly no effort for you. While backing a cake for all of them would be some effort. But there is some danger with references: When one of your friends gets angry and burns down the car repair shop, then you and all your other friends have a serious problem.

You can regard the names of persons as some sort of reference too. Imagine you have a list with the names of all the people you intend to invite to your birthday party and another list with the names of people who owe you money. Some names may be on both lists, this is it refers to the same person.

In computers, the dynamic storage, called RAM, consists of consecutive, numbered storage locations, called words. Each individual word has its address, which is a number typically starting at zero and extending to a value, which is defined by the amount of memory available in your computer. These addresses can be used to access the storage locations, that is, to store a value at that address, or to read the content again. Reading generally does not modify the content, you can read it many times and will always get the same value. When you write another value to that storage location, then reads will give you that new value.

Basically, for all the data that you use in your program you need in some form its address in the RAM, without the address, you can not access it. But what is with all the plain, value object variables we have used before, we have never used addresses? That is true — we used only names to access our variables, and the compiler mapped our chosen name to the actual address of the variables in memory whenever we accessed the variable. For most simple cases, this is the best way to access variables. Now, let us assume we have such value object type of variable declared in our program, can we access it without using its name? When we have declared it, it should reside somewhere in the RAM when the program is executed. Well, when we do really not want to access it by variable name, then there is still one chance: We can search in the whole RAM for the desired content. In practice, we would never do that, as it is stupid and would take very long, but we could do it. But how can we detect our variable? How can we be sure that it is indeed ours? Generally, we can not. Even when we are sure that the variable must reside somewhere in the RAM, typically the variable is marked in no way, of course. Even when we would know the value, which is stored in that variable, we would only know what bit pattern it should have, so for most words of the RAM with a different bit pattern we could say for sure that it can not be our variable, but whenever we find the expected bit pattern then it can be just a coincidence, there can be many more words in RAM with that content. In some way, it is as if you would search for a person, and you know that that person lives on a long road with numbered houses. If you only know that the person wears brown shoes, but you know not the number of the house nor the name of the person and no other unique property of that person, then you have not much luck.