Skip to content

Programming Languages

Status: 🟢 Active  |  Owner: Architecture Team  |  Last Reviewed: 2025-Q4


Introduction

Programming language choices are some of the most consequential and longest-lived technical decisions an engineering organisation makes. A language selected for a service today may still be running in production in five, ten, or fifteen years. It shapes the talent pool you can hire from, the frameworks and libraries available to you, the runtime characteristics of your systems, and the cognitive load carried by engineers maintaining those systems long after the original authors have moved on.

This section documents the programming languages approved for use across the organisation, the standards and conventions for each approved language, and the governance framework that controls how language decisions are made, revisited, and retired.


Intent

Preventing Unmanaged Polyglot Sprawl

A common failure mode in growing engineering organisations is unchecked polyglot sprawl — the gradual accumulation of production systems written in an ever-expanding set of languages, each chosen by a team for locally rational reasons, but collectively creating an enormous operational and talent burden. Supporting ten languages means maintaining ten sets of CI/CD templates, ten sets of security scanning tools, ten training programmes, ten dependency management strategies, and ten oncall runbooks.

This does not mean we enforce a single language for everything. That approach sacrifices real productivity gains that come from using the right tool for the right job. Go's concurrency model and small binary footprint make it excellent for high-throughput systems work. Python's ecosystem dominance in data science and ML is irreplaceable. TypeScript's type system and ubiquitous tooling make it the natural choice for frontend and full-stack Node services.

What it means is that language choices are deliberate, governed, and supportable. Every language on the approved list has a sponsoring guild, a defined set of appropriate use cases, a full toolchain (linting, testing, CI templates, security scanning), and an internal community of practice. Languages not on the approved list require an explicit adoption process.

Per-Language Depth, Not Just Permission

Approving a language is not sufficient. Each language section in this portal goes beyond "yes, you can use this" to document the specific standards, patterns, idioms, and anti-patterns that apply. Knowing that Python is approved is not enough — engineers need to know which Python version, which dependency manager, which formatter and linter, which frameworks, and how to handle the common pitfalls that have caused problems in production.

A Clear Path for New Languages

The technology landscape changes. Rust has emerged as a compelling choice for systems work. New languages will emerge. The adoption process documented in Language Governance provides a structured path from proposal to pilot to approved, ensuring that new language additions are deliberate, well-supported, and reversible if they do not meet expectations.


Approved Languages at a Glance

Language Tier Primary Use Cases
Java Tier 1 — Strategic Backend services, enterprise APIs, batch processing
Python Tier 1 — Strategic Data engineering, ML/AI, scripting, lightweight APIs
TypeScript Tier 1 — Strategic Frontend, full-stack Node.js services, CLIs
Go Tier 2 — Supported High-throughput services, CLI tooling, infrastructure tooling
Rust Tier 3 — Emerging Systems programming, WASM, performance-critical native code
SQL Tier 1 — Strategic Relational data access, analytics, reporting
HCL / Terraform Tier 1 — Strategic Infrastructure as code

What You Will Find Here

Section Intent
Language Governance Approved language list, adoption process, deprecation policy, polyglot strategy
Java JDK versions, Spring Boot, Maven/Gradle, JVM tuning, LTS migration paths
Python Versions, PEP 8/Black, Poetry, type hints, FastAPI/Django, packaging
TypeScript & JavaScript tsconfig, Node.js policy, ESLint/Prettier, React, NestJS, monorepo tooling
Go Project structure, error handling, concurrency, modules, standard library policy
Rust Approved use cases, toolchain, Clippy, memory safety, crate approval
SQL & Query Languages Style guide, ORM policy, query performance, GraphQL, HQL/JPQL
Infrastructure & Config Languages HCL/Terraform, YAML, Dockerfile, shell scripting standards

Last reviewed: 2025-Q4  |  Owner: Architecture Team