JetBrains Developer Ecosystem 2025 : TypeScript, Rust et Go en tête, Docker explose +17%

Écosystème développeurs 2025 : Tendances majeures

Le 24 octobre 2025, JetBrains a publié son rapport annuel "State of Developer Ecosystem 2025", basé sur une enquête auprès de 32,000 développeurs dans 190 pays. Ce rapport de référence pour l'industrie logicielle révèle des changements significatifs dans les technologies, pratiques, et priorités des développeurs à l'ère de l'IA générative et de la productivité redéfinie.

Findings clés :

1. TypeScript, Rust, Go perçus comme langages à plus forte croissance
2. Docker : +17 points d'adoption (plus grande hausse jamais mesurée)
3. Python garde n°1 mais perd momentum (plateau maturité)
4. "Vibe coding" émerge : Développement par instructions langage naturel via LLMs
5. Métriques productivité détrônent DORA metrics (vélocité code → developer happiness)

Ce rapport survient dans un contexte de transformation majeure de l'industrie : GitHub Copilot atteint 1,5 million d'abonnés payants, Cursor (IDE AI-native) lève 100M USD valorisation 2,5B USD, et les entreprises redéfinissent ce que signifie "productivité développeur" à l'ère des AI coding assistants.

Langages de programmation : Classement et momentum

Top 10 langages utilisés (2025) :

Observations :

Python n°1 mais plateau :

• 62% usage (vs 64% 2024) : Première baisse après 10 ans croissance continue
• Raisons :
  • Saturation marché (data science, scripts, automation déjà adoptés massivement)
  • Performance limitations (applications critiques migrent vers Rust, Go)
  • Alternatives émergent : Mojo (Python syntax + C performance)
• Segments dominés : Data science (92%), ML/AI (87%), scripting (78%)

TypeScript momentum énorme :

• 52% usage (+6% vs 2024) : Croissance la plus rapide des langages mainstream
• Perceived growth : 73% développeurs prédisent adoption continue
• Drivers :
  • TypeScript obligatoire dans 85% nouveaux projets frontend
  • Backend adoption : NestJS, tRPC (type-safe APIs)
  • Tooling ecosystem mature : ESLint, Prettier, Biome (linters ultra-rapides)
• Défis : Complexité type system (learning curve steep pour juniors)

Rust phénomène :

• 18% usage (+7% vs 2024) : Plus forte progression en points absolus
• Perceived growth : 78% prédisent croissance continue (record)
• Use cases :
  • Systems programming (remplace C/C++ progressivement)
  • WebAssembly (performances near-native web)
  • Blockchain/crypto (Solana, Polkadot basés Rust)
  • Tooling (Biome linter, Ruff Python linter écrits en Rust pour speed)
• Admiration : 72% des développeurs "admirent" Rust (vs 64% Zig, 66% Elixir)
• Barrière : Courbe apprentissage (ownership, borrowing concepts nouveaux)

Go stabilité :

• 24% usage (+5% vs 2024) : Croissance soutenue
• Perceived growth : 68% prédisent adoption continue
• Use cases :
  • Backend APIs (Gin, Fiber frameworks)
  • DevOps tooling (Kubernetes, Docker, Terraform écrits en Go)
  • Cloud-native apps (GCP encourage Go, AWS SDK Go mature)
• Forces : Simplicité, compilation rapide, concurrency built-in (goroutines)
• Faiblesse : Generics ajoutés tardivement (Go 1.18, 2022), ecosystem moins riche que Node/Python

JavaScript "mature plateau" :

• 58% usage (stable vs 2024)
• Perceived growth : 42% (faible vs TypeScript 73%)
• Interprétation : JavaScript n'est pas en déclin, mais adopté universellement (nowhere to grow)
• Migration TypeScript : 68% nouveaux projets JS sont en fait TypeScript

PHP déclin structurel :

• 17% usage (-4% vs 2024) : Chute continue depuis 2018
• Perceived growth : 18% (plus bas du classement)
• Survivants : WordPress (40% web), Laravel (framework moderne), legacy systems
• Tendance : Migrations PHP → Node.js, Python, Go pour nouveaux projets

