Showing 12 out of 12 results


Unlock the Secrets of Great, Lasting APIs

Have you been tasked with creating a web APIs for your organization? Mike Amundsen, author of the book "Design and Build Great Web APIs,” goes through some of the secrets of building great APIs and what the best process and tools are for doing that.

September 10, 2020

Principles of Web API Design: Delivering Value with APIs and Microservices

James Higginbotham, author of “Principles of Web API Design”, outlines the key points of creating and using APIs in today’s world. In the conversation with Mike Amundsen, author of “RESTful Patterns and Best Practices for API's Cookbook” you discover the principles of James’ ADDR process and how job stories and event storming contribute to a successful API launch. Furthermore, they touch upon key terms such as minimum viable portal and why API boundaries are so hot at the moment.

May 19, 2022

Restful Web API Patterns & Practices Cookbook

The API ecosystem is constantly evolving while the focus is changing in some cases from designing them to the implementation phase. Mike Amundsen, the author of the Restful Web API Patterns & Practices Cookbook, and Alianna Inzana, VP of Product at WeTransfer, are covering these recent changes while also touching on broader subjects like evolvable architectures. Join them for a BookClub episode revolving around “Restful Web API Patterns & Practices Cookbook”

June 30, 2022

Not Just Events: Developing Asynchronous Microservices

The microservice architecture functionally decomposes an application into a set of services. Each service has its own private database that’s only accessible indirectly through the services API. Consequently, implementing queries and transactions that span multiple services is challenging. In this presentation, you will learn how to solve these distributed data management challenges using asynchronous messaging. Chris will share with you how to implement transactions using sagas, which are sequences of local transactions. You will learn how to coordinate sagas using either events or command messages. Chris will also explore how to implement queries using Command Query Responsibility Segregation (CQRS), which uses events to maintain easily queried replicas.


Building HTTP API SDKs that Really Are a Kit

