How Local Development Tooling Helps with Cloud-Native Sustainability

Cloud-native environments provide key advantages for production workloads, including scalability, reliability, and cost efficiency. However, the rapid rise of cloud resources to build cloud-first applications and enhance the developer experience introduces challenges related to sustainability, potentially compromising energy and developer efficiency. Local-first cloud-native tools can address these challenges by prioritizing performance and sustainability, enabling users to assess and integrate sustainable practices throughout the software development life cycle (SDLC). In this panel, Nancy will be joined by Sunyanan, Oleg, and Harsh to explore strategies and workflows that developers can implement to minimize the ecological impact of cloud-first development. This high-level discussion will empower you to make conscious decisions when creating developer environments, and reducing carbon footprints while maximizing the benefits of the cloud-native ecosystem.

Improving Developer productivity with API-first tooling

Even AI is good enough to generate YAML now. However, to secure your job, you will need tools that use more complex general-purpose programming languages.
Jokes aside, we’ll look at a fleet of tools you can use for common configuration and environment setup tasks without touching any Yaml. From creating complex CI pipelines to setting up a local development environment to managing your cloud infrastructure and deployments, lots of essential parts of the cloud-native project setup can all be done in your favorite programming languages. You'll learn how open-source tools abstract container configuration and management (Testcontainers), build tool actions (Dagger), and cloud infrastructure setup (Pulumi).

This session will teach you how to use these tools and give you enough time to start building customized experiences for your application development teams.

Non-deterministic? No problem! You can test it!

Testing is hard, which is why developers tend to avoid it. Testing non-deterministic things is even harder, which is unfortunate, since we're all writing AI-infused applications, and AI models are notoriously non-deterministic. What happens when the applications start using advanced features, such as RAG, tools, and agents? How do you test these applications? There must be some tools, technologies, and practices out there that can help, while not costing your organization lots of money!

Join Java Champions Oleg & Eric in this session as they explore some of these tools & technologies, such as Testcontainers, LangChain4j, Quarkus, and Ollama. They’ll bring together Oleg’s Testcontainers knowledge and Eric’s testing obsessions, getting hands-on and show how you can incorporate these tools and technologies into your inner and outer loop processes.

You’ll see how effortlessly Quarkus integrates with Testcontainers, and how Testcontainers can be used in conjunction with popular LLMs when writing tests. You’ll also learn about how to use containers to extend your testing into your CI environments, so you can always be sure that if your tests are green you’re good to go!

NoYAML: The Brighter Future Bruno Borges Dreams Of

In the world of software development, YAML has long been a go-to solution for configuration management. But as projects grow, YAML configurations can become unwieldy, leading to frustration, decreased productivity, and significant risk with configuration changes.

This session challenges the status quo by exploring alternative tools and approaches that allow developers to accomplish common tasks without touching YAML. We'll cover a range of scenarios, including:
* Setting up local development environments
* Configuring Spring applications with the type-safe Pkl language
* Writing maintainable CI pipelines
* Configuring cloud resources

After this session you’ll have enough inspiration to change your ways of configuring systems, and enough courage to throw away your yaml-ruler.

"Just rub some AI on it" Adding AI: From development to testing to production

In the era of AI commoditization, developers will inevitably face requests to incorporate AI into existing applications.

We'll explore a pragmatic approach to AI integration, utilizing technologies such as SpringAI, Ollama for local development, and AWS Bedrock for deployment, with Testcontainers ensuring robust testing.

You'll learn the core AI concepts you'll need to know as an app developer and how to work with various tools to be productive in development and ready for production. We will cover the techniques for contextualizing and limiting interactions and using structured inputs and outputs.
On the production side you'll learn the fundamental aspects to Machine Learning Operations and how these relate to DevOps.

Smooth Sailing in the Cloud-Native Storm: Tools for better confidence in microservices development

Starting with cloud-native app may represent a steep learning curve! It’s not only a matter of architecture or technology but also a paradigm shift on developer experience and workflow. Even before writing code, configuring your entire test environment might be intimidating! And after that you still have to figure out how to validate your microservices with great confidence to release them independently!