Technologies émergentes : Mojo, Carbon, Gleam

Mojo (créé par Chris Lattner, LLVM/Swift) :

Pitch : "Python syntax with C performance"

# Syntaxe identique Python
def fibonacci(n: Int) -> Int:
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

# Mais compilation vers code natif (LLVM)
# Performance : 68,000x plus rapide que Python interprété (benchmark Mandelbrot)

Status 2025 :

• Beta ouverte (septembre 2025)
• Adoption : 50,000+ développeurs testent
• Use case : ML inference (remplacer Python+C++ glue code)
• Challenges : Ecosystem immature (pas de libs tierces encore)

Carbon (Google, successeur C++) :

package Geometry api;

fn Circle.Area(radius: f64) -> f64 {
  return 3.14159 * radius * radius;
}

Objectifs :

• Interoperability bidirectionnelle avec C++ (contrairement Rust)
• Syntaxe moderne (pas de baggage 40 ans C++)
• Memory safety sans overhead (vs Rust borrow checker)

Status 2025 :

• Experimental (pas production-ready)
• Intérêt : 35% développeurs C++ "curious" (survey JetBrains)
• Timeline : Version 1.0 espérée 2027

Gleam (Functional programming, Erlang VM) :

JetBrains survey : 70% admiration (2ème après Rust 72%)

pub fn greet(name: String) -> String {
  "Hello, " <> name <> "!"
}

Forces :

• Type safety (compile-time guarantees)
• Concurrent par défaut (Erlang VM = millions de processus)
• Syntaxe accessible (vs Elixir plus cryptique)

Limite : Niche (backend fault-tolerant, telecom, finance)

Frameworks et outils : Docker dominant, FastAPI monte

Frameworks web backend :

FastAPI surge :

• +5 points (plus grande progression backend frameworks)
• Raisons :
  • Async native (performances élevées)
  • Type hints Python 3.10+ (auto-documentation OpenAPI)
  • DX (Developer Experience) excellent (moins boilerplate que Django)
• Use cases : APIs ML/AI, microservices, backends startups

NestJS momentum TypeScript :

• +4 points : Suit montée TypeScript
• Forces : Architecture enterprise (inspiré Angular), decorators, TypeORM
• Clients : Scale-ups, enterprises migrant Express → NestJS (maintenabilité)

Express.js déclin relatif :

• -2 points : Pas de déclin absolu, mais perd parts vs concurrents modernes
• Problème : Middleware hell, pas de structure opinionnée
• Survie : Legacy projects, simplicité pour prototypes rapides

Frontend frameworks :

React stable dominant :

• 54% usage : Leadership incontesté mais plateau
• Concurrence : Svelte, Solid offrent performances supérieures (moins overhead Virtual DOM)
• Écosystème : Next.js (React framework) domine SSR/SSG (Server-Side Rendering)

Svelte progression :

• +3 points : Croissance continue depuis 2020
• SvelteKit : Concurrent Next.js, adoption progressive
• Limite : Ecosystem jobs moins large (React domine hiring)

Docker : Explosion +17 points

Statistique choc JetBrains :

Docker adoption : 79% développeurs (vs 62% en 2024)

• +17 points : Plus grande hausse single-year jamais enregistrée pour toute technologie

Raisons explosion :

1. Kubernetes mainstream ** :

• Kubernetes adoption enterprise : 68% (vs 52% 2024)
• Kubernetes = orchestration Docker containers
• Impossible faire K8s sans maîtriser Docker

2. Dev environments standardisés ** :

• "Works on my machine" → obsolète
• Docker Compose dev environments : Setup projet en 1 commande
• Onboarding nouveaux devs : 1 jour → 1 heure

3. CI/CD adoption ** :

• 92% entreprises utilisent CI/CD (vs 78% 2024)
• Pipelines CI = build Docker images, deploy containers
• GitLab CI, GitHub Actions, CircleCI = Docker-native

4. Microservices architecture ** :

• 71% nouveaux projets backend = microservices (vs 58% 2024)
• Microservices = containers par nature (1 service = 1 container)

5. Cloud-native mandataire ** :

• AWS ECS, Azure Container Instances, Google Cloud Run
• Deploy containers = plus simple que VMs traditionnelles

