Rethinking Infrastructure as Code: The Second Wave of DevOps and IaC by Winglang

Introduction

Picture this: You're sitting at your desk, sifting through lines of Terraform code, and you can't shake the feeling that something's off. It's like you're trying to assemble a puzzle, but the pieces keep changing shapes. Then, you stumble upon an article by Nathan Peck, and it's like someone turned on a light. Nathan's words resonate with you, articulating the unease you've felt but couldn't put into words. It's time for a change—a second wave in DevOps and IaC. And as you'll soon discover, Winglang might just be the surfboard we all need to ride this wave.

The DevOps and Infrastructure as Code (IaC) landscapes have seen significant advancements over the years. However, as cloud ecosystems grow in complexity, so do the tools and practices we use. Nathan Peck's article on rethinking IaC and the "Second Wave DevOps" piece from System Initiative both point to the need for a new approach. Enter Winglang, a cloud-oriented programming language that promises to simplify the cloud development process. Could this be the future of DevOps and IaC? Let's dive in.

The Current State of DevOps and IaC

DevOps has come a long way since its inception, with best practices like CI/CD, feature flags, and shared observability becoming the norm. However, despite these advancements, 88% of companies still can't deploy more than once a week. Similarly, IaC tools like Terraform and CloudFormation have become increasingly complex, making them hard to manage and scale.

The Problems

1. Complexity: Both DevOps and IaC are grappling with the complexities of modern cloud services.
2. Stagnation: The tools and practices have evolved, but the overall system design hasn't kept pace.
3. User Experience: DevOps work is often filled with "tiny papercuts," making it the worst part of building a modern application.

The Need for a Second Wave: A Closer Look

The DevOps and IaC landscapes are at a crossroads. While the tools and practices have evolved, the overall system design hasn't kept pace with the complexities of modern cloud services. Two thought-provoking articles—Nathan Peck's "Rethinking Infrastructure as Code from Scratch" and System Initiative's "Second Wave DevOps"—highlight the need for a new approach. Let's delve into each.

Nathan Peck's CSS for IaC: Simplifying Complexity

Nathan Peck argues that as cloud services grow in complexity, the IaC tools we use are becoming increasingly complex and unmanageable. He suggests that we need a new approach to make IaC more scalable, maintainable, and easier to understand.

The CSS Analogy

Nathan draws an analogy with HTML and CSS in web development. Just like CSS allows you to separate styling from content, he proposes a similar layer for IaC. This layer would let you group configurations into "traits" that you can apply to multiple resources.

Benefits of Traits

• Easier to Read: Semantic names for configurations.
• Scale Expertise: Senior devs can create these traits, and junior devs can apply them.
• Centrally Updatable: Change the trait in one place, and it updates everywhere.
• Clean Removal: Removing a trait removes all its settings.

System Initiative's Second Wave DevOps: Rethinking System Design

The "Second Wave DevOps" article takes a broader view, focusing not just on IaC but on the entire DevOps landscape. It argues that despite the cultural shift towards DevOps, the tools and practices have not evolved to meet the complexities of today's cloud ecosystems.

• The Stagnation Problem: The article points out that what worked for John Allspaw and Paul Hammond in 2009 is, in broad strokes, what we have been asking every single DevOps practitioner to do since. We've optimized individual parts of the system but haven't rethought how the whole system is put together.

• The Call for a System Overhaul: The article calls for a "second wave" of DevOps tools that focus on improving the daily experience of DevOps work. It's not just about automating tasks but reimagining the entire workflow and system design.

• The Risk of Not Changing: If we don't adapt, we risk the DevOps culture itself. The failure of our implementations could put the success of our culture change at risk, taking us back to a time when DevOps didn't exist, which was unequivocally worse for everyone involved.

Enter Winglang: A Cloud-Oriented Programming Language

As we grapple with the complexities and challenges in the DevOps and IaC landscapes, Winglang emerges as a potential game-changer. Designed to abstract away the intricacies of underlying cloud infrastructure, it allows developers to focus on what matters most: the application logic. But what makes Winglang stand out? Let's dissect its key features and see how it could be a cornerstone in the second wave of DevOps and IaC.

The Philosophy of Cloud-Oriented Programming

Winglang is built on the philosophy of "cloud-oriented programming," a paradigm that treats the cloud as a single, unified computer. This approach heavily relies on managed services and distributed programming to build systems that are intrinsically scalable, highly-available, and robust. It's a shift from seeing the cloud as a collection of services to viewing it as an integrated computing environment.

This philosophy aligns well with the calls for a second wave in DevOps and IaC. By treating the cloud as a unified system, Winglang inherently addresses many of the complexities and "tiny papercuts" that DevOps engineers face daily.

Watch Winglang Quick Introduction Video

Winglang Key Elements

• High-Level Cloud Primitives: The Batteries-Included Approach: One of Winglang's standout features is its high-level cloud primitives. These are essentially pre-built, cloud-portable resources that you can plug into your application, much like importing a library in traditional programming languages.

• The Power of Abstraction: These high-level primitives allow developers to leverage the full extent of the cloud without having to be infrastructure experts. It's akin to Nathan Peck's idea of using CSS-like "traits" to simplify configurations, but Winglang takes it a step further by integrating these abstractions directly into the programming language.

• Local Cloud Simulator Developer's Dream: Winglang comes with a local cloud simulator, allowing you to run your applications locally. This is a game-changer for debugging, testing, and iterative development.

• The Speed of Iteration: The local cloud simulator enables developers to see the effects of incremental changes at milliseconds latency. This aligns with the "Second Wave DevOps" article's call for tools that improve the daily experience of DevOps work.

• Infrastructure as Policy: A Horizontal Approach: Winglang introduces the concept of "Infrastructure as Policy," where infrastructure concerns like deployment, networking, and security can be applied horizontally through policies, rather than being hardcoded into the application.

• The Benefit of Separation: This feature allows for a clean separation between application logic and infrastructure concerns, making the codebase easier to manage and scale. It's a practical implementation of the "second wave" philosophy that calls for a complete overhaul of system design.

Conclusion

The complexities of modern cloud ecosystems demand a new approach to DevOps and IaC. Whether it's Nathan Peck's idea of CSS for IaC, System Initiative's call for a second wave in DevOps, or Winglang's cloud-oriented programming, it's clear that we're on the cusp of a significant shift in how we approach cloud development and operations.

Winglang seems to encapsulate many of the ideas and needs expressed by thought leaders like Nathan Peck and System Initiative. By offering a new way to approach cloud development, it could very well be a key player in the next wave of DevOps and IaC innovations.