From := to :=: How Go Brought Me Back to My Pascal and Delphi Days

March 31, 2026

It happened on a Tuesday. I was writing a small microservice in Go, nothing fancy, just an API endpoint that fetched some data from a database. My fingers were moving automatically, muscle memory doing its thing, when I typed:

nombre := "Peace"

I stopped. My hands hovered over the keyboard. I stared at the screen for a good five seconds.

:=

I hadn’t seen that operator since college. Since the days of floppy disks, blue screens with white text, and a professor who insisted that Pascal was “the language of the future.” That was twenty-something years ago.

And here it was again, staring back at me.

The Assignment That Traveled Through Time

Most modern languages use = for assignment. C does it. Java does it. JavaScript, Python, Rust, all of them, =.

But not Pascal. Not Delphi. And not Go.

In Pascal, := meant “declare and assign”. It was a deliberate choice, a way to distinguish assignment from comparison (=). When you wrote if x = 5 then, you were comparing. When you wrote x := 5, you were setting a value. Two different operations, two different symbols. It made sense. It was clear.

Then I left Pascal behind. I moved to C, then to Java, then to a dozen other languages. I got used to =. I stopped thinking about it. := became a fossil, buried somewhere in my brain alongside Turbo Pascal 7.0’s blue IDE and the satisfying click of a successful compilation.

Until Go unearthed it.

Because in Go, := does exactly what it did in Pascal:

Pascal:

var
  nombre: string;
begin
  nombre := 'Facultad';
end.

Go:

nombre := "Go"
// same as:
var nombre string = "Go"

Declaration and assignment, in one clean motion. No ambiguity. No confusion.

A Quick Detour: Turbo Pascal 7 and Delphi

To understand why this small operator made me feel something, I need to take you back.

Turbo Pascal 7.0 (1992) was magic. You wrote code, pressed Ctrl+F9, and in what felt like an instant, you had an .exe file. Compilation speed was legendary — seconds, never minutes. The IDE was everything: editor, compiler, debugger, all in one blue screen that didn’t need a mouse.

Then Delphi (1995) arrived and changed everything. Object Pascal. Visual form designer. Database components you could drag and drop. It was Turbo Pascal on steroids, and I spent countless hours building applications — inventory systems, reporting tools, small business software, all with Delphi’s unmistakable productivity.

But beyond the visual tools, what stayed with me was the language itself:

• Units with interface and implementation sections, a clean way to separate public from private.
• Types after names: nombre: string instead of string nombre.
• No header files: one .pas file, everything in one place.
• Compilation that never made you wait.

I didn’t know it then, but those characteristics were carving a set of expectations into my brain about what a programming language should feel like.

Beyond the Operator: Deeper Parallels

When I started writing Go years later, I expected something completely different. Go was modern, it was for servers and cloud, it had nothing to do with Pascal.

But then I noticed more than just :=.

FeaturePascal / DelphiGoAssignment with declaration:=:=Types after identifiersnombre: stringnombre stringPublic/private controlinterface section vs implementationCapitalized vs lowercase namesModulesunitpackageCompilation speedSecondsSecondsSingle file per module.pas.goNo preprocessorNo macrosNo macrosPointers^Tipo*Tipo (no arithmetic)Memory modelManual with Create/Free (Delphi), later with GC (some versions)Garbage collected

The one that really hit me was encapsulation.

In Delphi, you wrote:

unit Persona;
interface
  type
    TPersona = class
    private
      FNombre: string;
    public
      procedure Saludar;
    end;
implementation
  procedure TPersona.Saludar;
  begin
    WriteLn('Hola, soy ', FNombre);
  end;
end.

In Go, the same principle, different syntax:

package persona
type Persona struct {
    nombre string  // lowercase = private
}
func (p *Persona) Saludar() {
    fmt.Println("Hola, soy", p.nombre)
}
// Public function (uppercase) can be called from other packages
func NewPersona(nombre string) *Persona {
    return &Persona{nombre: nombre}
}

The idea is identical: what’s inside the module stays private unless you explicitly expose it. Pascal used sections (interface vs implementation). Go uses capitalization (uppercase = public, lowercase = private). Same concept, different implementation. Both prioritize clarity and intentionality.

What Go Kept, What Go Left Behind

Go didn’t copy Pascal blindly. It took the philosophy and applied it to a new era.

What Go kept:

• Simplicity over complexity: Pascal was designed for teaching; Go was designed for maintainability. Both reject features that add complexity without proportionally adding value.
• Compilation speed as a feature: If compilation takes more than a few seconds, something is wrong. This was true in 1992 and it’s still true today.
• Strong typing without ceremony: Types are explicit but not verbose.
• One way to do things: Delphi’s IDE encouraged a single style; Go enforces it with go fmt.

What Go left behind:

• Class inheritance: Go uses composition and embedding instead. No fragile base classes, no diamond problem.
• Exceptions: No try/except blocks. Go returns errors as values. You handle them where they occur, explicitly.
• Visual form designer: Go has no native GUI toolkit. It’s built for servers, CLIs, and cloud services.

The most interesting omission is inheritance. In Delphi, you’d create a TButton descendant to customize behavior. In Go, you embed a struct and override what you need. It’s a different model, but the goal is the same: code reuse without complexity.

That Feeling of Recognition

I’ve worked with C, Java, C#, JavaScript, Python. All fine languages. All useful. But none of them made me feel what Go made me feel when I typed := for the first time.

It wasn’t nostalgia. It was recognition.

It was the same feeling you get when you hear a song you haven’t heard in twenty years and you still know every word. Some part of your brain kept that language, those patterns, those expectations. And Go didn’t contradict them — it confirmed them.

The clarity. The lack of magic. The sense that the code does exactly what it says, no more, no less.

Why didn’t other languages adopt :=? Because most followed C’s convention. Pascal and Go made a different choice: distinguish declaration from comparison. It’s a small thing, but it tells you something about the philosophy of the language. It tells you that someone thought about readability. Someone cared.

Conclusion: A Bridge Between Eras

Pascal and Go are separated by more than twenty years, by the rise of the internet, by cloud computing, by a thousand technological revolutions.

But they’re connected by something deeper: a belief that programming languages should be clear, compilation should be fast, and code should be easy to read.

If you learned programming with Pascal or built applications with Delphi, Go will feel strangely familiar. Not because it looks the same — it doesn’t. But because it thinks the same. It values the same things. It makes the same kinds of trade-offs.

And somewhere, in a small operator that declares and assigns in one stroke, you’ll find a piece of your programming past waiting for you.

:=

It was there in the faculty. It’s there in Go.

And somehow, that little symbol makes all the difference.

If you enjoyed this, leave a comment below. Did you also come from Pascal or Delphi? What was your “wait, I’ve seen this before” moment with Go?