Docker alternatives :

• Podman : 12% usage (daemonless, rootless alternative)
• containerd : Low-level runtime (Docker utilise containerd sous le capot)

Malgré alternatives, Docker reste standard de facto.

"Vibe Coding" : Nouvelle ère développement

Concept "Vibe Coding" (Andrej Karpathy, février 2025) :

Développer software via instructions langage naturel aux LLMs, sans écrire code manuellement.

Exemple workflow :

Developer prompt to LLM:
"Create a REST API in FastAPI with endpoints:
- POST /users (create user with email, password)
- GET /users/{id} (retrieve user)
- PUT /users/{id} (update user)
- DELETE /users/{id}
Use SQLAlchemy ORM with PostgreSQL.
Include input validation with Pydantic.
Add JWT authentication.
Write pytest tests for all endpoints."

LLM generates:
- main.py (FastAPI app)
- models.py (SQLAlchemy models)
- schemas.py (Pydantic schemas)
- auth.py (JWT utilities)
- tests/ (pytest test suite)
- requirements.txt
- docker-compose.yml (PostgreSQL + app)

Adoption 2025 :

JetBrains survey : 42% développeurs utilisent "vibe coding" au moins 1x par semaine.

Outils permettant vibe coding :

• GitHub Copilot Chat (intégré VS Code, JetBrains IDEs)
• Cursor (IDE AI-native, génération code full-file)
• Windsurf (Codeium IDE, multi-file editing)
• ChatGPT / Claude (via copy-paste prompts/code)

Impact productivité :

Positif :

• Prototyping : 5-10x plus rapide (boilerplate généré automatiquement)
• Learning : Juniors comprennent patterns en voyant code généré + explications LLM
• Refactoring : LLM suggère améliorations architecture

Négatif :

• Qualité variable : Code généré parfois buggy, non-optimal
• Over-reliance : Juniors ne comprennent pas fondamentaux (copy-paste sans comprendre)
• Security risks : LLMs peuvent générer code vulnérable (SQL injection, XSS si prompts mal rédigés)

Débat industrie :

Pro-vibe-coding (Silicon Valley startups) :

"Dans 5 ans, coder manuellement sera perçu comme utiliser assembly aujourd'hui. Les meilleurs devs utiliseront AI pour 10x output."

Sceptiques (seniors, big tech) :

"Vibe coding OK pour prototypes, mais production-grade code nécessite deep understanding. LLMs génèrent code fragile, hard to maintain."

Consensus émergent :

• Vibe coding = tool, not replacement
• Devs doivent review et comprendre code généré
• Productivité gains réels (20-40%) mais pas 10x (encore)

Métriques productivité : Shift de DORA vers Dev Happiness

DORA metrics (DevOps Research & Assessment) :

Historiquement (2015-2024), productivité mesurée via :

1. Deployment frequency (combien de fois par jour/semaine)
2. Lead time for changes (temps code commit → production)
3. Change failure rate (% deployments causant incidents)
4. Time to restore service (temps résolution incidents)

Problème DORA 2025 :

JetBrains survey : 68% développeurs estiment DORA metrics ne capturent pas vraie productivité.

Critiques :

• Gaming metrics : Teams ship micro-changes pour "boost" deployment frequency (pas de valeur business)
• Burnout : Pression deploy vite → corners cut, technical debt accumulé
• Ignore quality : DORA ne mesure pas maintenabilité, lisibilité code

Nouvelles métriques 2025 :

1. Developer Happiness / Satisfaction ** :

• Surveys hebdomadaires : "How happy were you with your work this week?" (1-10)
• Corrélation : Dev happiness → meilleure rétention, moins bugs production

2. Flow State Time ** :

• % temps développeurs en "flow" (concentrés sans interruptions)
• Tools : Clockwise, Reclaim.ai (AI schedule management pour blocs focus)
• Target : 4+ heures flow/jour

3. PR Review Time ** :

• Temps entre PR ouvert → reviewed → merged
• Impact : PRs stalled plus de 24h → dev frustration, context switching coûteux

4. Cognitive Load ** :

