Objectives

What do we want to do today?

Learn how to get started with Nim

Find out why Nim is interesting

See Nim syntax and semantics

Objectives

Notes before we begin:

Code: https://github.com/tedneward/Demo-Nim

Slides: http://www.newardassociates.com/presentations/BusyDevsGuide/Nim.html

Nim Overview

Official description

Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula.

https://nim-lang.org/

Nim Overview

Official description

statically-typed

compiled to native ("native dependency-free") or JavaScript

memory management is deterministic and customizable

compile-time evaluation of some constructs

support for different backends (C, C++, JavaScript)

macro system offering full AST manipulation (at compile-time)

Getting Started

Installation

Download: https://nim-lang.org/install.html

Homebrew/Linuxbrew: brew install nim

Getting Started

Hello world

# This is a comment
echo "What's your name? "
var name: string = readLine(stdin)
echo "Hi, ", name, "!"

Compiling, then executing

$ nim c hello.nim
$ ./hello
What's your name?
Ted
Hi, Ted!

Compiling and executing in one run

$ nim compile -r hello.nim

Basics

Lexical

Single-line comments start with #

Documentation comments start with ##

Multi-line comments bracketed with #[ and ]#

and can be nested

Basics

Syntax

# This is a comment
    
#[ This is
    a multiline
    comment ]#

Basics

Local bindings

declaration name : type = value

Declarations

var: mutable/variable

const: compile-time-known immutable binding

let: non-compile-known immutable binding

names are UTF-8 strings

case- and underscore-insensitive, except for first character

type is optional if value is provided (type-inference)

Multiple declaration syntax is supported

Basics

Declarations in Nim

var a: int      # mutable integer, no value explicitly set
var b = 7       # mutable inferred integer set to 7
var 
  c = -11       # mutable inferred integer set to -11
  d = "Hello"   # mutable inferred string set to "Hello"
  e = '/'       # mutable inferred character set to '/'
var f1, f2 = 37 # mutable inferred integer set to variables
    
const g = 35    # immutable integer set to compile-time value  
var k = 27
let j = 2 * k   # immutable integer set to runtime value

Basics

Primitive types: Boolean

true, false literals

Relational operators:

==: equality

!=: inequality

less-than, greater-than per usual

less-than-equal, greater-than-equal per usual

Logical operators:

and: both operands must be true

or: either operand can be true

xor: true if only one operand is true

not: negates the truth value of the operand

Basics

Booleans in Nim

let
  rg = 31
  rh = 99
    
echo "rg is greater than rh: ", rg > rh
echo "rg is smaller than rh: ", rg < rh
echo "rg is equal to rh: ", rg == rh
echo "rg is not equal to rh: ", rg != rh
    
echo "T and T: ", true and true
echo "T or F: ", true or false
echo "F xor F: ", false xor false
echo "not F: ", not false

Basics

Primitive types: Integers

int

literals use _ as thousands separator

usual mathematical operators: +, -, *, /

+, -, * produce integer result

/ produces floating-point result

div produces integer (no-remainder) result

mod produces modulo (remainer-only) result

Basics

Primitive types: Floats

float

follows floating-point standard

literals support scientific (exponentiation) notation: 4e7

usual mathematical operators: +, -, *, /

no div or mod

Basics

Integer/float conversions

int function converts parameter to int type

float function convers parameter to float type

Basics

Nim numerics

let na = 11
var nb = (na + 5 - (3 * 2)) / 3
var nc = int(5.5)
var nd = float(5)

Basics

Primitive types: Characters

single ASCII character

multiple-character literals produce error