In this session, we’ll present tools to ease your life when setting up your development environment and testing with databases, middlewares, cloud services and your regular business services and API! Considering the diversity of styles and protocols - REST, gRPC, GraphQL, Async - and cloud-native stacks - this latter is not an easy task.

This session provides hands-on experience on: how to equip your team with a consistent and polyglot approach. And how to let them develop locally, but providing confidence with a unified policy between the inner and the outer loops.

Developer productivity for apps with AI

The AI landscape has grown a ton in the last year with many technologies and approaches that application developers must master to include AI in their end-user and enterprise apps. However, more focus must be put into enabling standard software development workflows: testing, ensuring RAG correctness and efficiency, local development environment and CI setups, and security of AI artifacts, monitoring of the quality and so on.

In this session, we look at how application developers can integration test their GenAI apps with local models, augmented with RAG both locally and in CI. You'll learn how the setups for GenAI apps in the inner development loop can be programmatically managed and how these new tools can get into typical software development workflows without impairing developer productivity.

Whether you're an enthusiast yourself, or your boss tells you to "add AI" to the software you're working on, this session will give you understanding of the scale of the problem of building with AI and suggestions how to do so without going crazy.

Simplified Inner and Outer cloud native developer loops

Despite the quality of modern cloud-native tools, the user experience for inner and outer developer loops are still radically different, which introduces friction and hampers developer productivity.

Development setups are app-centric, while production environments deal with deployments and tools required for operations teams to keep applications running. This session explores tools to simplify both side and improve developer productivity through a platform engineering and polyglot approach using a toolchain that:
Gives developers a standard set of app-level APIs to solve common distributed app challenges, using Dapr.
Equips developers and product teams with consistent, polyglot feature flags through OpenFeature.
Facilitates easy local development, outside of a Kubernetes cluster, with Testcontainers.

Attendees will walk away with a working demo showcasing a straightforward, lightweight and effective inner and outer dev loop, ensuring the seamless promotion of apps from dev to prod.

Velocity and happiness via tests

Flow state, cognitive load, and speed of feedback loops are three core dimensions of developer experience. Taken together, they encapsulate almost all friction encountered in the development process.

However, these can be hard to measure and sometimes straightforward to improve.

In this session, we show how tests, the test suites' quality, and running test experience cover all three core dimensions and enable high-performing teams.

We look at anti-patterns for tests and how they drastically increase the cognitive load required even for the most straightforward changes and slow down feedback loops.
Then we show how modern high-quality test setups ensure developer productivity and happiness and drive team velocity up and to the right.

Below is the small print and not part of the abstract:

Some useful materials:
* https://www.infoq.com/presentations/thoughtworks-high-performance-teams/
* https://martinfowler.com/articles/developer-effectiveness.html
* https://queue.acm.org/detail.cfm?id=3595878

We'll show testcontainers based setups for test -- ensuring environment parity, ease of running individual tests, flexibility of configuration, debuggability of the tests; talk about performance improvements to test suites, how higher level integration tests aren't too tied to implementation details allowing easier changes, and how they give a lot of confidence without requiring too much maintenance.

Libraries that make tests bring joy!

Tests are essential to developer productivity, but without proper care, they quickly stop being a fun way to know if the code is working and become a chore!

The best way to avoid this pitiful situation is to use libraries that simplify everyday tasks making working with tests a joy!

In this session, we'll look at a collection of libraries making tests enjoyable. Libraries that take care of the chores from environment setup, to generating test data, to working with asynchronous events without the silliness of timeouts, to fluently working with network queries, to mocking whole services like a pro!

Join us for a quick and fun overview of what libraries you should add to your projects and how they all combine to make tests bring joy!

JUnit 5 advanced features, awaitility, restassured, testcontainers
Working with data: instancio, synthesized tdk, wisser/jailer
Pi-test for mutation tests

Making your own Testcontainers module for fun and profit!

Testcontainers libraries are a de-facto standard for integration testing in the Java community. One of the reasons for its popularity is the ecosystem of the modules -- pre-defined abstractions for creating containerized services for your tests in a single line of code.

Testcontainers modules help to integrate with new technologies, hide setup complexity behind a neat abstraction, or use in-house Docker images without using lower-level API all the time.

In this lab, we'll go over the architecture of a module, see how one can implement it, and make a small but helpful module ourselves.