This talk will discuss the challenges of building HTTP API SDKs and what our two pizza sized team has learned from building SDKs for the Microsoft Graph. Microsoft Graph is an API with more than a billion users and 100K+ active client applications. We will discuss the architectural principles and design that we used to build SDKs that benefit developers of all skill levels. Our approach to SDK design supports scenarios from desktop applications that make a few dozen calls a day, to services that make millions of calls a day. Whether you are looking to support just a single language for a small internal API or a dozen languages for a API product based company, this talk will have something of value for all developers who work with HTTP APIs. **What will the audience learn from this talk?** Attendees will learn a strategy for decomposing the capabilities of a HTTP Client SDK into a flexible set of architectural components that needs the needs of a wide range of developers and will hear feedback on how Microsoft Graph customers have taken advantage of this architecture. **Does it feature code examples and/or live coding?** Yes, this session will demonstrate using one of the SDKs in a variety of different ways to show the flexibility **Prerequisite attendee experience level:** Level [300](https://gotocph.com/2019/pages/experience-level)


Declarative APIs in an Imperative World

Declarative UI frameworks have taken over the JavaScript landscape. Which is great, because making assumptions about your application's state is a source of pain, frustration, and bugs. But what happens when you need to glue together imperative APIs with your declarative UI framework? In this talk, I'll explain some problems the Atom Editor team came across when we started using React as our UI framework, as well as the solutions we came up with. Together, we'll explore how to generalize these patterns to tackle other imperative APIs you might come across in the wild, such as animation libraries. Finally, I'll explore the relationship between declarative UIs and functional programming, why functional programming has risen in popularity, and how we can learn from the history of programming language trends over time to avoid making the same mistakes over and over. **Academic level:** Intermediate **What is the take away in this talk:** How to use imperative APIs


Adopting gRPC: Overcoming Team and Technical Hurdles

gRPC and Protocol Buffers are becoming industry standards for exchanging data across systems and stitching together micro-services to build scalable applications. But there are barriers for new teams that want to adopt gRPC, such as minimal tooling for testing, inspecting, and interacting with gRPC servers. At FullStory, we've adopted gRPC and have developed general-purpose tools to overcome some of the inherent challenges. In this talk, we will introduce gRPC to those unfamiliar and discuss its benefits and tradeoffs, We will also describe other obstacles to adopting gRPC, and discuss patterns and best practices that can help overcome these obstacles to make developers more productive. Lastly, we’ll demo some of the tools that FullStory has built, grpcurl and grpcui, showing how they make gRPC more approachable and easier to work with. This is a partner talk.


HTTP/3 is next Generation HTTP. Is it QUIC enough?

HTTP/3 is the designated name for the coming next version of the protocol that is currently under development within the QUIC working group in the IETF. HTTP/3 is designed to improve in areas where HTTP/2 still has some shortcomings, primarily by changing the transport layer. HTTP/3 is the first major protocol to step away from TCP and instead it uses QUIC. Daniel Stenberg does a presentation about HTTP/3 and QUIC. Why the new protocols are deemed necessary, how they work, how they change how things are sent over the network and what some of the coming deployment challenges will be. **What will the audience learn from this talk?** They will learn some of the fundamental features of and differences between HTTP/3 and previous HTTP versions and why those changes are coming. **Does it feature code examples and/or live coding?** Nope **Prerequisite attendee experience level:** [200](https://gotocph.com/2019/pages/experience-level)


Discovering RESTful Web Microservices: A Traveler's Guide

Navigating the landscape of scalable, resilient Microservices can be tricky. While each service fulfills a different purpose, there are a handful of shared properties of microservices. Knowing what these properties are and how to implement them is vital to creating robust components that are available and reliable on demand. The scalability and resilience of the WWW of documents and WebApps gives us some clues on how powerful and reliable Internet-level Microservices can be implemented. And, almost 20 years ago, Roy Fielding documented an approach to meeting the challenge of network-based software; an approach often called RESTful. Using a mix of story-telling and code examples, this talk identifies key elements of each of these three things -- REST, the Web, and Microservices -- and shows how you can apply these elements to your own projects to gain the flexibility, resiliency, and scalability you need in order to build the three types of Microservices (Stateless, Persistence, and Aggregator) with the interoperability of the WWW and the adaptability of RESTful network systems. **Academic Level** Intermediate to advanced **Who Should Attend?** Whether you are a software architect, developer, or project/product manager, this talk will have something for you. **What You'll Learn** Topics/Concepts covered in this talk include: * The three basic types of microservices (Stateless, Persistence, Aggregator) * How to apply Michael Nygard's Stability Patterns to microservices * How REST architecture can improve microservices * What we can learn from the WWW when implementing Microservices * How use runtime service discovery to improve microservices


OAuth Tokens As Your Identity API

You have an OAuth server, now what? In this talk, Jacob will illustrate how OAuth and OpenID Connect can be leveraged to deliver agility and scalability while also ensuring security. Distributed systems bring with them complexities surrounding identity. How should end-user identities be traced and delegated? How can we manage user permissions across groups and in large organizations? Jacob will explore a standards-based approach using protocols like OAuth and OpenID Connect, highlighting patterns for large scale deployments while keeping things simple. We’ll also see how identity is preserved and utilized within complex software delivery networks like Kubernetes.


Introduction to OpenAPI

Open API Specification is a machine and human readable way to describe APIs. From these specs we can generate documentation, create libraries, and ensure that our users know exactly what to expect from our APIs.<br /> This talk shows you around OAS from the beginning, showing how to create the specs and recommending some tools to help the process. Once you have the spec, things get interesting and this talk will showcase some of the things that you can offer once your API is described in this way. This session is recommended for writers looking to become more API-savvy and API engineers wanting to make their APIs more useful to their users. **What will the audience learn from this talk?** Attendees will learn about describing their APIs using OpenAPI specification, and what can be produced from the descriptions, such as documentation, tests, and even code. **Does it feature code examples and/or live coding?** Code and spec examples are included (in large font for illustration purposes), but no live coding. **Prerequisite attendee experience level:** Level [100](https://gotocph.com/2019/pages/experience-level)


Boost your API Development with GraphQL & Prisma

GraphQL is taking over the industry and replaces REST as a new API standard. Originally developed by Facebook, it is already used in production by companies like GitHub, Twitter, Airbnb and a lot more. This session gives a thorough introduction into GraphQL, explains how it works and what the benefits are compared to traditional API standards like REST. We'll further explore how Prisma's auto-generated database client helps you build fully type-safe GraphQL servers without writing boilerplate.