A method is the smallest useful promise a program makes. Before it is a Windows app, before it is a plugin, before it is anything you double-click, it is one named block of behaviour you can call by name — again and again, from anywhere. PAZ’s own BIM interoperability panel opens with exactly this: a Python def members(path) that walks two IFC files and reports what survived the round-trip. Change the language, keep the idea. That def is a method. Today we build the same reflex in C#, from an empty folder to a running program on your own machine.

The signal is mundane, and that is the point: w3schools’ C# tutorial teaches the method with a three-line MyMethod() that prints “I just got executed!” — then calls it three times. It looks like nothing. It is the entire foundation of reusable software.

←TODAY: In 2026 the .NET 9 SDK is a free, open-source (MIT) download; a C# method you write on Windows runs unchanged on Linux and macOS. →3012: In Zurich-3012 the offices still standing kept their site logic as plain, named code — not locked inside a dead vendor plugin. Fulcrum: A method is a promise to whoever maintains the file next; name it well and a 25-year-old can still open it in fifty years.

The Tool: The .NET SDK — the command-line toolkit that compiles and runs C#. It is open source under the MIT licence, shipped by Microsoft, and the language itself was designed by Anders Hejlsberg (the same hand behind Turbo Pascal and TypeScript). For an architect or computational designer it is worth an afternoon because C# is the language your CAD extensions, your web utilities, and your site scripts all eventually meet. Learn the method here in a bare console app, and the same syntax carries later into where code meets geometry.

Setup:

# Windows 11: install the free .NET SDK via winget
winget install Microsoft.DotNet.SDK.9

# prove it works
dotnet --version          # -> 9.0.x

# scaffold your first program and run it
dotnet new console -o FirstApp
cd FirstApp
dotnet run                # -> Hello, World!

Three commands, and you have a compiled, running C# program. The SDK is free; the afternoon you lose to a broken dialog box isn’t — so getting to a first run fast matters more than it looks.

First steps:

1. Open FirstApp/Program.cs in any editor. The .NET 9 template greets you with a single top-level line: Console.WriteLine("Hello, World!");.
2. Replace it with a method and two calls:

   void MyMethod()
   {
       Console.WriteLine("I just got executed!");
   }
   
   MyMethod();
   MyMethod();
   

3. Run dotnet run. You will see the line printed twice — the same block of code, reused, exactly as w3schools promises.
4. Now make it earn its keep: give the method a parameter and a return value, so it computes instead of just announcing itself.

Atelier: In a Swiss Büro the value lands the moment a repeated site calculation stops living as a copy-pasted formula in five spreadsheets and becomes one named method the whole team calls. Copy-paste is a loan; the interest comes due on site. Your Monday move: install the .NET SDK on one workstation and rewrite your most-repeated manual calc — brick counts, slab volumes, insulation areas — as a single C# method, then call it from a two-line console app. One source of truth, versioned in git, not scattered across desks.

Hack: Turn a slab’s footprint into cubic metres of concrete with one named, reusable method — parameters in, answer out. Everything past “print a string” starts here.

static double SlabVolume(double areaM2, double thicknessM)
    => areaM2 * thicknessM;                 // m² × m = m³

double order = SlabVolume(180.0, 0.24);     // 180 m² slab, 24 cm deep
Console.WriteLine($"{order:F1} m³ concrete"); // -> 43.2 m³ concrete

Five ideas in four lines: a parameter list, a typed return value, an expression-bodied method (=>), string interpolation, and a format specifier. w3schools leaves parameters and return values for “later” — this is later. The method now answers a question instead of describing itself.

System — why a method matters more than it looks. A method is the unit of reuse, and reuse is the unit of trust. PAZ’s generative-architecture concept panel describes engineering’s ladder of autonomy — the machine enumerates structural-grid candidates, the engineer curates. Every rung of that ladder is built from named, testable methods; you cannot audit or automate a wall of copy-pasted logic. The same holds one floor down at the desk: the difference between a script you trust on site and one you fear is whether its pieces have names.

The lock-in question is quieter, but it outlives every project. The buildings that aged badly were rarely the ugly ones — they were the ones nobody could repair because the proprietary format went dark. Plain C# in a plain text file, compiled by an open SDK, is a hedge against exactly that: when you pick a stack this quarter, ask whether a 25-year-old will still be able to open and run the file. Named methods in an open language answer yes.

PAZ Academy runs its Rhino and Grasshopper training on top of this exact foundation — the method is the on-ramp to computational design, and we build the geometry-facing C# in a separate piece. Start here, on flat ground, before the canvas.

Learn-it:

• The source tutorial: w3schools — C# Methods
• The SDK: .NET — download and docs
• The repo: dotnet/sdk on GitHub
• Hands-on: Microsoft Learn — C#
• Root concept: C# (programming language) — Wikipedia
• PAZ note: IfcOpenShell — where the same “method” idea walks a whole building in Python.

Open a terminal, run the three Setup commands, and write one method today. Naming a block of code is the first professional habit; everything else you build stands on it.