Runscope API Testing and Monitoring    Learn More →

This Fortnight in APIs, Release VIII

By Ashley Waxman on .

This post is the eighth in a series that collects news stories, helpful tools and useful blog posts from the previous two weeks and is curated lovingly by the Runscope Developer Relations team. The topics span APIs, microservices, developer tools, best practices, funny observations and more. This post is also our final Fortnight of this year. Thank you for giving us such great stories to share, and get excited for more Fortnight in 2016!

For when you want to eat your own dogfood, but there’s not a server in sight:

We’ve largely moved away from running bare metal servers in the data center to virtual servers in the cloud. The same can be said of migrating disk, SAN and NAS storage into virtual volumes in the cloud. The team from Teletext.io chronicles how they’ve built their startup entirely on AWS, taking virtualization to the next level and removing all semblances of traditional server architecture. In The Serverless Startup—Down with Servers!, the team explains how they use Amazon API Gateway, Lambda, DynamoDB, S3 and CloudFront—without a single server to manage, not even EC2.

For when visibility is in the eye of the beholder:

In 2015, microservices was certainly one of the biggest buzzwords, sparking debate from both micro- and monolith-supporters about scalability, operational complexity and resources over which is the better infrastructure. The Segment blog recently released a post that explores a different angle: visibility. In Why Microservices Work for Us, the API-led analytics company’s founder Calvin French-Owen describes how monitoring microservices makes it significantly easier to gain visibility into each “microworker”, and how his 10-engineer team has scaled to 400 private repos and 70 different services.  

For when your newspaper starts printing in JSON:

On The New York Times’ blog Open, written by NYT developers about code and development, the company announced that it is open sourcing an internal projectGizmo is a toolkit that offers four packages to help developers configure and build microservice APIs and pubsub daemons. Gizmo came from the company’s years-long move to adopting Go, which it primarily uses for writing JSON APIs. This is an exciting move for NYT establishing itself as a technology company, and the toolkit is great for anyone looking to adopt Go and microservices.

For when all you’re asking for is a little accept (just a little bit) #Aretha:

You most likely use Content-Type in your POST and PUT calls, which informs the API the type of data you’re sending. But how often do you use the Accept header? That’s the other half of content negotiation where you designate the type of response you’d like to receive from the API. This article from Restlet helps you to understand the basics of content negotiation.

For when you use continuous deployments—do or do not, there is no try:

There are a lot of things we know we should be doing, but the barrier to entry is great enough that we shy away—such is the case with deployment pipelines, a process that many are quick to tout the value of, but not as many have had the time to invest in building out internally. In The Case for Deployment Pipelines, Keith Casey, Director of Product at Clarify.io, explains the tools and processes his team used to build continuous delivery pipelines on microservices and AWS. With CD pipelines, Clarify.io now experiences improved workflow, increased confidence and reduced risk, and Casey explains these benefits in depth.

For when you think your docs are all that and then some:

So you’ve defined your API using Swagger or API Blueprint, spun up the docs generator and the API documentation is all done, right? Not quite, writes James Higginbotham. In this article on the LaunchAny blog, he suggests that API docs have audiences that include more than just developers, and that we need to go beyond offering only referential documentation.

For when there are some habits you just don’t want to break:

Monitoring can be a loaded term, and the practice extends from your servers, to your APIs, to third-party APIs, to apps. Librato recently published 7 Habits of Highly Successful Monitoring Infrastructures to help take your monitoring practices from creating problems to solving problems. This article covers all the bases: why you’re monitoring (data, feedback, single source of truth), what you’re using (micro vs. monolithic systems), when to monitor (throughout the entire development lifecycle) and more. In a pinch, you can view a snapshot of the post on the Librato blog.

For when you want to start the new year design-first:

If you couldn’t make it to API Days New Zealand this October, the video of the keynote presentation by Jason Harmon, Head of API Design at Paypal, is now available. Jason presents on Design-First APIs in Practice, beginning with a deep-dive into design principles that are commonly held outside of the software world, but have yet to be widely recognized within software. He then shows how you can apply these principles to your APIs to improve efficiency, discovery and adoption. 

For when you need to find the force within you:

While we’re always looking for the latest tools, it never hurts to take a step back and learn about organizational health and leadership. In a look back on 2015, Codeship has compiled the best of its many interviews with tech leaders over the year in a piece chock-full of advice that answers, What Are the Challenges of Leading in Tech? This post draws on experiences from leaders like Brendan Schwartz, CTO of Wistia; Peter Van Hardenberg, founding developer of Heroku Postgres; and our own Co-founder and CEO John Sheehan.   

Categories: apis, api ecosystem, this fortnight in apis

Everything is going to be 200 OK®