Talks and Presentations

Mike Amundsen


As API Architect at Layer 7, Mike Amundsen heads up the company’s API Architecture & Design Practice in North America. He is responsible for working with companies across North America to provide insight into how best to capitalize on the myriad opportunities APIs present to both consumers and the enterprise.

An internationally-known author and lecturer, Amundsen is a recognized industry expert on subjects including distributed network architecture, Web application development and cloud computing. His recent work focuses on the role hypermedia plays in creating and maintaining applications that can successfully evolve over time. He has more than a dozen books to his credit, the most recent of which is Building Hypermedia APIs with HTML5 & Node. He also contributed to RESTful Web Services Cookbook (by Subbu Allamaraju). He is currently working on a new book on RESTful Web APIs with Leonard Richardson.

Available Talks

If you are looking for slides or source code from a presentation that is not in the "Avaliable Talks" list, check out the Archived Talks section.

Essential Node.js for Web Developers


Been thinking of trying out Node.js but not sure where to start? This fast-paced session hits all the highlights; the key concepts and skills you’ll need to easily and quickly build scalable Web apps.

Unlike some introductions that spend time explaining event loops and web sockets, this session start with a typical “Hello, Node” demo and quickly moves to short, fully-functional apps that show how to deal with static files, POST forms, mashups from other servers, file manipulation, data-handling, and even supporting HTTP Authentication.

If you need to get up-to-speed on Node.js really fast, or just want to get a great introduction to coding this powerful Web server, this talk is for you.

Slides and source code from this presentation will be made available after the session.

Programming with the OSS 'Cloud-Stack'


The 'cloud-stack' development environment - one that lets you not just build cloud-based app FOR the web, but actually build them while ON the Web - is a reality. Using open source, standardized software and management tools, it's now possible to code, test, debug, and deploy web based solutions; all from a modern browser.

Tools featured in this talk include Cloud9 IDE, Node.js, CouchDB, Github, and Heroku. Attendees will see a complete project built from start to finish to deployment all using free open source software. Along the way, the notion of how a collaborative, social, online environment affects the way software is built and deployed.

Ready to join the world of Cloud-Stack development? This talk is for you.

Slides and source code from this presentation will be made available after the session.

Hypermedia-Oriented Web Services: From APIs to Affordances


As the number of available Web Services continues to grow over time, new challenges are emerging. How should versioning be supported? What is the best way to document Web Services? Is it possible to evolve Web Services over time without breaking already existing implementations? To answer these questions, this talk puts forward a new rationale for architecting and implementing Web Services; Hypermedia.

This high-level talk reviews common architectural models used in current Web Service implementations including RPC, Object-Serialization, and URI-based models. It shows the advantages and limitations of each approach and how using a hypermedia-oriented model can help overcome these known limitations by changing the focus of the architecture from a list of API calls to a set of standardized hypermedia affordances clients already understand and support.

If you are responsible for creating and/or maintaining system-level architecture for Web Services; whether within the enterprise or on the public WWW, the techniques and examples from this talk and help you improve and expand the quality and functionality of your offerings to clients.

Slides and source code from this presentation will be made available after the session.

Hypermedia-Oriented Design - Beyond the REST Hype; Toward Practical Examples


"REST, REST everywhere, but not a decent example to be found."

Today every code library and HTTP API uses the term "REST" but almost none of them include really valuable examples. Almost none of them actually rely on "hypermedia as the engine of application state." Almost none of them are any different than POX/POCO/POJO HTTP.

This talk cuts through the nonsense and shows practical working examples of hypermedia-driven web apps based on Fielding's principles of REST architecture that really work; that really support evolvability over time. And you don't need a PhD to understand them or code them, either.

If you write web apps today and are tired to re-writing your client and server every time a new function, object, and or resource URI is added to the system, this talk is for you. You'll see clear examples of hypermedia-oriented design and implementation including working clients (not just server code) with examples of server updates that not only do not break existing clients, but allow them to "auto-magically work"; even support new server functionality without client-side code updates.

Slides and source code from this presentation will be made available after the session.

What We Need is More REST and Less ROT


