How Often Software and Software Infrastructure Changes

• What’s changed since ~1985 across cloud, mobile, thick-client/desktop, web front-ends, and data
• How often do software development teams end up refactoring/rewriting their code
• How long do “principal” languages tend to last

Here is a list of the major software and software infrastructure changes that have occurred since 1985:
 

And here’s a quick cadence chart of how many “big shifts” landed per 5-year period (past + 5-year outlook):

Executive takeaways (how often you really have to change)

• Cloud/infra: expect a material platform shift every ~5–7 years (IaaS → containers → k8s → serverless → edge/GPU). Most orgs perform incremental refactors yearly, plus 1–2 multi-quarter migrations per decade(e.g., VM→k8s or k8s→serverless/edge). Milestones: AWS (2006), Docker (2013), Kubernetes (2014), Lambda/serverless (2014). (Wikipedia)
• Mobile: platform additions are rare but seismic (iPhone 2007, Android 2008). Mobile stacks stabilize ~5–8 years at a time, but framework/tooling churn is ~3–5 years (native, cross-platform waves). App Store (2008) locked in new distribution + update cadences. (Wikipedia)
• Web/front-end: plan for meaningful framework change every ~3–5 years, with longer-lived concepts(components, reactive dataflow) persisting. Key pivots: AJAX/Web 2.0 (~2005), Node.js (2009), AngularJS (2010) → Angular 2 rewrite (2016), React (2013). (Wikipedia)
• Desktop/thick client: Windows client eras lasted ~8–12 years each (Win32 → .NET/WinForms/WPF → .NET Core/modern .NET). Cross-platform .NET Core (2016) and .NET 5 unification (2020) renewed the stack for another decade-ish. Expect selective porting vs full rewrites. (Wikipedia)
• Data/DB: large shifts roughly every ~7–10 years: OSS RDBMS maturity (MySQL ’95, Postgres ’96), Hadoop big-data wave (2006), NoSQL (2008–2011), cloud DW (Redshift ’12), Spark fast analytics (2014). Lakehouse unification is the current consolidation. (Wikipedia)

How long do “principal languages” last?

• C/C++: 35–50+ years in production (still foundational).
• Java: released 1995; still a top enterprise language 30 years on. (Wikipedia)
• Python: public since 1991; currently surging due to data/AI (34 years). (Wikipedia)
• C#: .NET (2002) to modern .NET (2020s) >20 years; rejuvenated by cross-platform .NET. (Wikipedia)
• JavaScript: mid-90s to today; runtime and tooling reinvented it (Node.js 2009). (Wikipedia)
• Go (2009), Rust (~2010s): still in growth; both look durable for 10–20+ year arcs.

Rule of thumb: principal languages easily last 15–30 years; what changes faster is the runtime, framework, packaging, and deployment model around them.

Timeline highlights (selected)

• 1990s: Win32 desktop boom; Java (1995) mainstreams VM-based cross-platform; MySQL (1995) & PostgreSQL (1996) anchor OSS RDBMS. (Wikipedia)
• 2000–2006: Web 2.0 & AJAX patterns; Hadoop (2006) kicks off big-data; AWS launches (S3/EC2 2006) → commercial cloud era. (Wikipedia)
• 2007–2010: iPhone (2007), App Store (2008), Android 1.0 (2008) reset mobile; Azure GA (2010) expands cloud. (Wikipedia)
• 2012–2016: Redshift preview (2012) → cloud DW; Docker (2013) → containers; Kubernetes (2014) → orchestration; Lambda (2014) → serverless; .NET Core 1.0 (2016) → cross-platform .NET; Angular 2 rewrite (2016). (Amazon Web Services, Inc.)
• 2014–present: Spark 1.0 (2014) → faster analytics; React (2013) dominates front-end; modern .NET unification (.NET 5, 2020). (databricks.com)

Practical cadence by surface

• Cloud back-ends: expect major migrations every ~6–8 years (VM→containers→k8s→serverless/edge) with continuous refactors yearly to adopt managed services. Budget 1 major replatform per decade. (Kubernetes)
• Mobile apps: platform is stable; toolchains change ~3–5 years (native SDK shifts, Swift/Kotlin idioms, cross-platform waves). Keep core logic separate to avoid framework lock-in. (Wikipedia)
• Web/front-end: framework churn ~3–5 years; plan for staged migrations (router, state, design system) rather than ground-up rewrites. (Wikipedia)
• Desktop/thick client: port when ecosystems unify (.NET Core → .NET 5+). Use long-term support (LTS) rails to reduce churn. (Microsoft)
• Data/analytics: paradigm flips ~7–10 years (Hadoop→Spark→Lakehouse). Keep storage open (Parquet, open table formats) to future-proof engines. (Wikipedia)

What forces an actual rewrite (vs. refactor)?

• Execution model shift (process-per-app → containers → k8s → functions)
• Distribution channel or OS shift (App Store policies; new mobile OS APIs)
• Language/runtime deprecation or unification (.NET Framework → modern .NET)
• Data scale & latency shifts (batch → streaming/interactive; GPU/AI)

5-year outlook (2026–2030) — where to expect pressure

• Edge/serverless at the CDN becomes default for latency-sensitive slices (login, personalization).
• GPU-centric cloud platforms standardize for AI inference/training—expect service boundaries to move to accelerators.
• Lakehouse consolidation trims engine sprawl; streaming+batch unify.
• WASM unlocks selective high-perf front-ends; cross-platform mobile UI with local AI stabilizes build pipelines.