The modern web is a miracle of engineering, but its history is littered with brilliant concepts that flamed out in execution. For every innovation that stuck the landing, there is a promising technology that fell on its face. Each of these failures offers an object lesson for us as software developers.
New tech is kind of a compulsion. We love to gaze at the shiny new frameworks on the horizon, but true architectural wisdom comes from examining the wreckage. And from catastrophic version migrations and hostile corporate takeovers of HTML to ignoring the realities of web physics and the physical limitations of the front end, we have plenty of wreckage to learn from.
Here are seven of the most egregious failures of execution in modern web history—and the architectural lessons we must absorb to ensure our good ideas don’t suffer the same fate.
Web SQL: A single-vendor dead end
The Good Idea: Bring a robust, relational database directly into the local browser. Enable responsive, offline-first web apps. Sync it all with a back-end data store of record.
The Fatal Flaw: External standards politics. Apple pushed Web SQL, but it was essentially just a raw wrapper around SQLite. Google baked Web SQL into Chrome, but Mozilla and Microsoft balked because standardizing it meant tying the entire web specification to one specific C library. It was deprecated.
The Lesson: Standards require consensus. Tying web infrastructure to a single implementation is a recipe for sudden deprecation. Although developers lost Web SQL and suffered under the clunky IndexedDB, the field has finally progressed into more fertile fields with the Wasm-based PGLite and more recent local-first solutions like PowerSync.
Angular 2: Burn the ships
The Good Idea: Build on the success of Angular with a completely rewritten, better version.
When Hernán Cortéz famously burned his ships, it turned out to be a brilliant strategy. For a mainstream web framework? Not so much.
Angular.js was the undisputed king of single-page apps (SPA), but it had performance bottlenecks. It felt like a high-functioning kludge. Google wanted to introduce a component-based architecture that would make it maintainable, enterprise-friendly, and performant. But to do it, they had to first tear it down to the studs.
The Fatal Flaw: Bad implementation strategy. Google announced a complete, non-backward-compatible rewrite that fundamentally broke everything. There was no clear migration path for massive enterprise codebases.
That left the door left wide open for a new framework. React came through that door and never left.
The Lesson: Never break the migration path. Even a difficult path respects your current users, telling them the developers value their continued participation.
Facebook’s Flow: Hothouse tomato
The Good Idea: JavaScript needed type safety to satisfy the enterprise. Flow introduced a granular type inference that could theoretically protect massive codebases with minimal manual annotations.
Unfortunately, the project was a hothouse tomato. It was conceived and nurtured in the controlled corporate environment of Facebook.
The Fatal Flaw: Flow was built for Facebook’s internal environment. Outside of Meta, Flow was notoriously buggy, required a heavy background server, crashed on Windows, and ignored the broader open-source ecosystem. Microsoft stepped adroitly into the breach with TypeScript.
The Lesson: An open ecosystem and seamless developer experience will always beat advantages like first-mover and raw technical superiority. Even if you’re a mega-corporation, keep the project tethered to active, broad use.
Google AMP: The corporate flex
The Good Idea: As mobile became massive, the web struggled to bring a decent experience to the handheld device. The entrenched modes we had cultivated over the previous 15 years were insufficient, leading to slow and clunky mobile websites, laden with heavy bundles and unoptimized assets.
Google AMP (Accelerated Mobile Pages) was intended to be a standard approach that pared down the HTML, the JavaScript, and the images served to mobile devices and enforced a universal CDN (content delivery network) cache. Google had the clout to accomplish all this.
The Fatal Flaw: Google relied on coercion to make AMP succeed. Moreover, the technology itself was too rigid. Google tried to force publishers to use a proprietary, stripped-down subset of HTML by threatening their search rankings. It was an anti-competitive, anti-innovation nightmare.
The Lesson: Open web standards win. Vendor lock-in disguised as “performance optimization” will eventually be routed around and rejected by the community.
You may not be working in a global powerhouse, but similar kinds of things happen even in small and medium shops. When the organization tries to enforce rigid standards on the ground-level coders, it can produce friction, resentment, and
[…]
Content was trimmed to protect the source. Please visit the original article for the full text.
Read the original article: