sota.io
2026-04-02·9 min read·sota.io team

Deploy BETA to Europe — Ole Lehrmann Madsen 🇩🇰 Aarhus + Kristen Nygaard 🇳🇴 Oslo, the Scandinavian OOP Language That Unified Everything on EU Infrastructure in 2026

In 1967, two researchers at the Norwegian Computing Center in Oslo created Simula — the first object-oriented programming language, and the ancestor of every class-based language ever written. One of them was Kristen Nygaard 🇳🇴. Sixteen years later, Nygaard collaborated with a team at Aarhus University in Denmark to design BETA: the most radical rethinking of object-oriented programming that the field has ever produced. BETA asked a question that no language before or since has answered quite the same way: what if a class, a method, an exception handler, and a co-routine are not different constructs that share some properties — but literally the same thing?

The answer was the Pattern. In BETA, there is one fundamental abstraction. Everything else is a use of it.

Aarhus University and the Scandinavian OOP Tradition

Aarhus University 🇩🇰 (founded 1928, Aarhus, Jutland, Denmark) became one of the most important centres of programming language research in the world during the 1970s and 1980s. The Computer Science Department — initially the DAIMI institute (Datalogisk Institut) — built an intellectual tradition that ran from formal specification methods through object-oriented programming to what became BETA.

Ole Lehrmann Madsen 🇩🇰 was the principal architect of BETA. He studied at Aarhus University and remained there for his entire career, becoming a professor at DAIMI. Madsen's contribution was the conceptual core of BETA: the realisation that the distinctions programming languages draw between classes, methods, and co-routines are unnecessary — that a single, more general construct can serve all of these roles without losing expressiveness.

Birger Møller-Pedersen 🇩🇰 was a researcher at the Norwegian Computing Center (Norsk Regnesentral) in Oslo, the same institution where Dahl and Nygaard had created Simula. His presence on the BETA team was both symbolic and substantive: it meant BETA was designed with direct knowledge of what Simula had achieved and where it had left room for something deeper.

Kristen Nygaard 🇳🇴 (1926–2002) brought the deepest perspective of all. He was already one of the most honoured computer scientists in the world — he and Ole-Johan Dahl had received the ACM Turing Award in 2001, thirty-four years after Simula, for their invention of object-oriented programming. Nygaard returned to OOP design with BETA not to extend what Simula had done but to rethink it. He believed that Simula's class and method were two distinct things where one unified concept would serve better.

The three published their work in the 1983 paper Object-Oriented Programming in the BETA Programming Language and later in a comprehensive 1993 book of the same title (Addison-Wesley, co-authored with Søren Brøndsted Knudsen 🇩🇰, also Aarhus). BETA has been continuously developed since then, primarily at Aarhus.

The Pattern: One Abstraction to Rule Them All

Every modern object-oriented language distinguishes between the noun and the verb. A class describes what data looks like. A method describes what an object does. These are treated as fundamentally different kinds of thing: you instantiate a class, you call a method. The two concepts have different syntax, different roles, and different rules.

BETA dissolves this distinction entirely. In BETA, both a class definition and a method definition are patterns. A pattern describes a template for execution: it has a set of attributes (which may be variables, nested patterns, or virtual patterns), an enter-part (for parameterisation), a do-part (a body of computation), and an exit-part (for producing a result). When you instantiate a pattern as an object, it behaves as a class. When you call a pattern as a procedure, it behaves as a method. When you iterate through its do-part incrementally, it behaves as a co-routine. When you escape from it under exceptional conditions, it behaves as an exception handler.

This is not a metaphor or an analogy. In BETA, these are literally the same language construct used in different ways:

