The secret to building better software? Get in control of your APIs

It's no secret that APIs are a blessing and a curse. Talk to any developer—at a startup or a giant—and they'll be grateful for the power that APIs give, but frustrated with the ever-spiraling web of dependencies. In this post, I talk about our approach for taming this complexity.

The problem is that modern software systems are entire rainforests, but all of our tools measure single trees. Below is Netflix’s iconic “death star” graph of their software architecture, an entire ecosystem of interconnected internal and external services. I bet you've seen something similar. For data leaks, performance, resource usage, we can monitor any individual node easily--but tracking it across nodes? Network monitoring addresses one edge at a time. And let's not even get into tracking external APIs.

What led me to start Akita is the observation that one of the main causes of the complexity is also the solution. For the last decade, first as a PhD student at MIT and then as a professor at CMU, I’d been working on programming languages for keeping track of data in complex software systems. The models I was working with were simple and clean: a far cry from the dynamically typed, semantically messy languages that are popular today. As the API revolution was unfolding, I had been getting increasingly concerned about how to model modern languages interacting in these heterogeneous systems.

It turns out that APIs give us just what we need to bring order to the interconnected web of plants and animals in our software rainforest. Most programming languages research happens using simple, declarative models. While there’s often a gap between those models and mainstream programming languages, API specifications are both simple and declarative. I realized that the ideas that my research group and I had been working on at the language level, for example type inference and invariant generation, could be applied at the API level to automate many things people are currently doing manually. We’ve used this observation to build some powerful tooling. In upcoming blog posts, we’ll be sharing more about these tools and how they work under the hood. (And how we abstract over the distributed systems problems!)

At Akita, we’ve figured out how to give you API-based software tooling that is completely self-serve, doesn’t require any code changes, and able to give you high-fidelity information about how your APIs are working together. Together with my team of API and dev tooling experts from places like Twilio and AWS’s Formal Methods group, we’re building a solution that helps you:

• Work better—with third-party APIs. Integrate more smoothly with third-party APIs by understanding how you’re calling them, what you’re sending to them, and when the interaction changes.
• Automatically generate API specs. Akita helps you automatically keep API specs up-to-date with every pull request, without additional developer work.
• Focus on the code that matters. We help you measure how well your test coverage reflects production traffic, allowing you to optimize for exactly what happens in practice.
• Catch bugs faster. Run us on every pull request! Catch and fix breaking API changes early with our API regressions.

Want to learn more? Join our private beta if building the next-generation of developer tooling, one abstraction layer up, sounds exciting to you!