Anders Hejlsberg Style Guide⁠‍⁠​‌​‌​​‌‌‍​‌​​‌​‌‌‍​​‌‌​​​‌‍​‌​​‌‌​​‍​​​​​​​‌‍‌​​‌‌​‌​‍‌​​​​​​​‍‌‌​​‌‌‌‌‍‌‌​​​‌​​‍‌‌‌‌‌‌​‌‍‌‌​‌​​​​‍​‌​‌‌‌‌‌‍​‌​​‌​‌‌‍​‌‌​‌​​‌‍‌​‌​‌‌‌​‍​​‌​‌​​​‍‌‌‌​‌​‌‌‍‌‌​​‌​​​‍​‌​‌​‌‌‌‍‌​​‌‌‌‌​‍​​‌‌​​​‌‍​​​​‌​‌​‍​‌​‌‌​​​⁠‍⁠

Overview

Anders Hejlsberg created Turbo Pascal (the fastest compiler of its era), Delphi (RAD with native compilation), C# (managed language with modern features), and TypeScript (typed JavaScript at scale). His career spans four decades of making developers more productive through language and tooling innovation.

Core Philosophy

"A language is only as good as its tooling."

"Types should help you, not get in your way."

"The best type system is one that understands existing code."

Hejlsberg believes languages exist to serve developers—making them more productive, catching their errors, and enabling great tooling.

Design Principles

Developer Productivity First: Every feature should make developers faster.

Gradual Adoption: Meet developers where they are.

IDE-Driven Design: Consider tooling from day one.

Pragmatic Type Systems: Types that work with real code, not against it.

When Designing Languages

Always

• Consider the IDE experience for every feature

• Provide escape hatches for edge cases

• Enable gradual adoption of type safety

• Make common patterns easy

• Design for tooling (completion, refactoring, navigation)

• Maintain backward compatibility

Never

• Sacrifice developer experience for type purity

• Require full type coverage from day one

• Break existing code without migration paths

• Design features that can't be tooled

• Ignore the ecosystem of existing code

• Make simple things verbose

Prefer

• Structural typing over nominal (for flexibility)

• Type inference over explicit annotations

• Gradual typing over all-or-nothing

• Composition over inheritance

• Async/await over callbacks

• Null safety without verbosity

Code Patterns

Structural Typing (TypeScript)

// TypeScript: structural typing for flexibility // Types are shapes, not names

interface Point { x: number; y: number; }

function distance(p1: Point, p2: Point): number { return Math.sqrt((p2.x - p1.x) ** 2 + (p2.y - p1.y) ** 2); }

// Any object with x and y works const a = { x: 0, y: 0 }; const b = { x: 3, y: 4, label: "target" }; // Extra properties OK

distance(a, b); // Works! Both match Point's shape

// This enables typing existing JavaScript code // without requiring changes

Union Types and Type Guards

// Unions: represent values that could be multiple types type Result<T> = | { success: true; value: T } | { success: false; error: string };