literals are offset by ticks (')

special characters:

\n: newline character

\t: tab character

\: backslash character

Basics

Primitive types: Strings

series of characters

literals are enclosed in double quotes (")

concatenation via &

special characters also supported

"raw" r-prefixed strings ignore special characters

"long strings" are """-enclosed strings

strings are objects

Basics

Nim strings and characters

var sa = "Hello"
let sb = sa & "\nworld\n"
let sr = r"Hello\tworld"    # raw string: "Hello        world"
sa.add(" the world")
echo "The sa string equals", sa
    
let
  ci = 'a'
  cj = 'd'
echo ci < cj
    
let
  sm = "axyb"
  sn = "axyz"
  so = "ba"
  sp = "ba "
echo sm < sn  
echo sn < so  
echo so < sp  

Composite Types

These are the types that are made up of other elements

Arrays

Sequences

Tuples

Composite Types

Arrays

"homogeneous container of constant length"

size must be known at compile-time

array[length,type] = [values]

values are comma-separated list of values

length and type can be inferred from values

Composite Types

Arrays

var
  a: array[3, int] = [5, 7, 9]
  b = [5, 7, 9]        
  c = []  # error      
  d: array[7, string] 
    
const m = 3
let n = 5
    
var ba: array[m, char]

Composite Types

Sequences

"homoegeneous container of flexible length"

size doesn't have to be known at compile-time

size can change at runtime

seq[type] = @[values]

if values are present, sequence declaration can be inferred

or newSeq[type]() procedure call

Composite Types

Sequences

var
  e1: seq[int] = @[]   
  f = @["abc", "def"]  
  e = newSeq[int]()
  g = @['x', 'y']
  h = @['1', '2', '3']
    
g.add('z')  # x, y, z
h.add(g)    # 1, 2, 3, x, y, z
    
var i = @[9, 8, 7] # 3
i.add(6)    # 4

Composite Types

Indexing and Slicing

both arrays and sequences use [-] indexing syntax

positive index starts 0-indexed from the left

^-prefixed index starts 1-indexed from the right

start .. end (range) is a "slice", inclusive of both ends

start ..< end is a "slice", exclusive of end

Composite Types

Indexing and slicing

let j = ['a', 'b', 'c', 'd', 'e']
    
echo j[1]   # a
echo j[^1]  # e
echo j[0 .. 3]  # @[a, b, c, d]
echo j[0 ..< 3] # @[a, b, c]

Composite Types

Tuples

heterogenous mutable-contents fixed-size containers

( values ) where values is a comma-separated list of values

( name : value ) named-field tuple

access fields by name or position

[ index ]

.name

Composite Types

Tuples

let n = ("Banana", 2, 'c')  
echo n    # (Field0: "Banana", Field1: 2, Field2: 'c')
    
var o = (name: "Banana", weight: 2, rating: 'c')
o[1] = 7          
o.name = "Apple"  
echo o    # (name: "Apple", weight: 7, rating: 'c')

Control flow

Branching: if

if condition :

elif condition : (optional)

else:

indentation-based scope blocks

Control flow

If

var x = 10
if x < 5:
    echo "x is less than 5"
elif x > 5:
    echo "x is greater than 5"
else:
    echo "x is equal to 5"

Control flow

Branching: case

case expression

of value :

else: (optional)

each of block has indentation scope

Control flow

Case

let i = 7
    
case i
  of 0:
    echo "i is zero"
  of 1, 3, 5, 7, 9:
    echo "i is odd"
  of 2, 4, 6, 8:
    echo "i is even"
  else:
    echo "i is too large"

Control flow

Looping: while

Control flow

While

var a = 1
    
while a*a < 100: 
  echo "a is: ", a
  inc a         
    
echo "final value of a: ", a

Control flow

Looping: for

Control flow

For

for n in 5 ..< 9: 
  echo n
    
for n in countup(0, 16, 4):  
  echo n

Control flow

Loop manipulation

break: Early loop termination

continue: Early loop re-cycle

Summary

So... now what?

Nim is a good language to know

Credentials

Who is this guy?

Architect, Engineering Manager/Leader, "force multiplier"

http://www.newardassociates.com

http://blogs.newardassociates.com

Books

Developer Relations Activity Patterns (w/Woodruff, et al; APress, 2026)

Professional F# 2.0 (w/Erickson, et al; Wrox, 2010)

Effective Enterprise Java (Addison-Wesley, 2004)

SSCLI Essentials (w/Stutz, et al; OReilly, 2003)

Server-Based Java Programming (Manning, 2000)