Stroom

Stroom is a programming language based on Dutch, designed by PSTF.

The article is also called !Nederlands.

Philosophy

• Dutch First: All keywords, built-in functions, and error messages are in Dutch.
• Object-Oriented: Everything is an object (except primitive types, which are automatically wrapped).
• Readable & Expressive: Use of clear verbs (has, inheritsFrom, times) for self-documenting code.
• Safe: Strong typing (static, with type inference where possible).

Core Syntax

Keywords

Dutch 			Function 				English Equivalent
Klasse 			Defines a class				class
erftVan 		Inheritance (single)			inherits / extends
heeft 			Declares a property (field)		has / field
actie 			Defines a method			method / action
start 			Entry point of the program		main
nieuw			Instantiates an object			new
zelf 			Refers to the current instance		this / self
als 			Conditional branch			if
anders 			Alternative branch			else
zolang 			Loop while the condition is true	while
voor 			Iteration over a range or list		for
keer 			Returns a value from an action		return
stop 			Breaks a loop				break
gaVerder 		Goes to the next iteration		continue
is 			Comparison operator (equality)		is / =
Waar / Onwaar		Boolean values				True / False
Niets 			Null value				null / nil
abstract (optional) 	Marks a class or action as abstract	abstract

Data Types

Dutch		Description				English Equivalent
Getal		Floating point or integer (automatic)	Number
HeelGetal	Integer (explicit)			Integer
Tekst		UTF-8 string				String
Bool		Boolean (True / False)			Bool
Lijst		Dynamic array (0-index)			List
NietsType	Type for Nothing			NullType

Object-Orientation Model

Creating a Class

Klasse Persoon {
    # Eigenschappen
    heeft naam: Tekst
    heeft leeftijd: Getal
    heeft isActief: Bool <- Waar   # Standaardwaarde

    # Constructor (optioneel, naam is altijd 'maak')
    maak (naam: Tekst, leeftijd: Getal) {
        zelf.naam <- naam
        zelf.leeftijd <- leeftijd
    }

    # Methode
    actie groet {
        schrijf("Hallo, " + zelf.naam)
    }

    actie vierVerjaardag -> Getal {  # Pijltje voor return type
        zelf.leeftijd <- zelf.leeftijd + 1
        keer zelf.leeftijd
    }
}

Overriding, Inheritance, and Polymorphism

Klasse Persoon {
    # Eigenschappen
    heeft naam: Tekst
    heeft leeftijd: Getal
    heeft isActief: Bool <- Waar   # Standaardwaarde

    # Constructor (optioneel, naam is altijd 'maak')
    maak (naam: Tekst, leeftijd: Getal) {
        zelf.naam <- naam
        zelf.leeftijd <- leeftijd
    }

    # Methode
    actie groet {
        schrijf("Hallo, " + zelf.naam)
    }

    actie vierVerjaardag -> Getal {  # Pijltje voor return type
        zelf.leeftijd <- zelf.leeftijd + 1
        keer zelf.leeftijd
    }
}

Encapsulation (Visibility)

• By default, fields and methods are public.
• Add privé for private access: heeft privé wachtwoord: Tekst

Input & Output (I/O)

Stroom provide built-in functions (no class needed, similar to System.out in Java).

Function			Description
schrijf(value)			Writes the value to the console with a newline.
schrijfZE(value)		Writes the value without a newline (ZE = Zonder Enter = No Enter).
lees() -> Tekst			Reads a full line from the console (string).
leesEval() -> automatisch	Reads a line and parses it into an expression.

Example: <ore> start {

   schrijf("Wat is uw voornaam?")
   var voornaam <- lees()
   schrijf("Hallo " + voornaam + "!")

}

Control Flow

If-Elif-Else

als (leeftijd >= 18) {
    schrijf("U bent meerderjarig.")
} andersAls (leeftijd >= 12) {
    schrijf("U bent een tiener.")
} anders {
    schrijf("U bent een kind.")
}

Loops (Conditional and Iterative)

# While-lus
var teller <- 0
zolang (teller < 5) {
    schrijf(teller)
    teller <- teller + 1
}

# For-lus (over een bereik)
voor (i in 1..10) {
    schrijf("Getal: " + i)
}

# Iteratie over een lijst
var namen <- ["Anna", "Bea", "Chris"]
voor (naam in namen) {
    schrijf(naam)
}

Recursion

Klasse Rekenaar {
    actie faculteit(n: Getal) -> Getal {
        als (n <= 1) {
            keer 1
        } anders {
            keer n * zelf.faculteit(n - 1)
        }
    }
}

start {
    var r <- nieuw Rekenaar()
    schrijf("Faculteit van 5 is: " + r.faculteit(5))  # Output: 120
}

Examples

FizzBuzz

start {
    var i <- 1
    zolang (i <= 100) {
        var output <- ""

        als (i % 3 is 0) {
            output <- output + "Fizz"
        }
        als (i % 5 is 0) {
            output <- output + "Buzz"
        }

        # Als de string leeg is, toon dan het getal
        als (output = "") {
            schrijf(i)
        } anders {
            schrijf(output)
        }
        i <- i + 1
    }
}

Why Stroom is Turing-complete

To be Turing-complete, a language must have:

• Unlimited memory: Dynamic allocation via new and List (which grows) provides an (theoretical) infinite tape.
• Conditional branching: if-structure.
• Iteration or recursion: Both while/for (iteration) and recursion (an action calling itself) are present.

Since all three are met, Stroom is formally Turing-complete.

Implementation Concept (Transpiler / VM)

Stroom can be implemented as a transpiler to Python or JavaScript, or as a bytecode VM. A simple approach:

• Parser: Build an AST (Abstract Syntax Tree) using a parser generator (e.g., ANTLR) with Dutch tokens.
• Semantic analysis: Type checking and inheritance resolution.
• Code generation: Generate Python code, for example, because Python is naturally OOP and dynamic, which makes integrating Dutch keywords easier.

Conclusion

Stroom offers a fully Dutch alternative to programming languages without sacrificing power. With classes, inheritance, polymorphism, safe I/O, and all control structures, it's a full-fledged, object-oriented, and Turing-complete language, perfect for educational purposes or Dutch-language projects.

See Also

!English, 中文（简体，中国大陆）, !Romanian...