The Great Divide: Why Web Dev Practices Aren’t a Silver Bullet

Introduction: From Friends to Foes in a Debate Over Code

Imagine a reunion of MIT alumni from the 90s. As seasoned tech veterans, we gathered not just to reminisce but to dive into heated discussions about our career paths. I embarked on my tech journey in the early 90s, delving into the world of system-level development, while my friends, a few years younger, caught the wave of the web development boom in the late 90s. Our conversation soon revealed a startling truth: each of us, wrapped in our professional bubbles, thought that our development process and methods where the right ones. This article explores the dangers of this one-size-fits-all mindset, particularly as web development practices increasingly encroach on domains where they might not fit.

The Meteoric Rise of Web Development: Speed Over Substance?

In the 90s, the Internet exploded, and with it, web development surged to the forefront of technology. It promised rapid deployment and immediate user feedback, quickly becoming the main part of modern software creation.

Web development thrives on speed and flexibility. It’s about getting content and features out the door as fast as possible to keep up with the relentless demands of users and the market. This urgency is supported by practices like:

• Continuous Integration and Continuous Deployment (CI/CD): These processes enable developers to integrate changes frequently and deploy updates rapidly. Tools like Jenkins, GitHub Actions, and Travis CI automate testing and deployment, allowing for swift roll-outs of new features or bug fixes.

• Micro-services and APIs: Modern web applications often decompose functionality into smaller, independent services that communicate through APIs. This architecture simplifies scaling and managing complex systems.

• Frameworks and Libraries: Popular tools such as React, Angular, and Node.js empower developers to build responsive and interactive user interfaces swiftly.

The tools and practices in web development—cloud services, APIs, continuous integration (CI), and DevOps—are tailored to creating and deploying applications that can scale and adapt quickly to user demands. This ecosystem encourages rapid iteration and deployment.

However, this focus on rapid iteration and deployment can be a double-edged sword. While it's ideal for the fast-paced realm of web applications, these practices can be problematic in environments where stability and long-term reliability are crucial.

System-Level Development: The Forgotten Hero

System-level development involves software that underpins all our digital infrastructure, operating systems, embedded applications, servers, databases, device drivers, and low-level libraries. Here, reliability and performance are critical. Development requires a meticulous approach, with rigorous testing processes such as:

• Smoke and Sanity Tests: These tests quickly check the basic functions of a system to ensure stability after changes. Smoke testing verifies that the most critical functionalities work, while sanity testing ensures a specific function or bug fix operates correctly.

• Module Testing: This involves testing individual components or modules of a system independently to ensure they perform as expected. It’s crucial for verifying that each part of a system can work in isolation before being integrated into the whole.

• Performance Bench-marking: Assessing the system’s performance under various conditions, including stress and load, to ensure it meets the required benchmarks.

• Regression Testing: Ensuring that recent changes have not adversely affected existing functionality, maintaining overall system stability and performance.

Imagine developing an operating system or server with the same casual integration and iterative testing as a web application. The results could be catastrophic—systems crashing, security vulnerabilities exposed, and performance bottlenecks crippling essential infrastructure.

Application-Level Development: Bridging Performance and Usability

Application-level development encompasses high-performance tools and desktop applications—think Adobe Photoshop or complex games. These applications require a blend of user centric design and deep system integration. Here, unit testing and integration testing are crucial to ensure components work seamlessly together. Additionally, performance and load testing are essential to guarantee that the application can handle significant data and user interactions without degradation.

Applying web development methodologies in these contexts could lead to sub-optimal performance and reliability issues, given the need for precise control over system resources and real-time interactions.

Web-Level Development: Fast, Flexible, and Financially Driven

Web-level development is all about rapid content delivery and dynamic user interactions through browsers and mobile devices. This field covers front-end development (user interfaces), back-end development (server logic (not servers!)), and the integration of various services and APIs that enhance functionality and scalability.

In web development, agility and speed are paramount. The focus is on deploying updates quickly to respond to user feedback and market changes. This approach is not just about technology but also about driving engagement and, ultimately, revenue. Practices in web development often include:

Unit testing and fast iteration cycles are vital in this realm to quickly validate new changes.

Real-World Consequences: Learning the Hard Way

Misapplying web development practices can have severe consequences. The Boeing 737 MAX disaster is a sobering example. The Maneuvering Characteristics Augmentation System relied heavily on input from a single sensor, mirroring web development’s emphasis on rapid integration and minimal redundancy. However, in the world of aviation, this approach led to two tragic crashes, resulting in 346 deaths and a brutal loss in trust for Boeing . The lack of thorough testing and the assumption that issues could be patched later proved disastrously inadequate for a system where safety cannot be compromised.

Similarly, Tesla’s aggressive deployment of its Autopilot and Self-Driving systems reflects web development’s rapid update cycles. In 2023 alone, Tesla faced recalls involving over 362,000 vehicles due to crashes and other safety concerns . These incidents occurred because features were released before being thoroughly vetted in real-world scenarios, highlighting the dangers of applying web-style agility to autonomous systems where safety is paramount.

The Risk of One-Size-Fits-All Development

The rise of web development has led to a pervasive belief that its methodologies are universally applicable. This mindset can be dangerous, particularly when it leads to the misapplication of web practices in system-level and application-level projects.

Applying web development’s rapid iteration and deployment strategies to system-level projects could undermine the stability and security of critical infrastructure. The Boeing 737 MAX issue is a prime example where iterative updates without thorough testing led to catastrophic failures. Similarly, integrating web-style agility into performance-critical desktop or server applications can result in sluggish and unreliable software. Each domain has unique demands that require tailored approaches to development and testing.

Embracing the Diversity of Software Development

As we navigate the multifaceted landscape of software development, it’s crucial to appreciate the diversity of skills, methodologies, and testing practices across different domains. Web development has undeniably transformed how we build and deploy applications, but it’s not a catch-all solution for every challenge.

System-level and application-level development demand their own rigorous approaches to ensure the robustness, performance, and reliability of software. Recognizing and respecting these differences is crucial for developing software that meets the highest standards of functionality and security.

In the end, the best path forward is to leverage the strengths of each development approach, understand their limitations, and apply them wisely to the contexts they best serve. By doing so, we can continue to innovate and build software that not only works but excels in its intended environment.

"Mastering the art of managing software development & products means knowing that one size doesn’t fit all and tailored approaches are needed to meet the distinct needs of each project."

-- S.P Mattias Bergström -- 2024