• Nombre systèmes/services dev doit comprendre pour feature
• Réduction : Platform engineering, internal developer platforms (backstage.io)

Shift culturel :

• 2015 -2023** : "Ship fast, break things" (Facebook motto)
• 2024 -2025** : "Ship sustainably, happy devs build better products"

Entreprises pionnières :

• GitLab : "Developer Satisfaction Score" métrique clé (publié quarterly)
• Shopify : "Maker Time" KPI (% temps devs en flow vs meetings)
• Spotify : Abandonne DORA, focus "Team Health" surveys

Implications pour développeurs et entreprises

Pour développeurs individuels :

Skills à prioriser 2025-2027 :

1. TypeScript : Standard frontend + backend (NestJS, tRPC)
2. Rust : Systems programming, WebAssembly, performance-critical
3. Docker + Kubernetes : Cloud-native deployment (mandatory skill)
4. AI tooling : GitHub Copilot, Cursor (productivity multiplier)
5. Prompt engineering : Savoir demander à LLMs (vibe coding efficace)

Skills en déclin :

• PHP legacy (sauf Laravel)
• Angular (React/Vue plus demandés)
• jQuery (obsolète avec frameworks modernes)

Pour entreprises tech :

Investissements prioritaires :

1. AI coding assistants ** :

• Budget : 30-50 USD/dev/mois (GitHub Copilot, Cursor, Tabnine)
• ROI : 20-40% productivity gain (selon études Microsoft, GitHub)

2. Developer Experience (DX) ** :

• Internal platforms : Backstage, Port, Humanitec
• Self-service infra : Devs créent envs sans tickets Ops
• Impact : Réduction lead time 50%, dev satisfaction +30%

3. Focus time protection ** :

• Politiques "No meeting Wednesdays"
• AI scheduling (Clockwise bloque focus blocks automatiquement)
• Bénéfice : Flow state +2h/jour/dev → qualité code améliore

4. Upskilling Rust, TypeScript, K8s ** :

• Bootcamps internes (2-4 semaines immersion)
• Pair programming seniors-juniors
• Justification : Recruter talents avec ces skills coûte 20-30% plus cher

Articles connexes

Pour approfondir le sujet, consultez également ces articles :

• Zig 2025 : l’alternative moderne au C pour systèmes critiques
• Mojo : Le langage qui combine syntaxe Python et performance C, 68 000x plus rapide
• Rust en 2025 : Le Langage qui Révolutionne la Programmation Système

Conclusion

Le rapport JetBrains Developer Ecosystem 2025 révèle une industrie en pleine transformation, portée par l'IA générative et une redéfinition de la productivité développeur. TypeScript, Rust, et Go émergent comme les langages d'avenir, tandis que Docker consolide sa position d'outil incontournable avec une adoption explosive (+17% en un an).

Points clés :

• 📊 TypeScript, Rust, Go : Langages à plus forte croissance perçue
• 🐳 Docker +17% : Plus grande hausse jamais mesurée pour une technologie
• 🐍 Python n°1 mais plateau (62% usage, -2% vs 2024)
• 🤖 "Vibe coding" : 42% devs utilisent LLMs pour générer code
• 📈 Métriques productivité : Shift DORA → Developer Happiness

Implications 2026-2030 :

• AI coding assistants deviennent aussi standards que IDEs (95%+ adoption)
• TypeScript pourrait dépasser JavaScript en usage absolu (actuellement 52% vs 58%)
• Rust mainstream pour systems programming (C/C++ replacement progressif)
• Developer happiness remplace vélocité comme métrique n°1 productivité

Pour les développeurs, le message est clair : embrasser l'IA comme outil (pas menace), investir dans langages modernes (TypeScript, Rust, Go), et prioriser qualité de vie (flow time, moins burnout) pour carrière durable.

L'ère du développeur augmenté par l'IA a commencé. Adaptez-vous ou soyez dépassés.

Ressources :

• JetBrains Report complet : https://www.jetbrains.com/lp/devecosystem-2025/
• Stack Overflow Survey 2025 : https://survey.stackoverflow.co/2025/
• GitHub Octoverse 2025 : https://octoverse.github.com/
• State of JS 2025 : https://stateofjs.com/