One of the key properties of RESTful Web applications is the ability to evolve over time. Too many Web APIs don’t evolve; they just get old, and useless; they rot. Why? Because they are little more than URI-based RPC calls returning serialized objects. Instead, Web APIs should rely on well-crafted media-type messages driven by links; they should be more RESTful.

This talk covers a handful of key design decisions that must be faced for every Web 2.0 API implementation. The choices are easy, the work is not. Too many frameworks and programming tools lead developers down the “wrong path” toward short-term expediency using record-based CRUD APIs returing XML or JSON without hyperlinks in the message; they follow the ROT (Representation Object Transfer) principles. Instead developers and architects need to ignore the “blandishments” of slick editors and frameworks and just knuckle down some hard slogging down the “right path;” the one that leads to a stable, scalable, re-usable, and evolve-able API based on Fielding’s REST principles.

Whether you are an individual developer, a small start-up, or a large, established company, now is the time to start creating more REST and less ROT (Slides).

There's a New Kid in Town: A Quick tour of NodeJS


There's a "new kid" in town and his name is "Node." Node.js is a server-side scripting platform based on a simple principle: The best code is asynchronous code.

Node.js allows developers to quickly and easily write web code that easily scales using one of the most common Web languages: Javascript. The platform is small, fast, and easily extended. It's easy to set up on any developer machine and there are even a number of public servers where you can host and run your Node.js code.

In this talk you'll get a quick tour of Node.js. You'll learn how to download and install Node.js on your system. You'll learn the basics of how it works and the base-level library functions. You'll see how you can take advantage of Node's event-base I/O, how to use and create shared modules, and how to build fully-functional Web apps that you can post to public Node hosting servers. Along the way you'll learn the how to harness the power of asynchronous while avoiding the most common pitfalls (Slides and Code).

What Is REST? : "And now for something a little different..."

All levels

When it comes down to actually understanding REST, it can be tough. There are quite a few versions of what REST "is" out there; some confusing, some contradictory, some helpful.

This talk sets out to explain the ideas behind Fielding's Representational State Transfer (REST) model; it's benefits and challenges. The presentation shows no code, no web pages, no HTTP headers or URIs. Instead, the primary motiviations of defining network architectures like REST are explored as well as the details of the REST style in particular. What are the unique architectural challenges of the Web? What key properties and features of a "purpose-designed" network model can overcome these challenges? How does one identify, implement, and verify these key properties? How does Fielding's REST address these questions? How can one use the same approach to create new networking models that go beyond Fielding's REST?

Using references to visual art, product design, and physical architecture, this talk is ideal as a high-level introduction to REST and distributed network programming in general, accessible to all levels of developer, architect, and web programmer, etc (Slides).

Archived Talks

These talks are no longer available but you can still download the slides and code.

Beyond REST : An approach for crafting stable, evolve-able Web applications


Building Web applications that can remain stable and also evolve over time (i.e. years) is an important goal for many solutions. Various strategies and models have been employed to meet this challenge (WS-*, REST, SOA, etc.) and, while each approach has its advantages and adherents, no single methodology is suited for all situations.

There are, however, aspects of Web applications - universal to all these models - that can be used to improve both thier stability and evolve-ability over time. They are: Protocol Semantics, Domain Semantics, and State Management.

This talk examines and illustrates these three distinct aspects of Web application design and the roles these qualities play in supporting stability and evolve-ability within a solution. As will be shown through various working examples, keeping these essential aspects in mind throughout the design and implemenation phases of a solution, can result in robust and flexible long-running applications that last well into the future regardless of the architectural model upon which they are based. (Slides).

Beyond Web 2.0 APIs : Implementing RESTful Hypermedia for Web Applications


As more and more data is exposed to the web, many developers find themselves building yet another Web 2.0 custom API and a custom client to match. All is fine until a change is required in the data format, the contents of a record, or the workflow of the application. Then, all bets are off and you start from the beginning again.

"Wasn't HTTP/REST supposed to solve all that?"

In this talk, you'll learn to implement RESTful Web applications using Hypermedia instead of typical Web 2.0 APIs. You'll learn how to create a single hypermedia definition that serves RIA, Desktop application, and traditional Web browsers. You'll learn how to design your API so that clients won't break when you change the data elements in a response or introduce new workflows in the application. You'll learn how to code both client and servers to allow for change over time - evolvability. And you can do it without abandoning your favorite programming language, framework or library.