Whether you're working on a database technology, want to implement chaos engineering practices, or improve your team's productivity, creating a Testcontainers module is an excellent way to abstract away some of the complexity of your integration tests and contribute to the Java ecosystem.

Making a Testcontainers module can be a great exercise -- either adding a more complex topology (adding a chaos engineering proxy and hiding it behind an abstraction, supporting your in-house docker images, or a new technology -- all these are great use cases and you can contribute to the Java ecosystem in a nice standalone way (without taking on yourself a ton of responsibility for maintaining the project forever).

Testing cloud-native applications with ease!

Many applications rely on cloud solutions like AWS, Azure, and GCP. Testing such applications could be a nightmare of spare cloud accounts or never-ending environment setups.

Thanks to Testcontainers, we can run all the necessary services locally and even more programmatically control their configuration and lifecycle! It means you can improve your development feedback loop locally and test your cloud-native applications without spending a penny.

In this demo-heavy session, we’ll go over typical use cases cloud-native app developers struggle to test effectively, and look at how Testcontainers features enable working with S3, DynamoDB, Lambdas, Google Spanner, and others. Testing your cloud-native applications with Localstack and GCloud modules has never been this easy and reliable.

Quarkus & Testcontainers: Perfect Synergy for Cloud-Native Development!

Applications today don't exist in a vacuum. They typically communicate with other services, such as databases, message brokers, cache servers, and more. These interconnectivity requirements make it hard to do local/inner-loop development and testing efficiently, often forcing developers to write lots of code and configuration that never gets to production.

What if there was a better way? What if you didn’t need to write any extra code or configuration and things just worked out of the box, making your life simpler and easier?

This session will introduce Testcontainers and explore the synergy between Testcontainers and Quarkus, showcasing all the integration that has been done for you, the developer, so that you don’t need to worry about anything!

We did this session with Eric Deansdrea (Red Hat), and it turned out pretty well: https://www.youtube.com/watch?v=x44dL5jzaG4

Learning GenAI/LLM programming with langchain4j and Testcontainers

GenAI and LLMs are currently a big hype topic within the IT industry and beyond. And while we should always be critical about “The next big thing” style hype waves, we also need to stay curious and make up our own mind. And how to better understand a technology as a developer, than by using it in practice?

In this talk, we want to look at how to use langchain4j, the Open-Source Java variant of the popular LLM framework langchain, together with Ollama as a local LLM model runtime, to create a local development experience for building GenAI applications. And to top things off, we will utilize Testcontainers’ infrastructure-as-code capabilities to set up this LLM development environment on demand and without requiring manual fiddling around.

Adding GenAI to modern application development

Whether you're a big believer or skeptical of them, GenAI technologies can offer massive help to your end-users, so as an application developer, you need to know how to navigate the AI landscape and properly develop GenAI apps.
The latter is often an afterthought since new approaches don't focus on basic software development cycle needs, such as testing, security, and local development environment setup.
In this session, we look at the modern application development process and how to add GenAI to your regular application stack.
You'll learn how Langchain projects work with different LLMs, how to enrich your app with RAG patterns without sacrificing developer experience, how to test the LLM-based setups locally and in CI, and how to preserve your productivity in the inner loop development despite adding GenAI.

Practical developer guide to the building apps with AI

You’re happily working on your project, surfing through tasks, and delivering value when your boss tells you to add AI to the code. Welcome to the future!

Now you quickly need to catch up with the latest developments in the world of AI which develops at unprecedented speed (even by JavaScript standards). What are the AI components that you can build into your apps? What problems is it good at right now? What systems do you need to architect if you want to bring your own data into the mix?
Do you need to start doing MLOps in addition to DevOps practices?

This session offers a practical take and an opinionated set of tools and practices for working with applications that include AI components. We’ll look at Google’s technical garden: Gemini and Gemma models, AlloyDB AI vector store for your RAG applications, and the Vertex AI platform.
You’ll learn how to work with the open source models locally, what tasks do they excel at right now, how to organize your tests for non-deterministic AI setups, and what to monitor in production to prevent your AI from getting dumber.

All in all you’ll get a quick-paced overview of how to get started and a fully functional sample project which you can use as a starting point for your exploration of building with AI.