On Monday, the 6th of November, in Chicago, Illinois, AppDeveloperCon was held during the co-located events at KubeCon North America 2023. The full-day event focused on cloud-native developers and featured talks on CNCF projects (such as OpenFGA, Dapr, TestContainers, and OpenFeature), eventing, patterns like choreography/orchestration, and ways of working in today’s cloud-native environments.
The idea of creating the AppDeveloperCon came from Mark Fussel, co-founder of Diagrid and co-creator of Dapr, which was one of the developer-focused frameworks covered during the day.
“We started AppDeveloperCon because we would come to KubeCon and we wouldn’t really hear about the Application Developer,” Fussells said. He went on to say that’s why he approached members of the CNCF back in February about a conference for developers. AppDeveloperCon is the culmination of those conversations.
Fussells kicked off the event by describing developer needs with a comparison to Maslow’s hierarchy of needs, where fundamental needs in Maslov’s work of "food, shelter, and warmth" can be compared to fundamental needs a developer has for "cloud-native infrastructure". While infrastructure isn’t the focus of what a developer needs to do, it's the foundation for being able to move up the hierarchy to things they really care about. Developers are hoping to move towards "business value and application innovation", but before they can get there (much like Maslow’s hierarchy’s journey to Self-Actualization), there are things that developers have to have available first. These are things like CI/CD, observability, security, scalability, and integrations to core services.
According to the CNCF Transparency Report for the 2023 KubeCon EU event, 16K people attended the conference in Amsterdam earlier this year. Of those attending the KubeCon EU, 2,971 identified as developers. AppDeveloperCon was created to serve that audience directly at KubeCon NA.
The inaugural AppDeveloperCon drew an average of 210 people per session throughout the full day. The day peaked at 325 attendees during a talk by Carlos Santana and Mithun Mallick, both Solution Architects at AWS, on Crafting Resilient and Scalable Systems with Orchestration and Choreography Patterns on Kubernetes.
The first session of the AppDeveloperCon was focused on developer experience. The talk, entitled Wiring Cloud Native Applications for Local Development, was given by Mauricio "Salaboy" Salatino of Diagrid & Oleg Šelajev of AtomicJar. The talk was focused on how a combination of Dapr (an OSS project that provides application-level APIs to solve common cloud-native challenges) and Test Containers (an open-source framework for providing throwaway, lightweight instances of databases, message brokers, web browsers that are used for local development, integration tests, and CI/CD pipelines) can be used to create a production-like experience on a developer’s local machine without the cognitive load required in wiring infrastructure components often found in cloud native systems today.
To demonstrate the ideas, Salatino and Šelajev created a simple event-driven application of three services and a frontend that passes messages via Kafka and stores state in Postgres (the source code is available on source code is available on github).
Šelajev described the number of things developers have to consider when developing an application that is not core to the logic of the system as a distraction (things like creating Kafka and Postgres instances in his example). He went on to say, as a developer, we’re interested in working on the logic of the system (the yellow boxes in the image below). Šelajev said, “I’m interested in the code and maybe the communication patterns. Everything else is an overhead that I need to pay.” Salatino then described a simpler version of the same system that leveraged the abstractions provided by Dapr and implementations of infrastructure by Test Containers. Combining the two reduces the cognitive load on developers building a system like what they describe.
To understand more about how Dapr works, consider it in a K8s environment. Dapr is installed into your cluster, and the application is configured to interact with its APIs rather than directly to the infrastructure components and services. It works because Dapr injects sidecars next to your application containers. Those sidecars expose APIs that developers use to communicate with infrastructure components and services. The application itself then interacts with those APIs. The effect is a decoupled system that allows a developer (or a platform team in the production environment) to define the implementation through configuration. The code itself doesn’t change. During development, the developer stays focused on the logic and calling APIs, not on the infrastructure or systems they need to interact with.
Using Test Containers to provide the implementation for things like Kafka or Postgres gives developers a seamless local developer experience without configuring the infra.
Another developer tooling talk happened later in the day. Adam Gardner of Dynatrace discussed progressive delivery and OpenFeature. Garner discussed OpenFeature as a way of abstracting feature flag implementation details away from your code. OpenFeature is an open specification that provides a vendor-agnostic, community-driven API for feature flagging that abstracts out the implementation from how feature flags are used in applications.
Feature flags, also known as feature toggles or feature switches, are a software development technique that turns certain functionality on and off at runtime without deploying new code. This allows for better control and more experimentation over the full lifecycle of features and is often a key component in using trunk-based development and implementing continuous delivery.
OpenFeature has a tagline of “One SDK, any backend.” An open-source implementation of a CRD-based feature flagging backend solution is available by visiting the OpenFeature GitHub account. You will find an implementation and sandbox of the OpenFeature Operator, based on flagd (an open-source feature flag evaluation engine ready-made for working with OpenFeature).
By using OpenFeature, a developer can code to a single API and implement a backend using something like the flag-based OpenFeature operator and then later switch as needs change to a different provider such as one offered by LaunchDarkly, CloudBees, PostHog, or Go Feature Flag. A full list of implemented backends or how to implement your own is available on their GitHub account.
In addition to the talks on local development with Dapr/Test Containers and Progressive delivery with OpenFeature, AppDeveloperCon at KubeCon had 14 other sessions and lightning talks, including:
- Lessons Learned Migrating an Existing Product to a Multi-Tenant Cloud Native Environment - Natalia Angulo & Carlos Sanchez, Adobe
- Modernizing Authorization for Cloud Native Applications Using OpenFGA - Andres Aguiar & María Inés Parnisari, Okta
- Crafting Resilient and Scalable Systems with Orchestration and Choreography Patterns on Kubernetes - Carlos Santana & Mithun Mallick, AWS
- Preview Environments: Now Everyone Is Part of the Software Development Process - Ramiro Berrelleza, Okteto & Sully Martinez
- Run Your CI in Code, Not YAML - Kyle Penfound, Dagger
You can view the complete schedule for the AppDeveloperCon online, and the video has been posted to their YouTube channel.
AppDeveloperCon is a co-located event that occurred before KubeCon North America 2023. KubeCon is the flagship conference that gathers adopters and technologists together around the CNCF ecosystem. The CNCF ecosystem includes projects like Kubernetes, Istio, Backstage, Flux, Envoy, Cilum, and many more. A full list can be viewed on the CNCF landscape