Based on Amundsen's work on Hypermedia Types, this talk includes lots of code examples and access to live servers where attendees can test their own code (Slides and Code).

Programming the Cloud with HTTP/REST


Developing applications for "The Cloud" can seem daunting. The number of technologies web developers are expected to master reads like an alphabet soup: MVC, HTTP, REST, SOAP, WCF, Azure Storage, ServiceBus, Workflow, DSL, Oslo, M, etc. At the same time developers are advised to install new versions of operatings systems, Web server hosts, and developer tools all in an effort to gain advantage in the emerging world of cloud computing. However, a very powerful Domain-Specific Language specifically designed for building robust Web applications that 'live in the cloud' has been available to .NET developers from the very beginning. It's the same DSL used by Yahoo, Amazon, Google and others. It's a DSL that crosses platforms, programming languages and developer environments. This DSL is HTTP.

In this session, you'll learn how to build and use a small, powerful set of C# helper classes that allow you to 'program in HTTP' directly - bypassing multiple layers of custom class libraries that may actually complicate your development and, in some cases, hurt overall performance. Along the way you'll get a pragmatic perspective on how the REST architectural model can simplify your code, shorten your development time, improve your application's flexibility, and increase its maintainability. Finally, you'll learn how 'programming in HTTP' allows you to build applications that are both fully operational today and 'ready for the Cloud' tomorrow.

All of the examples covered in the session work on both a local web server running IIS6/ASP.NET 2.0 and in Windows Azure. Attendees get access to all the code samples including the demonstration library, all the examples, and the final code project along with the slides from the presentation (Slides and Code (2010 edition)).

Implementing a Simple Word Search Using Azure Table Storage


As 'schema-less' storage becomes more prevalent, the patterns and practices learned from relational data storage models may be inappropriate for familiar data-handling situations. One example is the task of implementing a simple word search pattern for a short message application (i.e Twitter). With schema-less storage systems, using near-match keywords such as LIKE, linking different table sets using JOIN, and sorting the returned results via secondary indexes are often unavailable. Instead, new implementation strategies must be employed to get the same results.

This talk offers a step-by-step walk-through implementing a simple word search against stored messages and compares common relational data model practices to techniques that work for schema-less storage models such as Azure Table Storage. Attendees will learn how to implement JOIN-type and LIKE-type relational patterns in Azure Table Storage and how to apply these same techniques to other projects.

The demonstration will include a live implementation allowing participants to add word data to the system and experiment with search results (Slides and Code).

Web Caching for Newbies (How to Increase Performance and Reduce Bandwidth at the Same Time)


If you are planning to implement a web-based application hosted "in the Cloud" you need to consider the cost of running the application. Not only can charges occur based on storage, but also bandwidth and even by the number of requests to the server. In other words, if your application consumes lots of bandwidth or handles lots of repeated requests for the same data, you could be in for a fat bill at the end of the month.

In this session, you'll learn how to use standard HTTP Web caching techniques to limit bandwidth and reduce request traffic while still maintaining a speedy web application for your clients. Unlike typical "SEO" techniques, this talk focuses on the coding and design details needed to implement a reliable, responsive dynamic web application that takes best advantage of the latest caching techniques used by Yahoo, Google and others. You will learn how to use the "Validation Model" to cut back on excessive bandwidth usage. You'll also learn how to use the "Expiration Model" to reduce the number of times clients need to request data from your host servers.Also, you'll learn how to easily employ compression services on selected resources to reduce the amount of content sent from your servers.

Attendees will get access to all the code samples including helper libraries that work in .NET 2.0/VS2005 and above along with presentation slides (Slides and Code).

Your Essential Web Programming Toolkit (An HTTP Swiss Army Knife)


If you are responsible for coding Web applications using HTTP you need an essential set of tools; ones that allow you to quickly and easily create applciations that can talk to Web servers over HTTP, return results, and parse those results for processing and storage. What you don't need is an entirely new framework or programming model. You don't need a new editor, a fancy widget library, or a new way to "think about programming." All you need is a single jam-packed assembly that provides clear, consistent support for HTTP services. You need an HTTP "Swiss Army Knife."

