Post
An evidence-based deep-dive into popularity, performance, productivity, ecosystem maturity, and developer satisfaction across the programming landscape.
Executive Summary #
The global programming landscape in 2025–2026 is defined by three dominant forces: the AI-driven surge of Python, the TypeScript revolution in web development, and the steady rise of safety-focused systems languages like Rust and Go. This report synthesizes data from five major popularity indexes (TIOBE, Stack Overflow, RedMonk, GitHub Octoverse, and JetBrains), performance benchmarks, developer satisfaction surveys, and ecosystem analyses to provide a comprehensive comparison of the top 20 most popular programming languages.
Key findings: Python leads the TIOBE Index at 21.81% (February 2026) with a record-breaking peak of 26.98% in mid-2025, driven by its dominance in AI, machine learning, and data science. It saw a remarkable 7 percentage-point increase on the Stack Overflow Developer Survey from 2024 to 2025 alone, reaching 57.9% developer adoption. JavaScript remains the most widely used language by developers (66% on Stack Overflow), but TypeScript has overtaken both Python and JavaScript to become the #1 language on GitHub by monthly contributors as of August 2025 — the most significant language shift in over a decade. C# was named TIOBE’s Language of the Year for 2025, reflecting its growing cross-platform maturity and enterprise adoption.
On performance, compiled systems languages dominate: Rust achieves the fastest execution times (1.05 seconds in benchmark tests), followed closely by C (1.23s) and C++ (1.25s). Python is dramatically slower at 126.53 seconds — a trade-off developers accept for its productivity advantages and unmatched AI/ML ecosystem. Go occupies a sweet spot between performance and developer experience, completing benchmarks in 2.0 seconds with minimal memory overhead (16.3 MB).
Developer satisfaction data reveals a striking pattern: Rust is the most admired language for the ninth consecutive year (72.4% of users want to keep using it), followed by Gleam (70.8%), Elixir (65.9%), and Zig (64.2%). Meanwhile, Python and Go are the most desired languages that developers want to learn next, reflecting strong growth momentum.
The global developer population reached 47.2 million in 2025, up 50% from 31 million in 2022, with professional developers growing faster than amateurs. AI tool adoption is now mainstream: 85% of developers use AI tools regularly, and GitHub Copilot hit 20 million users in 2025. This AI wave is actively reshaping language preferences, with typed languages like TypeScript benefiting from AI-assisted coding reliability.
Ecosystem maturity varies enormously: npm leads with over 2 million packages and 4.4 trillion requests by end of 2024, while Rust’s crates.io has grown to 180,000+ crates with 20% growth in 2024. Package manager quality directly correlates with language adoption success — Cargo (Rust) is the most admired package manager at 71%, and uv (Python/Rust) achieved the highest admiration rate of any new technology this year at 74%.
The salary landscape shows specialized languages commanding significant premiums: Solidity ($167K), Erlang ($152K), Go ($146,879), and Rust ($130–170K) all exceed median developer compensation, while Python and JavaScript developers earn closer to the median due to larger talent pools.
Background and Context: How We Measure Programming Language Popularity #
Understanding programming language popularity requires recognizing that no single metric captures the full picture. Different indexes measure fundamentally different signals, and each has distinct strengths and blind spots. This section explains the five primary measurement frameworks used throughout this report, their methodologies, and what they actually tell us about language ecosystems.
TIOBE Index: Search Interest as a Proxy for Awareness
The TIOBE Programming Community Index, launched in 2001, measures programming language popularity based on search engine query volume across Google, Bing, Wikipedia, Amazon, YouTube, and 20+ other sites. It is updated monthly and provides ratings as percentages of total search interest.
What it captures: Broad mainstream awareness and visibility. A high TIOBE score means the language generates significant search traffic globally.
What it misses: Actual usage patterns. JavaScript ranks surprisingly low (#6 at 2.92% in February 2026) despite being used by 66% of developers, because web developers rarely search for “JavaScript programming” — they search for specific frameworks, libraries, or problems. Similarly, TypeScript ranks #32 on TIOBE despite being the #1 language on GitHub, because developers search for “React” or “Node.js” rather than “TypeScript.”
Best use case: Spotting mainstream attention shifts and long-term trends. C#’s rise to Language of the Year 2025 (+2.71% YoY) and R’s return to the top 10 (+1.14%) are meaningful signals that TIOBE captures well.
Stack Overflow Developer Survey: Self-Reported Professional Usage
The Stack Overflow Developer Survey is the largest annual survey of developers, collecting responses from tens of thousands of professionals worldwide. The 2025 edition had 31,771 respondents for language usage questions and over 65,000 total responses across all topics.
What it captures: Self-reported professional usage — what developers actually say they use at work and in personal projects. It also measures developer sentiment through “admired” (want to keep using) and “desired” (want to learn) metrics.
What it misses: The survey is self-selected and may overrepresent certain demographics (English-speaking, Western, professional developers). It doesn’t measure actual code output or repository activity.
Best use case: Understanding workplace adoption, developer satisfaction, and sentiment trends. Python’s 7 percentage-point jump from 2024 to 2025 is one of the largest single-year shifts ever recorded.
RedMonk Rankings: GitHub Activity + Stack Overflow Discussion
RedMonk takes a unique approach by combining two axes: GitHub code activity (pull requests, repository count) and Stack Overflow discussion activity (tag usage, question volume). Published bi-annually, these rankings predict future adoption trends rather than measuring current usage.
What it captures: Developer ecosystem momentum — the correlation between active coding and community discussion. RedMonk argues that languages with both high code traction and high discussion traction are most likely to grow.
What it misses: Languages with off-platform communities (e.g., Mathematica, MATLAB) are underrepresented. Private repositories on GitHub aren’t counted. AI coding assistants reducing Stack Overflow usage is now skewing the discussion axis, as RedMonk itself has noted in Q1 2026.
Best use case: Identifying languages with strong community momentum and predicting future growth. The top 3 (JavaScript, Python, Java) has been remarkably stable for years, reflecting entrenched ecosystems.
GitHub Octoverse: Actual Code Contribution Activity
GitHub’s annual Octoverse report measures real coding activity across its platform of 180+ million developers and 630 million repositories. It tracks commits, pull requests, contributor counts, and repository creation by language.
What it captures: What developers are actually writing and contributing to open source. This is the most direct measure of code output among all indexes.
What it misses: Private codebases (which dominate enterprise development), non-GitHub platforms, and languages used primarily in proprietary environments.
Best use case: Understanding open-source contribution patterns and real coding activity. TypeScript becoming #1 by monthly contributors in August 2025 is a watershed moment captured only by GitHub’s data.
JetBrains Developer Ecosystem Survey: Tool-Centric Insights
JetBrains’ annual survey (23,262 respondents in 2024) provides unique insights into tool usage, IDE preferences, and language adoption patterns from the perspective of professional developers who use JetBrains products. It introduced the “Language Promise Index” in 2024, combining audience growth over five years, stability of growth, and adoption intentions.
What it captures: Professional developer tooling choices and long-term language trajectory predictions. TypeScript’s growth from 12% (2017) to 35% (2024) is well-documented here.
What it misses: JetBrains users may be more likely to use certain languages (Java, Kotlin, Python, Go) that JetBrains IDEs support well, creating potential bias.
Best use case: Understanding professional tooling preferences and long-term language trajectory predictions.
Why Multiple Indexes Matter
Each index tells a different story because they measure different phenomena. TypeScript being #1 on GitHub but #32 on TIOBE is not a contradiction — it’s evidence that the language is heavily used in production code while generating relatively little standalone search interest (because it’s embedded in the JavaScript ecosystem). Python being #1 on TIOBE but #4 on Stack Overflow reflects its massive tutorial-search volume from learners and AI/ML practitioners, even though fewer professional developers report using it as their primary workplace language compared to JavaScript.
This report uses all five indexes (plus performance benchmarks and salary data) to construct a multi-dimensional picture of each language’s position in the ecosystem. No single ranking is definitive; the truth lies in the convergence (or divergence) across multiple measurement approaches.
The Top 20 Languages: Rankings and Trends #
Synthesizing data across all major indexes, the following 20 languages consistently appear in the top tiers of at least two or more measurement frameworks. This section presents each language with its cross-index ranking profile and key trend data.
Cross-Index Ranking Summary Table
| Language | TIOBE (Feb 2026) | Stack Overflow 2025 | RedMonk Q1 2026 | GitHub Octoverse 2025 |
|---|---|---|---|---|
| Python | #1 (21.81%) | #4 (57.9%) | #2 | #2-3 (overtaken by TS in Aug 2025) |
| JavaScript | #6 (2.92%) | #1 (66%) | #1 | #2-3 |
| TypeScript | #32 (0.47%) | #6 (43.6%) | #6 | #1 (Aug 2025) |
| Java | #4 (8.12%) | #7 (29.4%) | #3 | Top 5 |
| C# | #5 (6.83%) | #8 (27.8%) | #4 (tied) | Top 6 |
| C++ | #3 (8.55%) | #9 (23.5%) | #7 (tied) | Top 10 |
| C | #2 (11.05%) | #11 (22%) | #10 | Top 10 |
| PHP | — | #12 (18.9%) | #4 (tied) | Top 15 |
| Go | #16 (1.23%) | #13 (16.4%) | #12 | Growing rapidly |
| Rust | #14 (1.32%) | #14 (14.8%) | #20 | Growing rapidly |
| Swift | — | #20 (5.4%) | #11 | Top 15 |
| Kotlin | #20 (1.05%) | #15 (10.8%) | #14 (tied) | Top 15 |
| Ruby | — | #18 (6.4%) | #9 | Declining |
| R | #8 (2.19%) | #21 (4.9%) | #13 | Niche but growing |
| Shell/Bash | — | #5 (48.7%) | #14 (tied) | Top 10 |
| Dart | — | #19 (5.9%) | #18 (tied) | Growing (Flutter) |
| SQL | #9 (1.93%) | #3 (58.6%) | N/A* | N/A* |
| Scala | — | #28 (2.6%) | #14 (tied) | Stable niche |
| PowerShell | — | #10 (23.2%) | #17 | Growing in enterprise |
| Lua | — | #16 (9.2%) | Not in top 20 | Niche (gaming/embedded) |
*SQL and Shell/Bash are often excluded from RedMonk as they don’t fit the “programming language” criteria the same way. SQL is a query language; Shell is a scripting/utility language.
Tier Classification
Based on cross-index analysis, the top 20 languages fall into four distinct tiers:
Tier 1 — Universal Dominance (Python, JavaScript, TypeScript): These languages appear in the top 5 across all major indexes. Python dominates AI/ML and data science; JavaScript powers virtually all web development; TypeScript is rapidly becoming the default for new web projects. Together they represent the overwhelming majority of new development activity.
Tier 2 — Enterprise and Systems Backbone (Java, C#, C++, C): These languages power the world’s critical infrastructure. Java dominates enterprise backends and Android; C# leads in Microsoft ecosystems, game development (Unity), and cross-platform .NET; C++ is essential for performance-critical systems, game engines, and real-time applications; C remains foundational for operating systems, embedded devices, and system-level programming.
Tier 3 — Growing Contenders (Go, Rust, PHP, Swift, Kotlin): These languages have strong positions in specific domains but are growing. Go leads cloud-native development; Rust is the most admired language with government-backed momentum (CISA memory-safety mandates); PHP powers ~75% of websites via WordPress; Swift dominates iOS/macOS development; Kotlin is Android’s preferred language.
Tier 4 — Specialized and Niche (Ruby, R, Shell/Bash, Dart, SQL, Scala, PowerShell, Lua): These languages serve specific communities exceptionally well. Ruby excels in web development with Rails; R is the language of statistical computing; Shell/Bash is universal for system administration; Dart powers Flutter cross-platform apps; SQL is ubiquitous for databases; Scala serves big data (Spark) and functional programming enthusiasts; PowerShell dominates Windows administration; Lua excels in game scripting.
Key Trend Lines (2024–2026)
Python’s AI-driven explosion: Python’s 7 percentage-point jump on Stack Overflow (2024→2025) is the largest single-year increase ever recorded. Its TIOBE peak of 26.98% (July 2025) was the highest any language has ever achieved. The driver is unambiguous: AI, machine learning, and data science. Every major ML framework runs on Python, and the LLM SDK explosion on GitHub (1.1M+ repos, +178% YoY) is overwhelmingly Python-based.TypeScript’s web takeover: TypeScript becoming #1 on GitHub by monthly contributors in August 2025 represents the most significant language shift in over a decade. The transition from JavaScript to TypeScript is now the default for new web projects across React, Vue, Angular, Svelte, and Next.js. AI-assisted coding amplifies this trend — typed languages catch errors that would slip through in vanilla JavaScript.Rust’s steady climb: Despite ranking #20 on RedMonk and #14 on TIOBE, Rust is the most admired language for the 9th consecutive year (72.4% developer approval). The CISA memory-safety mandate (January 2026 deadline for critical infrastructure) is accelerating enterprise adoption. Rust job postings grew 35% YoY in 2025.C#’s quiet renaissance: Named TIOBE’s Language of the Year 2025, C# benefits from .NET’s cross-platform maturity, Unity game development growth, and strong enterprise adoption. Its +2.71% YoY TIOBE increase is the largest of any language.Go’s cloud-native dominance: Go demand grew 41% in job postings in 2025. It remains the language developers most aspire to work with on Stack Overflow. Its combination of simplicity, excellent concurrency (goroutines), and fast compilation makes it ideal for microservices and cloud infrastructure.Declining languages: Ruby fell out of TIOBE’s top 20 entirely in 2025. Objective-C (once ranked #9 or #10 since 2012) has steadily declined following Swift’s rise and may permanently exit the top 20. PHP remains stable but is not growing, with Cloudflare’s Emdash product potentially shifting WordPress-related demand toward TypeScript.
Feature Comparison: Paradigms, Typing, and Memory Management #
The design philosophy of each language fundamentally shapes its performance characteristics, developer experience, and ideal use cases. This section provides a systematic comparison of the top 20 languages across three critical dimensions.
Paradigm Classification
| Language | Primary Paradigm(s) | Notes |
|---|---|---|
| C | Procedural/Imperative | Structured programming, no OOP or FP built-in |
| C++ | Multi-paradigm | Procedural, OOP, generic, functional (C++11+) |
| Rust | Multi-paradigm | Systems-focused, ownership model, traits-based |
| Go | Procedural/Concurrent | Simplified OOP-like structs/interfaces, no inheritance |
| Java | Object-Oriented | Strict OOP, with lambda support (Java 8+) |
| Python | Multi-paradigm | OOP, functional, procedural — all first-class |
| JavaScript | Multi-paradigm | Prototype-based OOP, functional, event-driven |
| TypeScript | Multi-paradigm | Superset of JS, adds static types and interfaces |
| C# | Multi-paradigm | OOP, functional (LINQ), async/await, generics |
| PHP | Procedural/OOP | Historically procedural, modern PHP is strongly OOP |
| Swift | Multi-paradigm | OOP + protocol-oriented + functional patterns |
| Kotlin | Multi-paradigm | OOP, functional (coroutines), null-safety |
| Ruby | Object-Oriented | Pure OOP (everything is an object), metaprogramming |
| R | Functional/Procedural | Statistical computing, vectorized operations |
| Shell/Bash | Procedural/Scripting | Command-line automation, pipe-based workflows |
| Dart | Object-Oriented | Strongly typed, async/await, Flutter integration |
| Scala | Multi-paradigm | JVM-based, functional-first with OOP support |
| PowerShell | Object-Oriented/Scripting | .NET-based, pipeline of objects (not text) |
| Lua | Procedural/Multi-paradigm | Simple, embeddable, prototype-based OOP |
Type System Classification
| Language | Typing Discipline | Strength | Notes |
|---|---|---|---|
| C | Static | Weak | Explicit types, implicit conversions common |
| C++ | Static | Strong (mostly) | Templates add complexity; some unsafe casts possible |
| Rust | Static, inferred | Very strong | Type inference + strict borrow checker prevents entire classes of bugs |
| Go | Static, inferred | Strong | Simple type system, interfaces are structural (duck typing) |
| Java | Static, inferred (var) | Strong | Generics with type erasure; checked exceptions |
| Python | Dynamic | Strong | Type hints (PEP 484+) for static analysis tools |
| JavaScript | Dynamic | Weak/Strong mix | typeof null === 'object' ; loose equality pitfalls |
| TypeScript | Static, inferred | Strong | Structural typing; compiles to JS with full type safety |
| C# | Static, inferred (var) | Strong | Nullable reference types (C# 8+); pattern matching |
| PHP | Dynamic (weak) → Stronger | Improving | PHP 7+ strict types; union types, match expressions in PHP 8 |
| Swift | Static, inferred | Very strong | Optionals eliminate null pointer errors; value semantics |
| Kotlin | Static, inferred | Very strong | Null safety by design; sealed classes; data classes |
| Ruby | Dynamic | Strong | Duck typing; no type declarations needed |
| R | Dynamic | Weak | Vectorized; type coercion can be surprising |
| Shell/Bash | Dynamic (all strings) | Very weak | Everything is a string; numeric handling is awkward |
| Dart | Static, inferred | Strong | Sound null safety (Dart 2.12+); AOT compilation for Flutter |
| Scala | Static, inferred | Very strong | Advanced type system; implicits; dependent types |
| PowerShell | Static/Dynamic mix | Strong | .NET types; pipeline passes objects not text |
| Lua | Dynamic | Weak | Single table type; numeric/string coercion |
Memory Management Approaches
| Language | Memory Model | Garbage Collection | Manual Control | Notes |
|---|---|---|---|---|
| C | Manual | None | Full (malloc/free) | Developer responsible for all memory; prone to leaks and buffer overflows |
| C++ | Manual/RAII | Optional (boost, etc.) | Full with smart pointers | RAII pattern; unique_ptr/shared_ptr; still unsafe by default |
| Rust | Ownership/Borrowing | None (deterministic) | Compile-time enforcement | Zero-cost abstractions; borrow checker prevents data races and memory errors at compile time |
| Go | Automatic (GC) | Yes (concurrent, low-latency) | Limited | GC s are minimal (< 1ms typical); no manual control needed |
| Java | Automatic (GC) | Yes (multiple GC algorithms) | None | G1, ZGC, Shenandoah; JIT optimization at runtime |
| Python | Reference counting + GC | Yes (cyclic GC) | Limited (weakref) | CPython uses ref counting; PyPy has tracing GC |
| JavaScript | Automatic (GC) | Yes (V8, SpiderMonkey) | None | V8’s generational GC is highly optimized for web workloads |
| TypeScript | Automatic (GC) | Same as JS | None | Inherits JS runtime memory management |
| C# | Automatic (GC) | Yes (generational, 3 generations) | Limited (unsafe blocks, Span | .NET 8+ has significant GC improvements; AOT compilation available |
| PHP | Reference counting + GC | Yes (cyclic GC) | None | Per-request lifecycle simplifies memory concerns for web apps |
| Swift | ARC (Automatic Reference Counting) | Deterministic (ARC) | Limited (weak/unowned refs) | No traditional GC; compile-time reference counting |
| Kotlin | Automatic (GC) | Same as Java (JVM) | None | Coroutines are lightweight but still managed by JVM GC |
| Ruby | Automatic (GC) | Yes (generational in Ruby 2.7+) | Limited | Traditionally slow GC; improving with YJIT in Ruby 3.1+ |
| R | Automatic (GC) | Yes (copy-on-modify) | None | Copy-on-modify semantics can cause memory duplication |
| Shell/Bash | OS-managed | N/A | N/A | Scripts run in ephemeral processes; no persistent memory concerns |
| Dart | Automatic (GC) | Yes (generational, isolates) | None | Isolates provide true parallelism without shared memory |
| Scala | Automatic (GC) | Same as Java (JVM) | None | JVM GC applies; Akka actors avoid shared mutable state |
| PowerShell | Automatic (GC) | Same as .NET (C# runtime) | None | Inherits .NET’s generational GC |
| Lua | Automatic (GC) | Yes (incremental) | Limited | Designed for embedding; incremental GC minimizes s |
Key Design Trade-offs
Safety vs. Performance: Rust achieves both memory safety and C-level performance through compile-time borrow checking, but at the cost of a steep learning curve and longer compile times. C and C++ offer maximum performance but require manual memory management that introduces entire classes of bugs (buffer overflows, use-after-free, data races).
Developer Productivity vs. Runtime Efficiency: Python’s dynamic typing and simple syntax enable rapid development — a factor of 100x slower in raw execution (126.53s vs. 1.05s for Rust in benchmarks) but acceptable because most Python workloads delegate heavy computation to compiled libraries (NumPy, TensorFlow) written in C/C++.
Static vs. Dynamic Typing: The shift toward static typing is one of the clearest trends in the industry. TypeScript’s rise from 12% to 43.6% adoption (Stack Overflow) demonstrates that developers want type safety without sacrificing JavaScript’s ecosystem. Go’s structural typing and Rust’s type inference show that modern static languages can be concise and developer-friendly.
Concurrency Models: Languages differ radically in their approach to concurrent programming:
Go: Goroutines and channels — lightweight, simple, but GC-managedRust: Fearless concurrency through ownership — compile-time data race preventionJava/C#/Kotlin: Thread-based with modern async/await patternsElixir/Erlang (not in top 20 by usage but influential): Actor model via lightweight processesJavaScript: Single-threaded event loop with async/await — no true parallelism in the browser
Runtime Performance Analysis #
Performance is one of the most concrete dimensions for comparing programming languages, though it is also the most context-dependent. A language that excels at CPU-bound computation may perform poorly for I/O-heavy workloads, and vice versa. This section synthesizes benchmark data from multiple sources and provides realistic performance expectations.
Benchmark Methodology and Caveats
The primary source for raw execution speed comparisons is The Computer Language Benchmarks Game (formerly The Great Computer Language Shootout), which evaluates standardized microbenchmarks including:
Low I/O benchmarks:fannkuch-redux
,n-body
,spectral-norm
— exercise CPU and cache performanceHigh I/O benchmarks:mandelbrot
,fasta
,k-nucleotide
,reverse-complement
— test disk and network throughputContentious benchmarks:binary-trees
,pidigits
,regex-redux
— allow varying approaches and libraries
These are microbenchmarks, not real-world applications. They are “easy to use, easy to measure, but far from realistic,” as the project itself acknowledges. Nevertheless, they provide valuable relative comparisons of language-level performance characteristics. A secondary source is the programming-language-benchmarks.vercel.app project, which runs benchmarks in a consistent CI environment across 28 languages and 18 computational problems.
Raw Execution Speed: The Performance Hierarchy
Based on benchmark data from multiple sources, languages fall into clear performance tiers:
| Tier | Languages | Typical Benchmark Time | Relative to C |
|---|---|---|---|
| Tier 1 (Systems) | Rust, C, C++, Fortran | 1.05–1.25s | 0.85x–1.0x |
| Tier 2 (Near-Native) | Swift, Java, Kotlin | 1.5–1.75s | 1.2x–1.4x |
| Tier 3 (Managed) | Go, C#, Dart | 2.0–3.0s | 1.6x–2.4x |
| Tier 4 (JIT-Optimized) | JavaScript (V8), PHP (OPcache) | 2.5–3.5s | 2x–2.8x |
| Tier 5 (Interpreted) | Python, Ruby, R, Lua, Bash | 20–127+s | 16x–100x+ |
Key observations:
Rust is the fastest, achieving 1.05 seconds in standard benchmarks — marginally faster than C (1.23s) and C++ (1.25s). This is remarkable because Rust enforces memory safety at compile time without sacrificing runtime performance. However, Rust uses more memory (376 MB vs. 348 MB for C) due to additional compile-time checks and data structure layouts.Java’s JIT compilation brings it close to native speeds (1.63s), with modern JVMs capable of optimizing hot code paths to near-C performance. The trade-off is slower startup time (JVM initialization) and higher memory overhead (20.2 MB base).Go’s sweet spot: At 2.0 seconds execution time with only 16.3 MB memory, Go offers an excellent balance between speed and resource efficiency. Its simple garbage collector produces minimal s (< 1ms), making it ideal for latency-sensitive services.Python’s dramatic gap: At 126.53 seconds — roughly 100x slower than Rust — Python’s interpreted nature imposes a massive performance penalty for raw computation. However, this is misleading in practice: Python developers rarely write CPU-bound code in pure Python. Instead, they use compiled libraries (NumPy, Pandas, TensorFlow) written in C/C++/Fortran, which execute at near-native speeds. The “Python is slow” narrative applies to the language runtime, not the ecosystem.
Web Framework Performance (TechEmpower Round 23)
For I/O-bound web workloads, the TechEmpower Framework Benchmarks provide more realistic measurements:
Rust frameworks (Actix, Axum) consistently rank in the top tier, handling hundreds of thousands of requests per secondGo frameworks rank in the top 15% among 400+ tested frameworks**.NET 8 (C#)** showed significant performance improvements over previous roundsJava frameworks (Spring Boot, Quarkus, Vert.x) are highly competitive with Netty-based HTTP parsing optimizationsPython frameworks lag in raw throughput but FastAPI (built on Starlette and Pydantic) has gained +5 percentage points in adoption due to its async capabilities and developer experience
Memory Efficiency
Memory usage varies dramatically:
| Language | Base Memory Usage | Notes |
|---|---|---|
| Go | 16.3 MB | Extremely efficient; ideal for microservices |
| Python | 13.6 MB | Low base, but grows rapidly with libraries |
| Java | 20.2 MB | JVM overhead; can be reduced with GraalVM native image |
| Swift | 22 MB | Optimized for Apple ecosystem |
| Kotlin | 25 MB | Inherits JVM memory model |
| PHP | 28 MB | Per-request model; memory freed after each request |
| C | 348 MB | High in benchmarks due to data structures, not language overhead |
| C++ | 360 MB | Similar to C; templates can increase binary size |
| Rust | 376 MB | Higher than C/C++ due to safety checks and data layouts |
Note: The high memory figures for C, C++, and Rust in benchmarks reflect the data structures used in the benchmark problems (e.g., large arrays, trees), not inherent language overhead. In real-world systems programming, these languages have minimal runtime memory footprints.
Startup Time Considerations
Startup time is increasingly important for serverless and containerized workloads:
Fastest startup: C, C++, Rust (compiled to native binary — near-instant)Moderate startup: Go (fast compilation, small binaries), PHP (per-request model)Slower startup: Java/JVM languages (JIT warmup period; GraalVM native image helps), .NET (improving with AOT in .NET 8)Variable startup: JavaScript/TypeScript (depends on runtime — Node.js is fast, browser depends on page load)Interpreted: Python, Ruby (startup includes interpreter initialization + module )
When Performance Matters (and When It Doesn’t)
The critical insight is that raw execution speed matters enormously for some workloads and barely at all for others:
Matters critically: Game engines, real-time systems, high-frequency trading, embedded devices, operating system kernels, database enginesMatters moderately: High-throughput web services, data processing pipelines, compiler/runtime developmentMatters less: Web applications (where I/O and network latency dominate), data science (where optimized libraries handle computation), scripting and automation, prototyping
For most web applications, the bottleneck is database queries, network latency, and API calls — not the programming language’s execution speed. A Python web server handling 100 requests/second is perfectly adequate for 99% of websites. The choice of language should be driven by developer productivity, ecosystem fit, and team expertise, with performance optimization applied selectively to hot paths.
Developer Productivity and Satisfaction #
While runtime performance is measurable and objective, developer productivity is notoriously difficult to quantify. This section draws on the most reliable available data: self-reported satisfaction from the Stack Overflow Developer Survey, adoption patterns from JetBrains, and the qualitative signals embedded in “admired” and “desired” metrics.
The Most Admired Languages (Stack Overflow 2025)
The “admired” metric measures what percentage of developers who have used a language want to continue using it. This is the strongest available proxy for developer satisfaction:
| Rank | Language | Admiration Rate | Desired Rate | Gap (Desired − Admired) |
|---|---|---|---|---|
| 1 | Rust | 72.4% | 29.2% | -43.2pp |
| 2 | Gleam | 70.8% | 3.1% | -67.7pp |
| 3 | Elixir | 65.9% | 5.8% | -60.1pp |
| 4 | Zig | 64.2% | 7.7% | -56.5pp |
| 5 | Swift | 65.9% | 6.5% | -59.4pp |
| 6 | Svelte (framework) | 62.4% | 11.1% | -51.3pp |
| 7 | Phoenix (framework) | 79.0% | 4.0% | -75.0pp |
The Rust phenomenon: Rust’s 9th consecutive year as the most admired language is remarkable in an industry where developer preferences shift rapidly. The borrow checker — Rust’s compile-time memory safety mechanism — frustrates newcomers but converts them into evangelists once mastered. The language eliminates entire classes of bugs (null pointer dereferences, buffer overflows, data races, use-after-free) at compile time, creating a development experience that experienced Rust developers describe as “safe and fast.”
The niche satisfaction pattern: Gleam, Elixir, and Zig all have high admiration rates but very low usage. This is the classic “hidden gem” pattern: developers who discover these languages love them, but the barrier to adoption (learning curve, ecosystem maturity, hiring difficulty) keeps mainstream adoption low. Phoenix (Elixir’s web framework) at 79% admiration is the most admired web framework in the survey, but only 2.4% of developers use it.
The Most Desired Languages
The “desired” metric measures what percentage of developers want to learn a language they haven’t yet used:
| Language | Desired Rate | Current Usage (SO 2025) |
|---|---|---|
| Python | 56.4% | 57.9% |
| SQL | 56.4% | 58.6% |
| TypeScript | 58.0% | 43.6% |
| Go | 52.8% | 16.4% |
| Kotlin | 51.0% | 10.8% |
Key insight: Python and SQL are both highly desired AND highly used — they’re already mainstream but continue to attract new developers. TypeScript and Go show the strongest growth potential: high desire (58% and 52.8%) with relatively lower current usage, indicating significant room for adoption growth. Kotlin’s 51% desire rate at only 10.8% usage suggests it remains under-adopted relative to developer interest, likely due to its association with Android development limiting perceived applicability.
Learning Curve and Accessibility
Languages can be classified by their learning curve:
Low barrier (beginner-friendly):
Python: Universally recommended as a first language. Clean syntax, extensive tutorials, forgiving error messages. The #1 language for learners on Stack Overflow (71.8% of learners use it).JavaScript: Easy to start (runs in any browser), but the path from beginner to professional is long due to the ecosystem’s complexity and historical baggage.Ruby: Elegant syntax designed for developer happiness (“programmer joy”), though declining popularity affects learning resources.
Moderate barrier:
TypeScript: Easy for JavaScript developers; adds type system concepts that have a learning curve but pay off in maintainability.Go: Deliberately simple — only 25 keywords. The concurrency model (goroutines/channels) requires mental shift but is learnable.Swift: Modern syntax, excellent documentation, Apple’s investment in education tools.PHP: Easy to start, harder to master modern practices (dependency injection, testing, PSR standards).
High barrier:
Rust: The borrow checker is the most commonly cited barrier. Developers report 3–6 months to become productive. The CISA memory-safety mandate may force enterprise adoption regardless of learning curve.C/C++: Manual memory management, complex syntax (especially C++ templates), and subtle undefined behavior make these languages dangerous for beginners.Scala: Advanced type system, functional programming concepts, and JVM ecosystem complexity create a steep initial climb.
Developer Experience with AI Tools
The integration of AI coding assistants is reshaping developer productivity across all languages. Key data points from Stack Overflow 2025:
81.4% of developers have used OpenAI GPT models for development work42.8% use Claude Sonnet;35.3% use Gemini FlashCursor(AI-enabled editor) is used by 17.9% of all respondents and 19.3% of professional developers — the fastest-growing IDE categoryClaude Code is used by 9.7% of respondents, growing rapidly
Impact on language choice: Typed languages benefit disproportionately from AI-assisted coding. When AI generates code, type systems catch the mistakes the AI makes at compile time rather than at runtime. This explains TypeScript’s rise to #1 on GitHub — developers using AI tools prefer the safety net that types provide. As GitHub’s Octoverse 2025 report states: “TypeScript’s rise illustrates how developers are shifting toward typed languages that make agent-assisted coding more reliable in production.”
Productivity Trade-offs: The Full Picture
The relationship between language design and developer productivity involves fundamental trade-offs:
| Language | Development Speed | Code Maintainability | Debugging Ease | Learning Curve |
|---|---|---|---|---|
| Python | ★★★★★ | ★★★★ | ★★★★ | ★★★★★ |
| JavaScript | ★★★★☆ | ★★★☆ | ★★★☆ | ★★★★☆ |
| TypeScript | ★★★★☆ | ★★★★★ | ★★★★★ | ★★★☆☆ |
| Go | ★★★★☆ | ★★★★☆ | ★★★★☆ | ★★★★☆ |
| Rust | ★★★☆☆ | ★★★★★ | ★★★★☆ | ★★☆☆☆ |
| Java | ★★★☆☆ | ★★★★☆ | ★★★★☆ | ★★★☆☆ |
| C++ | ★★☆☆☆ | ★★★☆☆ | ★★☆☆☆ | ★★☆☆☆ |
| Ruby | ★★★★★ | ★★★☆☆ | ★★★☆☆ | ★★★★☆ |
The productivity paradox: Languages that enable the fastest initial development (Python, Ruby) can become harder to maintain at scale due to dynamic typing and lack of compile-time safety. Languages with higher upfront friction (Rust, TypeScript, Go) tend to produce more maintainable code with fewer runtime bugs. The “right” choice depends on project lifecycle: rapid prototyping favors Python; long-lived systems favor Rust or Go.
Ecosystem and Toolchain Maturity #
A language’s ecosystem — its package manager, standard library, frameworks, IDE support, testing tools, and community resources — is often more important than the language itself. This section evaluates ecosystem maturity across the top 20 languages.
Package Manager Landscape
Package managers are the backbone of modern development, and their quality directly impacts developer experience:
| Language | Package Manager | Packages Available | Admiration Rate (SO 2025) | Key Characteristics |
|---|---|---|---|---|
| JavaScript/TypeScript | npm | 2.2M+ | 45.0% | Largest ecosystem; dependency hell challenges; pnpm emerging as faster alternative |
| Python | pip/PyPI | 500K+ | 45.0% | Massive ecosystem; dependency resolution historically problematic; uv (Rust-based) at 74.2% admiration |
| Rust | Cargo | 180K+ | 70.8% | Excellent dependency resolution; built-in tooling; sparse index for faster resolution |
| Java | Maven/Central | 47M+ artifacts | 34.8% | Mature but verbose; Gradle (42.1%) gaining ground for modern builds |
| C#/.NET | NuGet | 350K+ | 53.8% | Well-integrated with Visual Studio; improving cross-platform support |
| Go | go modules | N/A (centralized) | N/A | Built into language toolchain; no central registry needed; simple and reliable |
| PHP | Composer | 600K+ | 46.9% | PSR standards improved ecosystem quality significantly |
| Swift | Swift Package Manager | Growing | N/A | Apple-led; improving rapidly; still catching up to npm/PyPI scale |
| Kotlin | Maven/Gradle | Shared with Java | — | Inherits Java’s ecosystem; adds Kotlin-specific libraries |
| Ruby | RubyGems/Bundler | 150K+ | N/A | Bundler solved dependency management; ecosystem mature but not growing |
| Dart | pub.dev | 10K+ | N/A | Smaller but focused on Flutter/Dart ecosystem |
| R | CRAN | 20K+ | N/A | Strict quality control; slower release cycle; excellent for statistics |
Cargo (Rust) as the gold standard: At 70.8% admiration — the highest of any package manager — Cargo exemplifies what modern package management should be: deterministic builds, integrated documentation, built-in testing, and reliable dependency resolution. Its sparse index feature addresses the initial sync performance problem that plagues full-index systems like Cargo’s original design.
The npm ecosystem paradox: npm is the largest package ecosystem by far (2.2M+ packages, 4.4 trillion requests by end of 2024), but its admiration rate (45%) is moderate. The sheer volume includes many abandoned, duplicate, or low-quality packages. The rise of pnpm (13.4% usage, 53.9% admiration) and Bun (5.5% usage, 55.8% admiration) reflects developer frustration with npm’s performance and reliability issues.
uv as the dark horse: uv, a Python package manager built in Rust, achieved the highest admiration rate of any new technology in the 2025 Stack Overflow survey at 74.2%. This suggests that Python developers are eager for better tooling and that Rust-built developer tools are gaining trust.
IDE and Editor Support
IDE quality varies dramatically across languages:
| Language | Primary IDE(s) | IDE Usage (SO 2025) | Quality Assessment |
|---|---|---|---|
| JavaScript/TypeScript | VS Code (75.9%), WebStorm (8.3%) | Excellent | VS Code dominates; TypeScript support is best-in-class |
| Python | VS Code, PyCharm (14.2%), Jupyter (12.0%) | Excellent | PyCharm is the gold standard; Jupyter essential for data science |
| Java | IntelliJ IDEA (28.4%), Eclipse (6.7%), VS Code | Excellent | IntelliJ is widely considered the best IDE for any language |
| C# | Visual Studio (29.0%), VS Code, Rider (7.8%) | Excellent | Visual Studio remains unmatched for .NET development |
| Rust | VS Code, RustRover (3.3%), IntelliJ plugins | Good | Improving rapidly; rust-analyzer provides excellent LSP support |
| Go | VS Code, GoLand, Vim/Neovim | Good | Language server is built into the toolchain; no heavyweight IDE needed |
| C/C++ | VS Code, CLion, Visual Studio, Vim/Neovim | Moderate | Fragmented tooling; IntelliSense quality varies by project complexity |
| PHP | PhpStorm (6.4%), VS Code, Laravel-specific tools | Good | PhpStorm is excellent; ecosystem tools are framework-dependent |
| Swift | Xcode (10.6%) | Excellent for Apple | Xcode is the only viable option for iOS development; tightly integrated |
| Kotlin | IntelliJ IDEA, Android Studio (14.8%), VS Code | Excellent | Inherits JetBrains’ excellent Java tooling |
VS Code’s dominance: At 75.9% usage among all respondents and 76.2% among professional developers, Visual Studio Code is the most used development environment by a wide margin. Its extension ecosystem provides varying quality support for different languages — best for JavaScript/TypeScript and Python, good for Rust and Go, moderate for C/C++.
AI-enabled editors emerging: Cursor (17.9%), Claude Code (9.7%), and Windsurf (4.9%) represent a new category of AI-integrated IDEs. These tools are growing rapidly and may reshape the development experience across all languages.
Framework Ecosystem Strength
The quality and maturity of a language’s frameworks determine its practical utility:
Web frameworks:
JavaScript/TypeScript: React (44.7%), Next.js (20.8%), Vue.js (17.6%), Angular (18.2%), Svelte (7.2%) — the most diverse and competitive ecosystemPython: FastAPI (14.8%, +5pp YoY), Django (12.6%), Flask (13.2%) — FastAPI’s growth reflects the async Python renaissanceJava: Spring Boot (15.6%) — enterprise standard, but heavy; Quarkus and Micronaut gaining for cloud-nativeC#: ASP.NET Core (21.3%) — highly competitive with Node.js in performance benchmarksPHP: Laravel (9.3%), Symfony (4.3%) — Laravel dominates the modern PHP ecosystemRuby: Ruby on Rails (6.2%) — mature, opinionated, but declining
Data science/AI frameworks:
Python: TensorFlow, PyTorch, Hugging Face, scikit-learn, Pandas — unmatched ecosystem; no serious competitorR: ggplot2, dplyr, tidymodels — excellent for statistics and visualization; smaller ML ecosystemJulia(not in top 20 by usage): Growing in scientific computing but still niche
Community Size and Health
Community vitality is measured by Stack Overflow tag activity, GitHub Stars, conference presence, and documentation quality:
Largest communities: JavaScript, Python, Java — millions of developers, thousands of tutorials, extensive Q&A on Stack OverflowStrong and growing: TypeScript, Go, Rust — active communities with strong momentum and excellent documentationEstablished but stable: C#, C++, PHP — mature communities with steady engagement but limited growthNiche but passionate: Elixir, Zig, Gleam — small communities with extremely high satisfaction and quality discourse
The community-platform shift: AI tools are changing how developers seek help. Stack Overflow remains the most used community platform (84.2%), but its role is evolving as developers increasingly turn to AI assistants for immediate answers. RedMonk has noted that AI coding assistants reducing developer reliance on Stack Overflow is slowing tag growth and questioning whether discussion activity should remain an axis of language rankings.
Industry Adoption and Use Cases #
Each programming language has carved out specific domains where it is the default choice. Understanding these use case mappings is essential for making informed technology decisions.
Domain-to-Language Mapping
| Domain | Primary Languages | Secondary/Alternative Languages | Notes |
|---|---|---|---|
| Web Frontend | JavaScript, TypeScript | Dart (Flutter web), Svelte | TypeScript now default for new projects; JS remains for legacy |
| Web Backend | JavaScript/TS (Node.js), Python, Java, C#, Go, PHP, Ruby | Rust, Elixir | Node.js 48.7% usage; FastAPI growing fast (+5pp); Spring Boot enterprise standard |
| Mobile (iOS) | Swift, Objective-C | Dart (Flutter), Kotlin (multiplatform) | Swift dominates; Flutter gaining for cross-platform |
| Mobile (Android) | Kotlin, Java | Dart (Flutter) | Kotlin is Google’s preferred language; 10.8% SO adoption |
| Cross-platform Mobile | Dart (Flutter) | JavaScript/TS (React Native), Kotlin Multiplatform | Flutter growing rapidly; React Native still has larger ecosystem |
| AI/Machine Learning | Python | R, Julia, C++ (for performance) | Python is undisputed; PyTorch and TensorFlow dominate |
| Data Science/Analytics | Python, R, SQL | Julia, MATLAB | Python for ML; R for statistics; SQL for data extraction |
| Systems Programming | C, C++, Rust | Go (for some systems work) | Rust gaining share via safety guarantees and CISA mandate |
| Embedded/IoT | C, C++, Rust, Lua, MicroPython (2.3%) | Zig, Assembly | Memory and performance constraints drive language choice |
| Game Development | C++, C#, Python (tooling) | Rust, Lua (scripting) | Unity (C#) and Unreal (C++) dominate; Godot uses GDScript/Python |
| Cloud-Native/Microservices | Go, Java, C#, Rust | Python, JavaScript | Go designed for this; Kubernetes/Docker written in Go |
| DevOps/Infrastructure | Shell/Bash, Python, Go, PowerShell | Ruby (Chef), JavaScript (Terraform providers) | Bash 48.7% usage; Terraform (Go) is IaC standard |
| Database Development | SQL, PL/pgSQL, T-SQL | Python (analytics), Java (application layer) | PostgreSQL most admired DB (65.5%) |
| Blockchain/Smart Contracts | Solidity ($167K avg salary), Rust (Solana) | Go (Ethereum client), JavaScript | Niche but extremely high-paying |
| Scientific Computing | Python, Fortran, C++, R | Julia | Fortran still used in supercomputing; Julia growing |
| Enterprise Backend | Java, C#, Python, Go | Ruby, PHP | Java/Spring and C#/.NET are enterprise standards |
Job Market Data (United States)
Job posting data reveals which languages have the strongest demand:
| Language | Estimated US Job Postings | YoY Growth | Salary Range (US) |
|---|---|---|---|
| Python | 64,000+ | +7pp adoption | $125,740 avg |
| Java | 43,000+ | Stable | $117K–$150K |
| JavaScript | 30,000+ | Stable | $117K–$155K |
| C# | Significant | +2.71% TIOBE | $112,515 avg |
| Go | Growing rapidly | +41% demand growth | $146,879 avg |
| Rust | Smaller but fast-growing | +35% YoY | $130K–$170K |
| Solidity | Niche but premium | High demand/low supply | $167,000 avg |
The demand-to-supply ratio matters more than raw job counts. Rust and Go have fewer total postings than Python, but they also have far fewer available developers (14.8% and 16.4% of the developer population vs. 57.9% for Python). The math favors specialized languages for individual career strategy.
Geographic Patterns
North America: JavaScript/TypeScript and Python dominate; Go strong in cloud infrastructure; Rust growing in security-focused rolesEurope: Strong Java and C# presence (enterprise); Python leading in data/AI; Go popular in fintechAsia-Pacific: Python surging (especially India, China); JavaScript dominant for web; Go growing rapidlyLatin America: Growing Python and JavaScript communities; remote work opportunities driving language choices
Competing Perspectives and Controversies #
The programming language landscape is not free of controversy. Several debates shape how we interpret the data presented above.
“Python vs. JavaScript: Which Is More Popular?”
This question has no single answer because it depends entirely on the measurement methodology:
TIOBE says Python(#1 at 21.81% vs. JavaScript’s #6 at 2.92%) — but this measures search interest, not usage** Stack Overflow says JavaScript**(66% vs. Python’s 57.9%) — but this is self-reported and may overcount casual usage** GitHub Octoverse says TypeScript**(#1 by contributors) — but this only counts open-source code on GitHub
The truth is that both languages are enormously popular in different contexts. JavaScript is the language of the web; Python is the language of AI and data. They are not competitors so much as complementary tools that serve different domains. The real competitor to JavaScript is TypeScript (its superset), and the real competitor to Python in AI/ML is… nothing yet. Julia has potential but remains niche (1.4% SO usage).
“Will Rust Replace C/C++?”
The narrative that Rust will replace C and C++ is pervasive but nuanced. The evidence suggests:
Arguments for replacement:
- Rust provides memory safety without sacrificing performance — the primary motivation for its design
- The CISA memory-safety mandate (January 2026) requires critical infrastructure manufacturers to publish roadmaps for memory-safe languages
- Linux kernel now accepts Rust code (merged in 2022); Windows, Firefox, and Chrome all incorporate Rust
- Rust job postings grew 35% YoY; developer admiration is at 72.4%
Arguments against full replacement:
- C and C++ have decades of existing code that will not be rewritten (automotive, aerospace, embedded)
- The learning curve for Rust is steep; many organizations lack the bandwidth for a language transition
- C remains simpler for certain use cases (boots, kernel modules where every byte matters)
- C++ continues to evolve (C++23, C++26) with improved safety features
Most likely outcome: Gradual coexistence rather than replacement. Rust will grow in new projects and critical security-sensitive code, while C/C++ persist in legacy systems and domains where their simplicity or existing investments are irreplaceable. The transition timeline is measured in decades, not years.
“Is the TIOBE Index Meaningful?”
TIOBE is one of the most widely cited language rankings but also one of the most criticized:
Criticism: It measures search engine queries, not actual usage. A language can be popular because people are learning it (Python), troubleshooting it (JavaScript), or debating it (Rust) — these are qualitatively different signals.Defense: Search interest is a valid proxy for mainstream awareness and long-term trends. TIOBE’s 25-year history provides valuable longitudinal data.The TypeScript problem: TypeScript at #32 on TIOBE despite being #1 on GitHub demonstrates the index’s blind spot for languages embedded within other ecosystems.
Assessment: TIOBE is useful for spotting broad trends and mainstream attention shifts but should not be used in isolation. It is best combined with usage-based indexes like Stack Overflow and GitHub Octoverse.
“Are Microbenchmarks Meaningful?”
The Computer Language Benchmarks Game is the most cited source for language speed comparisons but faces legitimate criticism:
Criticism: Toy benchmarks don’t represent real-world applications. Real software involves I/O, networking, databases, and complex business logic — not just CPU-bound computation.Defense: Microbenchmarks isolate language-level performance characteristics and provide consistent, reproducible comparisons. They are valuable for understanding relative performance tiers.The Python caveat: Python’s benchmark performance (126.53s) is misleading because Python developers rarely write CPU-bound code in pure Python. The ecosystem’s compiled libraries (NumPy, TensorFlow) execute at near-native speeds.
Assessment: Benchmarks are valuable for understanding relative performance tiers but should be interpreted with context. A language that is 100x slower than C for computation may be perfectly adequate for a web application where the bottleneck is database queries and network latency.
“Is AI Going to Make Language Choice Irrelevant?”
Some argue that AI coding assistants will make the underlying programming language less important because AI can generate code in any language. The evidence suggests otherwise:
Typed languages benefit from AI: TypeScript’s rise correlates with AI-assisted coding adoption. When AI writes your code, type safety catches the AI’s mistakes.Python dominates AI development: Python is both the language of AI and benefits most from AI tools. Every major ML framework is Python-first.Language-specific AI training: AI models are trained on code corpora that are heavily skewed toward certain languages (Python, JavaScript). This creates a feedback loop where popular languages get better AI support.
Assessment: AI is reshaping but not eliminating the importance of language choice. It is amplifying the advantages of certain design patterns (static typing, strong ecosystems) while reducing the friction of learning new languages.
Quantitative Summary #
Consolidated Rankings Table
The following table synthesizes all available data into a single comparison framework for the top 20 languages:
| Language | TIOBE Rank | SO Usage % | RedMonk Rank | Performance Tier | Admiration % | Ecosystem Size | Best For |
|---|---|---|---|---|---|---|---|
| Python | 1 | 57.9% | 2 | Tier 5 (slow) | 56.4% desired | Largest (PyPI 500K+) | AI/ML, data science, scripting |
| JavaScript | 6 | 66.0% | 1 | Tier 4 (JIT) | 46.8% admired | Largest (npm 2.2M+) | Web frontend/backend |
| TypeScript | 32 | 43.6% | 6 | Tier 4 (JIT) | 58.0% desired | Shared with JS | Type-safe web development |
| Java | 4 | 29.4% | 3 | Tier 2 (JIT) | 41.8% admired | Very large (Maven 47M+) | Enterprise, Android |
| C# | 5 | 27.8% | 4 | Tier 3 (.NET) | 55.8% admired | Large (NuGet 350K+) | Enterprise, game dev (Unity) |
| C++ | 3 | 23.5% | 7 | Tier 1 (native) | 46.6% admired | Very large (conan, vcpkg) | Systems, games, HFT |
| C | 2 | 22.0% | 10 | Tier 1 (native) | 45.0% admired | Large (historical) | OS, embedded, systems |
| Go | 16 | 16.4% | 12 | Tier 3 (managed) | 56.5% admired | Moderate | Cloud-native, microservices |
| Rust | 14 | 14.8% | 20 | Tier 1 (native) | 72.4% admired | Growing (crates.io 180K+) | Systems, safety-critical |
| PHP | — | 18.9% | 4 | Tier 4 (JIT-ish) | 38.9% admired | Large (Composer 600K+) | Web backend (WordPress) |
| Swift | — | 5.4% | 11 | Tier 2 (native) | 65.9% admired | Moderate | iOS/macOS development |
| Kotlin | 20 | 10.8% | 14 | Tier 2 (JVM) | 51.0% admired | Shared with Java | Android, JVM apps |
| Ruby | — | 6.4% | 9 | Tier 5 (interpreted) | 44.3% admired | Moderate (RubyGems 150K+) | Web (Rails), scripting |
| R | 8 | 4.9% | 13 | Tier 5 (interpreted) | 39.6% admired | Moderate (CRAN 20K+) | Statistics, data analysis |
| Shell/Bash | — | 48.7% | 14 | N/A (scripting) | 52.8% admired | Universal | DevOps, system admin |
| Dart | — | 5.9% | 18 | Tier 3 (AOT/JIT) | 47.0% admired | Moderate (pub.dev 10K+) | Flutter cross-platform |
| SQL | 9 | 58.6% | N/A | N/A (query lang) | 56.4% desired | Universal | Database queries |
| Scala | — | 2.6% | 14 | Tier 2 (JVM) | 39.4% admired | Shared with Java | Big data (Spark), FP |
| PowerShell | — | 23.2% | 17 | Tier 3 (.NET) | 35.4% admired | Moderate | Windows admin, DevOps |
| Lua | — | 9.2% | — | Tier 4 (JIT-ish) | 46.9% admired | Moderate | Game scripting, embedded |
Performance vs. Productivity Matrix
A useful mental model for language selection is the performance-productivity trade-off:
High Productivity ────────────────────────┐
│
Python Ruby │ C Rust C++
│
│
JavaScript TypeScript │ Swift Go
│
│
PHP Bash │ Java Kotlin Scala
│
Low Productivity ─────────────────────────┘
Slow Execution Fast Execution
Languages in the upper-right quadrant (Rust, C) offer both performance and — for experienced developers — productivity through safety guarantees. Languages in the lower-left (Python, Ruby) maximize development speed at the cost of runtime efficiency. Languages in the middle (Go, TypeScript, Swift) represent pragmatic compromises.
Risks, Uncertainties, and Open Questions #
Measurement Limitations
Survey bias: All major surveys (Stack Overflow, JetBrains) are self-selected and may overrepresent English-speaking, Western, professional developers. The global developer population is 47.2 million; survey samples represent a fraction of this.Index methodology gaps: No single index captures the full picture. TIOBE misses embedded usage; GitHub misses private codebases; Stack Overflow misses non-professional developers.Benchmark limitations: Microbenchmarks don’t represent real applications. Real-world performance depends on frameworks, libraries, deployment environments, and developer skill level.
Emerging Uncertainties
AI’s long-term impact on language preferences: AI coding assistants are still maturing. Their effect on language choice may accelerate or reverse current trends in ways that are not yet predictable. The shift toward typed languages (TypeScript) could continue or plateau.Rust’s enterprise adoption timeline: The CISA memory-safety mandate creates a floor for Rust adoption, but the actual pace of migration from C/C++ is uncertain. Organizational inertia and the learning curve are significant barriers.Python’s sustainability at scale: Python’s performance limitations and dependency management challenges (the “dependency hell” problem) could become more acute as AI workloads grow. Alternatives like Mojo (0.4% SO usage) or Julia are emerging but unproven at scale.Web development consolidation: The web framework landscape is consolidating around TypeScript/React/Next.js, but this ecosystem is complex and may face fragmentation or simplification in coming years.The decline of legacy languages: Ruby’s exit from TIOBE’s top 20 and Objective-C’s steady decline suggest that some established languages are losing relevance. The pace of this decline is uncertain but the direction appears clear.
Unanswerable Questions
Will any language achieve Python-level dominance in AI? Python’s position is reinforced by network effects: every ML framework, library, and tutorial is Python-first. Breaking this cycle would require a fundamentally better alternative, not just incremental improvements.Can Rust achieve mainstream adoption beyond systems programming? Rust’s design philosophy (compile-time safety, zero-cost abstractions) is compelling but the learning curve is steep. Whether it can break out of its current niche depends on whether enough organizations invest in the transition.Will AI coding assistants change which languages beginners learn? If AI tools make coding equally easy in all languages, the traditional “Python first” recommendation could shift. Early evidence suggests typed languages may become more attractive for AI-assisted learning.
Implications and Outlook #
Short-Term (2026–2027)
TypeScript consolidation: TypeScript will continue replacing JavaScript as the default for new web projects. The transition is already well underway, with most major frameworks scaffolding TypeScript by default.Python’s AI momentum continues: Python’s dominance in AI/ML is self-reinforcing. As AI becomes more central to software development, Python’s adoption will grow further, though its raw usage percentage may plateau as it approaches saturation.Rust’s enterprise acceleration: The CISA memory-safety mandate (January 2026 deadline) will drive Rust adoption in critical infrastructure. Expect to see Rust in more government and security-sensitive projects.Go’s cloud-native entrenchment: Go remains the language of choice for cloud-native development. Its combination of simplicity, performance, and concurrency support is unmatched for microservices and infrastructure tools.
Medium-Term (2027–2030)
AI reshapes the landscape: AI coding assistants will continue to favor typed languages. TypeScript, Go, Rust, and Kotlin may see accelerated adoption as AI tools make their type systems more valuable.Memory safety becomes mainstream: Beyond the CISA mandate, industry pressure for memory-safe code will grow as security incidents involving buffer overflows and use-after-free bugs remain costly. Rust and Swift are the primary beneficiaries.Consolidation in web development: The JavaScript/TypeScript ecosystem may consolidate around fewer, more opinionated frameworks (Next.js is already the leader). This could improve developer experience but reduce flexibility.Emerging languages find niches: Languages like Zig (64% admiration), Gleam (70% admiration), and Mojo may grow from niche to notable, though achieving mainstream adoption remains unlikely within this timeframe.
Long-Term Structural Shifts
The productivity-performance gap narrows: AI-assisted coding and improved compilers/runtimes will reduce the performance gap between interpreted and compiled languages. Python-like productivity with Rust-like performance may become achievable through AI-generated optimized code.Language choice becomes less binary: Developers increasingly use multiple languages within a single project (TypeScript frontend + Python backend + Go microservices + SQL database). The “pick one language” paradigm is giving way to polyglot development.Domain-specific languages grow: As AI handles general-purpose coding, specialized languages for specific domains (data processing, security, embedded systems) may gain relative importance.
Strategic Recommendations
For individual developers:
- Learn Python if you want the fastest path to employment (64K+ US jobs) or entry into AI/ML
- Learn TypeScript if you’re in web development — it’s becoming the default
- Learn Go if you want high salary ($146,879 avg) with growing demand (+41% YoY) and manageable learning curve
- Learn Rust if you’re interested in systems programming, security, or long-term career differentiation
For organizations:
- Evaluate TypeScript migration for JavaScript codebases — the ROI in maintainability and AI-assisted coding reliability is significant
- Consider Rust for new performance-critical or security-sensitive components, while maintaining C/C++ for existing investments
- Invest in Python/AI skills as AI becomes central to business operations
- Adopt Go for new cloud-native services where developer velocity and operational simplicity matter
Conclusion #
The programming language landscape of 2025–2026 is characterized by both remarkable stability and significant transformation. The top five languages (Python, JavaScript/TypeScript, Java, C#, C++) have held their positions for years, reflecting the enormous inertia of established ecosystems. Yet beneath this surface stability, profound shifts are underway.
Three meta-trends define the current era:
The AI revolution is reshaping language preferences. Python benefits directly as the language of AI development. TypeScript benefits indirectly as typed languages become more valuable in AI-assisted coding workflows. This dual effect is driving both Python’s record-breaking adoption and TypeScript’s rise to #1 on GitHub.Memory safety is becoming a strategic imperative. The CISA memory-safety mandate, combined with the growing cost of security breaches, is pushing organizations toward Rust and Swift. These languages eliminate entire classes of bugs at compile time — a benefit that becomes more valuable as software systems grow more complex and interconnected.Developer experience is winning over raw performance. Languages that prioritize developer productivity (Python, Ruby, Go) continue to gain share even as hardware becomes faster. The cost of developer time far exceeds the cost of compute for most applications, making languages that enable rapid development and easy maintenance increasingly attractive.
The “best” programming language remains context-dependent. Python is unmatched for AI and data science. TypeScript is becoming the default for web development. Go excels at cloud-native infrastructure. Rust is the future of systems programming. Java and C# remain enterprise workhorses. No single language dominates all domains, and the polyglot nature of modern software development means that most developers will use multiple languages throughout their careers.
What has changed is the speed of transition. The shift from JavaScript to TypeScript happened faster than most predicted. Python’s AI-driven adoption surge is unprecedented in scale. Rust’s enterprise uptake is being accelerated by government policy. These trends suggest that the programming language landscape will continue to evolve rapidly, and staying informed about these shifts — as this report attempts to do — is essential for making sound technology decisions.
Methodology Note #
This report synthesizes data from five major programming language popularity indexes (TIOBE Index February 2026, Stack Overflow Developer Survey 2025, RedMonk Programming Language Rankings Q1 2026, GitHub Octoverse 2025, JetBrains State of Developer Ecosystem Report 2024), performance benchmarks (Computer Language Benchmarks Game v25.03, programming-language-benchmarks.vercel.app), salary data (VentureBeat 2025, Second Talent 2025, Rockstar Developer University compilation), and ecosystem metrics (npm, PyPI, crates.io, Maven Central package counts; Stack Overflow IDE and framework usage data).
Search strategies included targeted queries for each index’s latest data, performance benchmark results, developer satisfaction surveys, and ecosystem/toolchain comparisons. Primary sources were prioritized over secondary analyses wherever possible. Data points are attributed to specific sources throughout the report.
Limitations include: (1) all popularity indexes measure different signals and cannot be directly compared; (2) performance benchmarks are microbenchmarks that may not reflect real-world application performance; (3) survey data is self-selected and may not represent the global developer population accurately; (4) salary data is US-centric and subject to geographic, experience, and role variation. Where sources disagree, discrepancies are noted rather than papered over.
References #
Rockstar Developer University. “Programming Language Statistics 2026: Popularity, TIOBE & Salary.” February 10, 2026.
https://rockstardeveloperuniversity.com/programming-language-statistics/(accessed 2026-07-06)RedMonk. “The RedMonk Programming Language Rankings: January 2026.” Stephen O’Grady, April 14, 2026.
https://redmonk.com/sogrady/2026/04/14/language-rankings-1-26/(accessed 2026-07-06)Stack Overflow. “2025 Stack Overflow Developer Survey — Technology.”
https://survey.stackoverflow.co/2025/technology(accessed 2026-07-06)JetBrains. “State of Developer Ecosystem Report 2024.”
https://www.jetbrains.com/lp/devecosystem-2024/(accessed 2026-07-06)GitHub. “Octoverse 2025: The state of open source.”
https://octoverse.github.com/(accessed 2026-07-06)MOR Software. “Top 10+ Fastest Programming Languages in 2026 for High-Performance.” March 5, 2026.
https://morsoftware.com/blog/fastest-programming-languages(accessed 2026-07-06)The Computer Language Benchmarks Game. “Version 25.03.”
https://benchmarksgame-team.pages.debian.net/benchmarksgame/index.html(accessed 2026-07-06)Programming Language Benchmarks Visualization. “Benchmarks for programming languages and compilers.”
https://programming-language-benchmarks.vercel.app/(accessed 2026-07-06)TechEmpower. “Round 23 results — Framework Benchmarks.”
https://www.techempower.com/benchmarks/(accessed 2026-07-06)SlashData. “Global Developer Survey 2025.” Cited via Rockstar Developer University, 2026. (47.2 million developers worldwide)
InfoWorld. “C# wins Tiobe Programming Language of the Year honors for 2025.” January 6, 2026.
https://www.infoworld.com/article/4112993/c-wins-tiobe-programming-language-of-the-year-honors-for-2025.html(accessed 2026-07-06)GitHub Blog. “Octoverse: AI leads Python to top language.” October 30, 2024.
https://github.blog/news-insights/octoverse/octoverse-2024/(accessed 2026-07-06)Stack Overflow Blog. “Developers want more, more, more: the 2024 results.” January 1, 2025.
https://stackoverflow.blog/2025/01/01/developers-want-more-more-more-the-2024-results-from-stack-overflow-s-annual-developer-survey/(accessed 2026-07-06)JetBrains Blog. “The State of Developer Ecosystem 2025: Coding in the Age of AI.” October 21, 2025.
https://blog.jetbrains.com/research/2025/10/state-of-developer-ecosystem-2025/(accessed 2026-07-06)Sonatype. “2024 Software Supply Chain Report — Scale of Open Source.”
https://www.sonatype.com/state-of-the-software-supply-chain/2024/scale(accessed 2026-07-06)Andrew Nesbitt. “Package Manager Design Tradeoffs.” December 5, 2025.
https://nesbitt.io/2025/12/05/package-manager-tradeoffs.html(accessed 2026-07-06)Intuition Labs. “Impact of Generative AI on Top Programming Languages.” August 16, 2025.
https://intuitionlabs.ai/pdfs/impact-of-generative-ai-on-top-programming-languages.pdf(accessed 2026-07-06)Wikipedia. “Comparison of multi-paradigm programming languages.”
https://en.wikipedia.org/wiki/Comparison_of_multi-paradigm_programming_languages(accessed 2026-07-06)
Share this article #
Related writing #
How AI Agents Actually Work: An Architectural Deep Dive
An analysis of the patterns, infrastructure, and trade-offs behind the systems that have redefined what large language models can do
The term "AI agent" has become one of the most overloaded in modern tech, but at its core it refers to a simple pattern: a large language model...
The State of Content Management Systems in 2026: A Comprehensive Comparison
Evaluating Core Features, Architecture, Performance, and Ecosystems Across the Leading Platforms
The CMS landscape in 2026 is defined by a fundamental architectural divergence: traditional monolithic platforms are losing new-site momentum to...
Pydantic AI vs Claude Agent SDK: A Comprehensive Framework Comparison for Production AI Agents
A deep-dive analysis of two prominent Python-based approaches to building production-grade AI agents — examining architecture, capabilities, developer experience, ecosystem, pricing, and trade-offs as of June 2026.
This report compares two distinct approaches to building AI agents in Python: Pydantic AI, an open-source, model-agnostic agent framework built...
Search #
Search by title, subtitle, tags, categories, authors, or body text.