---
title: "03 — Languages an Architect Should Know — And Why It's Plural"
uid: languages-an-architect-should-know
tags: ["programming-languages", "roadmap:software-architect", "java", "go", "python", "dotnet", "ruby", "javascript"]
excerpt: "No single language is right for everything. The architect's job is reading each language's trade-offs fluently enough to match strengths to the problem."
date: 2026-08-13T03:27:42+0000
source: https://www.aveshina.my.id/en/blog/languages-an-architect-should-know
---

"Pick your favorite and go deep" was my language strategy, and it skipped the part that matters for architecture. The model that corrected it: **no language is right for everything, and an architect evaluates languages by matching their strengths to the problem at hand** [1]. The list isn't a checklist of things to master equally; it's a spread of trade-offs an architect has to read fluently enough to make the call.

A programming language is a system of notation with a type system, variables, and error-handling mechanisms, and languages differ meaningfully on those axes [1]. The architect's question is never "which is best" in the abstract — it's "which fits _this_ team, _this_ problem, _this_ runtime."

## The JVM family: Java, Kotlin, Scala

Java is the widely-used, object-oriented, platform-independent workhorse — reliable and scalable, with extensive libraries and strong community support, dominant in large-scale enterprise applications, Android, and web services [2]. If an architect walks into a bank, Java is probably already there.

Kotlin is the modern, statically-typed sibling — fully interoperable with Java but more concise and safer (null safety being the headline), now the preferred Android language and gaining on the backend [2]. Scala combines object-oriented and functional programming on the JVM, favored for data engineering, high-concurrency backends, and expressive power [2]. The three share a runtime, so the choice between them is about how comfortable each is to write and which paradigm it follows, not deployment.

## Python: readability first, performance second

Python is multi-paradigm and interpreted — code runs as soon as it's written, and the syntax allows functional, procedural, or object-oriented styles [3]. It's frequently the first language recommended to new coders because of its focus on readability, consistency, and ease of use. The honest caveat the roadmap includes: it's "not especially performant in most production tasks" [3]. Python is the right call when developer speed and ecosystem (data, ML, scripting) matter more than raw runtime speed — and the wrong call for a latency-sensitive hot path — the few lines of code that run on every request and can't afford to be slow.

## Go: cloud-native and minimal

Go is Google's open-source language built for cloud services, CLI tools, and API development [4]. Its pitch is a small, opinionated surface, fast compilation, and first-class concurrency primitives (goroutines, channels). Go is the language I reach for when I want a single binary I can deploy anywhere and a runtime that handles concurrency without me inventing a framework for it.

## JavaScript and TypeScript: the web layer

JavaScript is the primary language of the web — browsers natively, and servers through Node.js [5]. TypeScript adds static typing on top, catching errors earlier and making large codebases maintainable. Architects on web or full-stack projects need both to evaluate frontend and backend technology choices honestly [5]. The JS/TS ecosystem moves fast and is unusually broad; the architect's job here is often _curbing_ adoption of novelty as much as enabling it.

## .NET: the enterprise Microsoft stack

The .NET ecosystem, built around C#, is widely used for enterprise applications, especially in Windows-centric environments, with large libraries and tooling for web, desktop, and cloud [6]. An architect in enterprise settings often needs to understand .NET's strengths around tooling, performance, and integration with Microsoft infrastructure [6]. Like the JVM family, .NET is a _platform commitment_ — once an organization standardizes on it, the tooling and vendor relationships compound.

## Ruby: developer happiness

Ruby is a high-level, dynamically-typed language that blends Perl, Smalltalk, Eiffel, Ada, and Lisp, focusing on simplicity and productivity with syntax that reads naturally [7]. It supports procedural, object-oriented, and functional programming. Ruby's reputation is built on developer happiness and the Rails convention-over-configuration philosophy — the right pick when the priority is shipping a web product fast with a small team.

## How I use this

The practical check is matching language traits to constraints. Latency-critical and cloud-deployed leans Go; enterprise and long-lived leans Java/Kotlin or .NET; data and ML lean Python; web UI leans JS/TS; fast-to-ship web product leans Ruby. Team familiarity weighs heavier than any of these — a team fluent in one ecosystem will out-ship a team struggling with a "better" language every time. The architect's fluency across the spread is what makes that match honest.

## References

[1] "Programming Language," Wikipedia. [Online]. Available: [https://en.wikipedia.org/wiki/Programming_language](https://en.wikipedia.org/wiki/Programming_language)

[2] "Java/Kotlin/Scala," roadmap.sh — Software Architect. [Online]. Available: [https://roadmap.sh/software-architect/java--kotlin--scala--swift](https://roadmap.sh/software-architect/java--kotlin--scala--swift)

[3] "Python," roadmap.sh — Software Architect. [Online]. Available: [https://roadmap.sh/software-architect/python](https://roadmap.sh/software-architect/python)

[4] "Go," roadmap.sh — Software Architect. [Online]. Available: [https://roadmap.sh/software-architect/go](https://roadmap.sh/software-architect/go)

[5] "JavaScript / TypeScript," roadmap.sh — Software Architect. [Online]. Available: [https://roadmap.sh/software-architect/javascript--typescript](https://roadmap.sh/software-architect/javascript--typescript)

[6] ".NET Framework Based," roadmap.sh — Software Architect. [Online]. Available: [https://roadmap.sh/software-architect/net-framework-based](https://roadmap.sh/software-architect/net-framework-based)

[7] "Ruby," roadmap.sh — Software Architect. [Online]. Available: [https://roadmap.sh/software-architect/ruby](https://roadmap.sh/software-architect/ruby)

```quiz
Q: An architect is choosing a language for a latency-critical, cloud-deployed service where fast compilation and simple deployment matter. Best fit from the roadmap's list?
- Python
- Go
- Ruby
correct: 1
explain: Go is built for cloud services and CLI tools, with fast compilation and first-class concurrency. Python prioritizes readability over runtime speed; Ruby prioritizes developer happiness for web products.

Q: What does TypeScript add on top of JavaScript?
- A new runtime separate from browsers and Node
- Static typing, catching errors earlier and aiding large-codebase maintenance
correct: 1
explain: TypeScript is a superset of JavaScript adding static types. It compiles to JavaScript and runs on the same runtimes.

Q: Kotlin's defining advantages over Java are…
- platform independence and a larger standard library
- concise syntax and safety features like null safety, while staying JVM-interoperable
correct: 1
explain: Kotlin is fully interoperable with Java but more concise and safer (notably null safety), which is why it became preferred for Android and is gaining on the backend.

Q: The roadmap's honest caveat about Python is that it is…
- not especially performant in most production tasks
- unsuitable for any production use
correct: 0
explain: Python prioritizes readability and ecosystem over raw runtime speed. It's the wrong pick for a latency-sensitive hot path (code that runs constantly and can't afford to be slow) but right when developer speed and the data/ML ecosystem matter.

Q: Why would an organization standardize on .NET or the JVM family?
- These are platform commitments where tooling and vendor relationships compound over time
- They are universally faster than other languages
correct: 0
explain: .NET and the JVM are ecosystem/platform commitments. Their value in enterprise settings comes from tooling, integration, and compounding standardization — not raw speed alone.
```