function process<T>(result: Result<T>): T | null { // Type narrowing: compiler tracks which branch we're in if (result.success) { // TypeScript knows: result.value exists here return result.value; } else { // TypeScript knows: result.error exists here console.error(result.error); return null; } }

// Discriminated unions for state machines type State = | { status: "idle" } | { status: "loading" } | { status: "success"; data: string } | { status: "error"; message: string };

function render(state: State): string { switch (state.status) { case "idle": return "Ready"; case "loading": return "Loading..."; case "success": return state.data; // data available case "error": return state.message; // message available } }

Generics with Constraints

// Generics that work with real patterns

// Constrain to ensure properties exist function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] { return items.map(item => item[key]); }

const users = [ { name: "Alice", age: 30 }, { name: "Bob", age: 25 } ];

const names = pluck(users, "name"); // string[] const ages = pluck(users, "age"); // number[] // pluck(users, "foo"); // Error: "foo" not in User

// Mapped types: transform type shapes type Readonly<T> = { readonly [P in keyof T]: T[P]; };

type Partial<T> = { [P in keyof T]?: T[P]; };

type Required<T> = { [P in keyof T]-?: T[P]; };

// Conditional types: types that compute type NonNullable<T> = T extends null | undefined ? never : T; type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

Async/Await (C# Innovation)

// C#: async/await pioneered by Hejlsberg's team // Asynchronous code that reads like synchronous

public async Task<User> GetUserWithOrdersAsync(int userId) { // Each await yields control, resumes when ready var user = await _userRepository.GetByIdAsync(userId);

if (user == null)
    return null;

// Parallel async operations
var ordersTask = _orderRepository.GetByUserAsync(userId);
var preferencesTask = _preferenceRepository.GetAsync(userId);

await Task.WhenAll(ordersTask, preferencesTask);

user.Orders = ordersTask.Result;
user.Preferences = preferencesTask.Result;

return user;

}

// The compiler transforms this into a state machine // Developer writes linear code, gets async behavior

LINQ: Language-Integrated Query

// LINQ: query syntax integrated into the language // Type-safe, composable, provider-agnostic

var results = from user in users where user.Age >= 18 orderby user.Name select new { user.Name, user.Email };

// Method syntax (equivalent) var results = users .Where(u => u.Age >= 18) .OrderBy(u => u.Name) .Select(u => new { u.Name, u.Email });

// Works with any data source var dbResults = from order in db.Orders join customer in db.Customers on order.CustomerId equals customer.Id where order.Total > 1000 select new { customer.Name, order.Total };

// Deferred execution: query builds an expression tree // Execution happens when results are enumerated

Null Safety Without Pain

// C# nullable reference types: gradual null safety

// Enable per-file or per-project #nullable enable

public class UserService { // Non-nullable: must not be null public string GetDisplayName(User user) { return user.Name; // user cannot be null }

// Nullable: explicitly might be null
public User? FindUser(string email)
{
    return _repository.FindByEmail(email);
}

// Compiler tracks null state
public void ProcessUser(string email)
{
    var user = FindUser(email);
    
    // user.Name;  // Warning: possible null reference
    
    if (user != null)
    {
        // Compiler knows user is not null here
        Console.WriteLine(user.Name);  // OK
    }
    
    // Null-coalescing operators
    var name = user?.Name ?? "Unknown";
}

}

Pattern Matching Evolution

// C# pattern matching: evolved over versions

// Type patterns if (obj is string s) { Console.WriteLine(s.Length); }

// Switch expressions with patterns var description = shape switch { Circle { Radius: 0 } => "Point", Circle { Radius: var r } => $"Circle with radius {r}", Rectangle { Width: var w, Height: var h } when w == h => $"Square {w}x{w}", Rectangle { Width: var w, Height: var h } => $"Rectangle {w}x{h}", _ => "Unknown shape" };

// List patterns (C# 11) var result = numbers switch { [] => "Empty", [var single] => $"Single: {single}", [var first, .., var last] => $"First: {first}, Last: {last}", _ => "Other" };

Type Inference Done Right

// TypeScript: extensive type inference // Types inferred from usage, not declarations

// Inferred from initializer const message = "hello"; // string const count = 42; // number const items = [1, 2, 3]; // number[]

// Inferred from context const doubled = items.map(x => x * 2); // number[] // x is inferred as number from items being number[]

// Inferred return types function createUser(name: string, age: number) { return { name, age, createdAt: new Date() }; } // Return type inferred as { name: string; age: number; createdAt: Date }

// Generic inference function first<T>(items: T[]): T | undefined { return items[0]; }

const n = first([1, 2, 3]); // number | undefined const s = first(["a", "b"]); // string | undefined // T is inferred from the argument

IDE-First Feature Design

// Features designed with IDE support in mind

// 1. Go to definition works through types interface UserService { getUser(id: string): Promise<User>; saveUser(user: User): Promise<void>; }

// Ctrl+Click on getUser goes to interface definition

// 2. Rename works safely class OrderProcessor { processOrder(order: Order) { // Rename "order" → all usages update this.validate(order); this.save(order); } }

// 3. Completion knows valid options type Status = "pending" | "active" | "completed"; const status: Status = "|" // Autocomplete shows: pending, active, completed

// 4. Quick fixes provide migrations const config = { name: "app", // @ts-expect-error - Typing to add later untyped: someValue, // IDE suggests: Add type annotation };

Language Evolution Philosophy

Gradual Typing Adoption Path ══════════════════════════════════════════════════════════════

Phase Type Coverage Developer Action ────────────────────────────────────────────────────────────

1. Baseline 0% Rename .js → .ts, compiles!
2. Implicit 20% Add types to public APIs
3. Strict 60% Enable strict null checks
4. Complete 90%+ Full coverage, all strict

Key insight: Each phase provides value No phase requires rewriting code Migration can be file-by-file

Mental Model

Hejlsberg approaches language design by asking:

• What's the developer experience? Features must be usable

• How does this work in the IDE? Tooling is part of the design

• Can this be adopted gradually? Don't require big-bang rewrites

• Does this match real code patterns? Type systems should model reality

• Is there an escape hatch? Sometimes types are too strict

Signature Hejlsberg Moves

• Turbo Pascal speed: Compilation so fast it changed expectations

• Delphi's RAD: Visual design with native performance

• C# async/await: Made async mainstream and readable

• LINQ: Query syntax integrated into the language

• TypeScript's structural typing: Types for JavaScript at scale

• Gradual typing: Adopt at your own pace

• Nullable reference types: Null safety without rewrites

• Mapped/conditional types: Type-level computation