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:
| Year | Domain | Milestone | Vendor | Rewrite | Notes |
| 1995 | Database/Data | MySQL 1.0 era (first release) | MySQL AB | Low | Open-source RDBMS adoption |
| 1995 | Desktop/Thick Client | Windows 95/Win32 mainstream | Microsoft | Medium | Win32 client-server boom |
| 1996 | Database/Data | PostgreSQL project renamed; SQL focus | PGDG | Low | Advanced OSS RDBMS matures |
| 2002 | Desktop/Thick Client | .NET 1.0 (WinForms/ASP.NET) | Microsoft | Medium | Managed code shift for Windows |
| 2005 | Web/Frontend | AJAX popularized (Web 2.0) | Multiple | Medium | Asynchronous UX patterns; partial rewrites |
| 2006 | Cloud/Infra | AWS S3/EC2 usher commercial cloud (IaaS) | Amazon | High | Many lift-and-shift rewrites; ops model change |
| 2006 | Database/Data | Hadoop 0.1 (big-data wave) | Apache | Medium | Batch analytics stack emerges |
| 2006 | Desktop/Thick Client | WPF released | Microsoft | Low | New desktop UI stack; selective adoption |
| 2007 | Mobile | iPhone announced; modern smartphone era | Apple | High | New native platforms & UX paradigms |
| 2008 | Cloud/Infra | Google App Engine (PaaS preview) | Medium | 12-factor style apps; platform constraints | |
| 2008 | Mobile | Android 1.0 / G1 launch | High | Parallel Android ecosystem | |
| 2008 | Mobile | Apple App Store opens | Apple | High | New distribution/econ model for apps |
| 2009 | Database/Data | MongoDB 1.0 (document DB) | 10gen/MongoDB | Medium | NoSQL movement in prod |
| 2009 | Web/Frontend | Node.js runtime released | Joyent/OSS | Medium | JS full-stack; build tooling revolution |
| 2010 | Cloud/Infra | Windows Azure GA (now Microsoft Azure) | Microsoft | Medium | New cloud targets for .NET/Windows shops |
| 2010 | Web/Frontend | AngularJS (1.x) released | Medium | SPA era begins | |
| 2012 | Cloud/Infra | Amazon Redshift (cloud DW) | Amazon | Medium | Shift of analytics to cloud DWaaS |
| 2013 | Cloud/Infra | Docker popularizes containers | Docker | High | Packaging & deploy model changes; CI/CD revamp |
| 2013 | Web/Frontend | React released | Medium | Component model; virtual DOM | |
| 2014 | Cloud/Infra | Kubernetes first commit/orchestration era | CNCF | High | Replatform microservices to k8s |
| 2014 | Cloud/Infra | AWS Lambda (serverless functions) | Amazon | Medium | Event-driven rewrites; new cost model |
| 2014 | Database/Data | Apache Spark 1.0 (fast analytics) | Apache/Databricks | Medium | Move beyond MapReduce |
| 2016 | Desktop/Thick Client | .NET Core 1.0 (cross-platform) | Microsoft | High | Porting from .NET Framework begins |
| 2016 | Web/Frontend | Angular 2 rewrite | Medium | Framework breakage; migration pressure | |
| 2020 | Desktop/Thick Client | .NET 5 unification | Microsoft | Medium | Single .NET target; migration planning |
| 2026 | Cloud/Infra | Edge/serverless at the CDN (functions at edge) mainstream | Multiple | Medium | Latency-sensitive microservices at edge POPs |
| 2027 | Web/Frontend | WASM apps with Rust/Go/C# for selective workloads | Multiple | Medium | Partial rewrites for perf/security |
| 2028 | Database/Data | Unified lakehouse (stream+batch) standardizes | Multiple | Medium | Consolidate pipelines; fewer engines |
| 2029 | Cloud/Infra | GPU-centric platforms default for AI services | Multiple | High | Refactor for heterogeneous compute |
| 2030 | Mobile | Cross-platform UI + local AI toolchains stabilize | Multiple | Medium | Converged build systems; on-device AI |
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.