Robust API Design for Systems

Abstract of the talk:
An Application Programmable Interface (API) is the way we interact with a system. This is NOT restricted to web APIs, and is true of every software system. Most of the time, when we design APIs by writing methods and classes, we don't really think about what does it mean to have a function like this, or a class, or a module declared this way? But everything about an API means something, and serves to describe a system. What do we need to think about when writing our APIs? How do we differentiate between a good and a bad API? The world is unsurprisingly abundant in bad APIs - and worse implementations. In this session, we'll look at what makes an API good, and how to design them well.

Towards this, we'll take a relatively trivial problem and try to come up with a really robust API. Along the way, we'll tackle concepts like security, reduce failures or bugs, self-documentation, and performance - most of which are not even considered features of an API, but implementation concerns. Let's challenge this notion for an hour and see where it takes us.

Pre-requisites for Attendees:
- Beginner level understanding of APIs will help
- Basic understanding of static types and familiarity with a typed language like Java will help
- A little bit of interest in designing good APIs - both on and off the web - will help
- Interest in concerns like accuracy, backward compatibility, security, and performance will help
None of these are hard requirements, we can learn as we go.

Take Aways From The Talk:
Anyone interested in writing good code, or writing good APIs that will be consumed by others will benefit from this session's discussion points. You will also learn that APIs can also solve several other concerns that are usually left to be dealt with at implementation level like security, error handling, and performance. In general, even if you disagree with the arguments of this talk, you will walk out a little more thoughtful about API design.