-- A pattern used as a class (object factory):
Person: (# name: @text; age: @integer #)

-- A pattern used as a method (procedure):
greet: (# do 'Hello, world!' -> putline #)

-- A pattern used as a co-routine (generator):
counter: (# value: @integer;
  init: (# do 0 -> value #);
  next: (# do value + 1 -> value; value -> inner #)
#)

The same syntactic construct — (# ... #) — expresses what five or six different keywords express in Java or Python. The # delimiter is BETA's characteristic notation; its source code is visually distinct from everything else in the programming language landscape.

Sub-patterns and the Inversion of Inheritance

BETA handles inheritance through sub-patterns. A sub-pattern extends an existing pattern, adding attributes and augmenting behaviour. This much is familiar from other OOP languages. What is unfamiliar — and what makes BETA's approach to inheritance philosophically distinctive — is the inner mechanism.

In Java, a subclass calls super.method() to invoke the parent's implementation. The subclass is in control: it decides when and whether the parent's code runs. In BETA, this relationship is inverted. The parent pattern calls inner at a specific point in its do-part, and the sub-pattern's additional code is executed at that point. The parent defines the structure of execution; the sub-pattern fills in the specialised portion.

This means BETA's inheritance is always prefix inheritance: the parent's code runs first (up to inner), then the sub-pattern's code, then the parent's code continues after inner. Subclasses cannot skip the parent's pre- and post-processing. This makes inheritance significantly safer than in Java or C++: a sub-pattern cannot accidentally break an invariant that the parent establishes before calling inner or relies on after inner returns.

From a GDPR perspective, this property is significant. Data governance patterns in BETA can enforce logging, audit trail generation, or data minimisation constraints in the parent pattern's do-part that no sub-pattern can bypass. The compiler structure guarantees this at the language level, not through runtime assertions or documentation.

Virtual Patterns and the Type System

BETA has virtual patterns — patterns that can be overridden in sub-patterns, analogous to virtual methods in C++ or abstract methods in Java. But because the unit of abstraction in BETA is the pattern, and a pattern can be instantiated as an object or called as a method, virtual patterns are simultaneously virtual types and virtual procedures.

A pattern attribute declared as virtual in a parent can be specialised to a more specific sub-pattern in a subtype. This is what object-oriented languages call covariant specialisation of return types, but in BETA it applies to the entire pattern — both the class-like and the method-like uses of the same abstraction.

Erik Ernst 🇩🇰 (Aarhus University) extended virtual patterns further in his work on gbeta — generalised BETA — which supports multiply virtual patterns and multiple inheritance. Ernst's PhD thesis at Aarhus in the late 1990s became influential in type theory: his work on family polymorphism and virtual classes influenced the design of Scala's abstract type members and the academic literature on dependent types. The connection from BETA → gbeta → Scala's type system is a direct line of descent from Aarhus to Lausanne.

Concurrency: Patterns as Co-routines

BETA's unified Pattern construct makes co-routine support natural rather than a language addition. A pattern whose do-part includes suspend calls becomes a co-routine: each call to the pattern resumes where it left off. This is the same construct used for object instantiation and method invocation — the mode of use determines the semantics.

-- A pattern used as a co-routine (generator):
naturals: (# n: @integer;
  cycle: (# do n + 1 -> n; n -> inner; restart cycle #)
  do 0 -> n; cycle
#)

This model of concurrency predates Python generators, JavaScript async/await, and Kotlin coroutines by decades. The coroutine as a language primitive rather than a library construction was a design principle Nygaard had established in Simula and refined in BETA. Every modern language that has "discovered" structured concurrency in the last decade is converging on patterns that BETA explored in 1983.

The Mjolner BETA System and gbeta

The primary implementation of BETA was the Mjolner BETA System, developed at Aarhus University through the 1980s and 1990s. Mjolner was a full integrated development environment — one of the earliest — including a compiler, debugger, and editor with semantic awareness of BETA's structure. It was used in commercial projects across Scandinavia and was a production-quality system.

The modern implementation is gbeta, developed by Erik Ernst 🇩🇰 at Aarhus. gbeta is available as open source and supports the full BETA language with extensions. It compiles BETA source to native binaries via a C backend — the same architecture used by many research language implementations — and runs on any standard Linux system.

# Install gbeta on Ubuntu (EU Linux server):
# Build from source — gbeta requires SML/NJ
sudo apt-get install -y smlnj

git clone https://github.com/ufo2mmar/gbeta.git
cd gbeta
make

# Hello World in BETA:
cat > hello.bet << 'EOF'
(* BETA Hello World *)
PROGRAM hello;
  (# do 'Hello from BETA 🇩🇰🇳🇴 — Aarhus + Oslo on EU infrastructure!' -> putline #)
EOF

gbeta hello.bet

The binary output is standard ELF, deployable on any EU Linux server without additional runtime dependencies beyond the C standard library.

Connecting to Simula: the OOP Lineage from Oslo

Nygaard's presence on the BETA design team creates one of the most direct lineages in programming language history. Nygaard co-invented OOP with Simula in 1967. He participated in BETA's design in 1983. BETA's core innovations — the Pattern unification, prefix inheritance, virtual classes — have influenced virtually every major OOP language designed since, either directly or through the academic literature that BETA generated.

The inheritance line from Aarhus and Oslo to the rest of the industry:

The Scandinavian school of OOP — Simula (Oslo, 1967), BETA (Aarhus, 1983), Scala (EPFL, 2003 under Odersky who studied with Wirth, a Swiss-German Wirth-student who knew the Scandinavian tradition) — is a coherent intellectual tradition. Every mainstream OOP language stands somewhere in its shadow.

EU Regulatory Angles

GDPR Art. 25 — Data Protection by Design: BETA's prefix inheritance and the inner mechanism enforce structural constraints at the compiler level. A data-handling pattern that performs consent logging before calling inner cannot have that logging bypassed by sub-patterns. The GDPR requirement that privacy be designed into systems rather than bolted on can be implemented in BETA at the type system level.

EU AI Act Art. 9 — Risk Management Systems: BETA's formal pattern structure and virtual patterns make behaviour auditable. The type system can enforce that AI system components respect defined contracts — logging inputs, recording decisions, maintaining audit trails — because these are compiler-enforced invariants in the parent pattern.

NIS2 — Secure Software Design: The absence of multiple dispatch and the controlled semantics of virtual patterns reduce the attack surface of BETA software compared to languages with more dynamic dispatch mechanisms. The predictability of prefix inheritance eliminates a class of security issues where subclasses intercept and modify security-critical parent behaviour.

Skandinavische Digitale Souveränität: BETA was created entirely within the European Economic Area — Denmark (EU member since 1973) and Norway (EEA member with full GDPR coverage). No American institution contributed to the design of the language. The Aarhus-Oslo intellectual axis represents exactly the kind of European-origin digital infrastructure that EU sovereignty initiatives are designed to recognise and support.

Deploy BETA on sota.io

sota.io supports any language that compiles to a Linux binary or runs in a standard container. A BETA application compiled with gbeta and packaged as shown below deploys with:

sota deploy --region eu-west

The platform detects the container, provisions EU infrastructure on Hetzner (Germany) or Scaleway (France), injects managed PostgreSQL credentials as environment variables, configures TLS termination, and assigns a .sota.io subdomain. All infrastructure runs within the European Economic Area.

FROM ubuntu:24.04 AS builder
RUN apt-get update && apt-get install -y smlnj git make gcc
RUN git clone https://github.com/ufo2mmar/gbeta.git /gbeta && \
    cd /gbeta && make

WORKDIR /app
COPY *.bet ./
RUN /gbeta/bin/gbeta -o server server.bet

FROM ubuntu:24.04
RUN apt-get update && apt-get install -y libpq5
COPY --from=builder /app/server /app/server
EXPOSE 8080
CMD ["/app/server"]

The language Ole Lehrmann Madsen 🇩🇰 designed at Aarhus University, that Kristen Nygaard 🇳🇴 helped conceive from the foundation of Simula, that Erik Ernst 🇩🇪 extended into gbeta — is still compilable, still deployable, still the most radical unification of object-oriented concepts ever proposed. The Pattern is still the deepest answer to the question of what an object-oriented abstraction should be.

sota.io is the EU-native platform-as-a-service for developers who need European infrastructure, GDPR compliance by default, and managed PostgreSQL without the operational overhead. Deploy your BETA application to EU servers in minutes at sota.io.