In this session you'll learn the seven key components all HTTP programming utilities should provide. You'll learn how to create classes that handle dispatching requests to the proper code block, a class to parse incoming URIs to find essential elements for processing, a class to determine the proper MIME-type to use in response to an incoming request, classes for processing incoming content, and classes to transform your results for responses. You'll also learn how to easily add support for caching and authentication/authorization services. Finally, you'll learn how to leverage existing classes in the .NET framework to create your own HTTP client to use for machine-to-machine HTTP interactions. You'll see how these class libraries are quickly and easily built using any version of the .NET framework and, once completed, can be integrated into all your existing Web applications without major re-writing of existing code.

Attendees will get access to all the code samples including helper libraries that work in .NET 2.0/VS2005 and above along with presentation slides (Slides and Code).

Understanding Azure Table Storage (How I learned to stop worrying and love the Cloud)


Anyone who has tested out Azure Storage Services knows that putting your data in the cloud is easy. Getting it back out, however, is another story. "Where's my JOIN, ORDER BY, GROUP BY, COUNT(), LIKE, BEGIN TRANS, and all that other stuff I've come to depend on?" you may ask. "Not there, not needed" is the usual reply. Be we all know different, right?

In this talk, you'll get a look behind the curtains at the "Entity-Attribute-Value" (EAV) data model that makes Azure Table Storage so fast and how you can get the most out of your data in the cloud. You'll learn why typical SQL-Server operations such as JOIN, TRANS, and COUNT() are missing and how you can overcome these limitations using common patterns for schema-less data. In addition, you'll see how you can employ new data storage designs to take advantage of the strengths of the ATS model. You'll also learn how to gain new power over your cloud data with techniques such as multi-threading, parallel processing, and pre-emptive caching using simple C# helper classes.

Attendees will get access to all the code samples including helper libraries that work in .NET 2.0/VS2005 as well as Windows Azure/VS2008 along with presentation slides.

Taking Your ASP.NET Apps to the Next Level with HTTP Handlers


HTTP Handlers are the most powerful and best-kept secret of ASP.NET. Included in the very first release, ASHX files give developers direct access to HTTP request/response streams and allow you to easily build lightning fast web apps in a short amount of time. HTTP Handlers are easy to build and maintain and the ASHX file format lets you create these speedy applications without the need to rely on compiled custom code.

In this session, you'll learn how to put HTTP Handlers work for you, how to use them to build dynamic web applications that serve up anything from HTML pages to JSON/XML APIs to PDFs and binary images. You'll also learn how to incorporate HTTP Handlers into your existing Web projects without requiring extensive rebuilding and recompiling. Finally, you'll learn how to integrate the power of HTTP Handlers in the initial design of your future ASP.NET applications.

Attendees will get access to all the code samples including helper libraries that work in .NET 2.0/VS2005 and above along with presentation slides.

Beyond Web 2.0 APIs: Implementing Successful HTTP/REST Web Services Using the Five "Killer Ds"


Recent trends show an increase in the publishing of "Web 2.0 APIs" - application interfaces that allow just about any web-aware client to access important data and mix it with other data to create new and compelling web apps. The challenge facing most developers today is how to effectively and efficiently expose application data via Web APIs without compromising security and performance. Also, what is the best way to design Web APIs to allow the most flexibility and prevent future enhancements from causing problems for existing users?

In this session, you'll learn how to implement successful Web APIs using a five-step model called the "Killer Ds." You'll learn now the describe the work-flow needed for your API to make sure users can't mistakenly or maliciously access and modify application data. You'll learn how to define and design API request and response content that best supports both your application needs and the capabilities of clients. You'll learn how to decorate these requests and responses with the proper control and meta data needed to ensure the data is used properly, protected, and available in a timely manner. You'll also learn how to defend your data using standard authentication and authorization schemes that are easily understood by a wide rang of web clients. Finally, you'll learn how the "Killer Ds" pattern helps you add future modifications and enhancements without adversely affecting existing clients.

Attendees will get access to all the code samples including helper libraries that work in .NET 2.0/VS2005 and above along with presentation slides.