David Denton
Engineering Lead // Founder // Trainer // Speaker // Kotlin GDE // Co-creator of http4k
London, United Kingdom
Actions
Highly experienced Engineering Lead specialising in TDD, software craft, debt-resolving, mentoring and straight talking.
Particularly specialised with ContinuousDeployment solutions: JVM, JS & a quick study in others. Everything-as-code automation. Build-craft. Refactoring wizard. Legacy-code cleaner.
International speaker. Mentor, Co-founder of Monopolis (https://monopolis.cloud). Co-creator of the popular http4k platform (http://http4k.org) and recognised Kotlin Google Developer Expert.
Area of Expertise
Topics
Client as a Function: The Missing Half of the Story
Server as a Function revolutionised how we think about HTTP server design with http4k. But what about the other side of the equation? This talk introduces the Connect pattern and its Kotlin reference implementation http4k Connect, which brings the same functional simplicity to API client design.
While we carefully compose our server-side APIs from small, focused functions, API clients often remain monolithic classes with dozens of methods. The Connect pattern challenges this asymmetry by modelling API clients as pure functions that accept "actions" - a pattern that mirrors how servers accept requests.
We'll explore how treating clients as functions enables powerful composition patterns, simplifies testing through protocol-compatible fakes, and creates lightweight implementations perfect for Serverless environments. Using http4k Connect as a reference implementation, we'll see these principles in action using Kotlin's powerful type system.
Key takeaways:
- Breaking client monoliths with functional symmetry
- Pattern principles and implementation
- Testing and composition
Although we'll demonstrate these concepts using http4k libraries, the principles behind the Connect pattern apply across all languages and frameworks. Join us to discover how bringing functional thinking to client design can help you write cleaner, more testable HTTP clients, regardless of your technology stack.
Full Stream Ahead: Breaking the protocol barrier with http4k
HTTP's request-response pattern has served us well, but modern web applications demand more. Real-time communication demands different protocols, yet maintaining testability and simplicity remains crucial to developer experience.
In this talk, we'll explore how http4k extends HTTP's capabilities through WebSocket and Server-Sent Events support and how these protocols can be modelled as simple functions, making them as testable as plain HTTP endpoints. We'll then show how these streaming capabilities open up new possibilities for server-side rendering, bringing us full circle from the days of JSP to modern reactive interfaces - all while keeping the complexity on the server where it belongs.
Join us to discover how http4k's streaming capabilities can enhance your web applications, enabling everything from chat applications to live dashboards and reactive server-rendered interfaces.
Test-Driven Microservices with http4k
Abstract:
With the rise of Microservice architectures and demands of Continuous Delivery, the need for systems to be well tested before they hit production has never been higher. In order to support this, it is crucial that the libraries and architectures we choose actively treat testing as a first class citizen.
This talk is a whirlwind mix of Kotlin live-coding and theory that covers the various types of testing that teams should be doing, and how the http4k ecosystem has been built from the ground up to make both developing and testing your apps a breeze. We will be coding parts of a simple application in a Test-Driven way and exploring more advanced subjects such as Approval, Contract and Chaos Testing.
Takeaways:
Attendees will gain insights into several techniques of effective Microservice testing that are relevant regardless of your choice of technology, and gain specific knowledge about the capabilities provided by the http4k community.
Level:
Intermediate, but theory sections will be suitable for all audience levels.
Kotlin's Elegant Deceptions: Simple APIs, Unusual Tactics
What untapped potential lies within Kotlin for creating APIs that are not just functional, but artfully elegant? Dive into the exploration of Kotlin's innovative methods, beyond conventional usage. Discover the language's blend of elegance and advanced features can enrich and elevate your approach to API development, moving beyond the ordinary towards the extraordinary.
In this talk, we're going to dive into how you can use Kotlin's thoughtful language features to build APIs that are not just good, but great. We'll cover the theory behind each technique and showcase it's use by diving behind the scenes in some established open source projects.
Attendees will gain practical techniques from this session, ready to be applied in their Kotlin projects for immediate impact. The insights into little-known features for API design will empower them to enhance their development work, fostering elegance and efficiency in their APIs from the outset.
Get ready to challenge your usual way of doing things and unlock some seriously innovative programming tricks!
It works on my machine! Boost productivity with Shift-Left engineering.
Developer feedback cycles are too long. Increasing numbers of services, system complexity, cloud-only based integrations and poor local testability - these all contribute to longer lead times. Techniques like build-caching, monorepos and pipeline optimisation can help, but fundamentally we still know too little, too late.
It doesn't have to be this way - it's entirely possible to reduce effective cycle times to a couple of minutes. But when it comes to it, your choice of technologies and testing strategies may well be holding you back.
Join us as we show the tools and techniques we used to take an engineering team to the next level, improving from 150 to 9000 deployments a month with a 10 minute Change Lead Time. Learn how we applied extreme Shift-Left engineering principles to generate and test everything locally - from pipelines to K8S manifests to monitoring to security, as well as rethinking test suites to E2E test dozens of services locally, and visually documenting behaviour and to show us not just if systems work, but how they work.
Make productivity engineering not just for developers but anyone working with your systems.
Exploring the Testing Hyperpyramid with Kotlin and http4k
We all know that testing is an important factor in software development.
But.
What if your tests could also work for you in dimensions that you didn’t even know existed? What if they could give you superpowers? Superpowers like easily running an entire bank on a single developer workstation, generating visual documentation of all the interactions across your fleet of microservices with a simple test plugin, or building reusable infrastructure which allow you to test your entire codebase at the unit, integration or end-to-end level.
In this talk, you'll learn about why your design and technology choices matter for testing and some Kotlin and http4k techniques that allow you to do much more by actually writing less test code.
Server as a Function in Kotlin
The birth of http4k: What started as a rewrite of a major scientific publisher's website evolved into the world's most testable web framework, now boasting millions of downloads monthly across its 180-module ecosystem. Learn how we built an entire HTTP toolkit from the ground up using pure functions and zero magic to deliver unprecedented testability.
http4k's unique design choices - born from real-world, high-scale demands - make it possible to test every aspect of your system with remarkable ease. By combining functional programming principles with a ruthless focus on testability, we've created a framework that makes building and testing web applications dramatically simpler than traditional approaches.
Throughout this talk, we'll demonstrate how http4k grew from a single project's needs into a comprehensive HTTP ecosystem, powering everything from high-performance APIs to complex web applications. You'll see firsthand how its pure-functional approach and extensive module system let you build exactly what you need, while keeping your applications remarkably simple to test and maintain.
Key focus areas:
- How a single project spawned the world's most testable web framework
- The evolution into a 180-module HTTP ecosystem
- How http4k also reimagines monolithic API client design
- A zero-magic approach to pure functional web development
- Practical demonstration of http4k's super- efficient design
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top