Lone Star Software Symposium: Austin
November 5 - 7, 2021
With the new release cadence, programmers can enjoy new features at a much faster rate. Java has been evolving rapidly, but in a responsible manner. While some of the new recent features in Java have been around in other languages for a while there are some coolness for them being introduced in Java. First, programmers who are maintaining large legacy systems can make use of these exciting features, right there in Java as they move forward to adopting newer versions. Second, Java brings its own twist and innovation to how these features are used in the language. Learning these is not only an exciting journey but can also make us more productive when writing Java code.
In this presentation we will take a live coding, example driven approach to look at a few features that have been added to Java in the most recent releases of the language.
Asynchronous programming is gaining popularity due to the recent architectural changes and influences. Java's CompletableFuture is a different programming model than what we're used to. How do stages work and how can we leverage the APIs to implement non-blocking calls.
This presentation will walk you through the fundamentals of CompletableFuture and how to make use of it.
Multithreading has been in Java from day one. The multithreading API has gone through significant changes over the years. And yet, we have something major that's threading again. What's the reason for yet another implementation, yet another change? How is that different from what we already have. When will we use the new model and when will we stick to the existing APIs.
Too many questions but we will not take them all in parallel. Instead we will give the questions serious thoughts and get a deeper understanding of the purpose of Project Loom, what problems it solves, and how and when we can benefit from it.
Apache Kafka is the core of an amazing ecosystem of tools and frameworks that enable us to get more value from our data. Let's take a journey through this wonderful world and see what we can learn.
In this session, we'll have a gentle introduction to Apache Kafka, and then a survey of some of the more popular components in the Kafka ecosystem. We will be looking at the Kafka Producer and Consumer libraries, Kafka Connect, Kafka Streams, the Confluent Schema Registry, and ksqlDB. You will leave loaded with ideas of ways to put Kafka to use in your organization, and a list of resources to help you on your journey.
Some say that data is the new oil, and like oil, data needs to be collected, refined, and distributed to gain value from it. For years we've collected data into tankers called databases, and when we had enough, we shipped batches of it to be refined by some process. Then when that was done, we'd make it available to end-users. However, unlike oil, data tends to lose its value the longer we wait to use it. (Data is the new milk?)
So, what if we could hook up a pipeline* to the source of the oil, er… data, and transform it in near real time, on its way to the end-users? That's precisely what we can do with Apache Kafka and Kafka Streams. In this session, we’ll see how we can use Kafka Streams to enrich, aggregate, summarize, and otherwise transform our data while it is flowing through our systems.
- These pipelines are completely harmless to the environment.
The Spring Framework transformed enterprise Java development nearly two decades ago, making it easier to achieve common things such as transactions, security, loose-coupling, and much more Over the years, Spring has continued to rise to every challenge Java developers face, most recently addressing subjects such as reactive programming, cloud computing, and container deployment in Kubernetes. Meanwhile, Spring Boot makes easy work of Spring by employing (among other things) auto-configuration, runtime insight and management, and a practical convention for specifying application properties.
The releases of Spring Framework 6 and Spring Boot 3 bring exciting and useful new capabilities. With features like native compilation, improved observability and tracing, support for HTTP problem details, and declarative HTTP clients, as well as baselining on Java 17 and Jakarta EE 9, Spring is ready for a new generation of application development.
In this workshop, you'll start with a very simple Spring Boot application and learn to grow it into a fully functional application including a web front-end and data persistence. And you'll get hands-on experience with some of the most exciting new features in Spring 6 and Spring Boot 3.
Workshop Requirements
You'll need…
- Java (17 or higher)
- An IDE of your choosing (I'll be using either Spring Tools or IntelliJ, but VSCode or even NetBeans will be fine if you prefer)
- A web browser (who doesn't have one of those?)
- Docker Desktop (https://www.docker.com/products/docker-desktop/)
The Spring Framework transformed enterprise Java development nearly two decades ago, making it easier to achieve common things such as transactions, security, loose-coupling, and much more Over the years, Spring has continued to rise to every challenge Java developers face, most recently addressing subjects such as reactive programming, cloud computing, and container deployment in Kubernetes. Meanwhile, Spring Boot makes easy work of Spring by employing (among other things) auto-configuration, runtime insight and management, and a practical convention for specifying application properties.
The releases of Spring Framework 6 and Spring Boot 3 bring exciting and useful new capabilities. With features like native compilation, improved observability and tracing, support for HTTP problem details, and declarative HTTP clients, as well as baselining on Java 17 and Jakarta EE 9, Spring is ready for a new generation of application development.
In this workshop, you'll start with a very simple Spring Boot application and learn to grow it into a fully functional application including a web front-end and data persistence. And you'll get hands-on experience with some of the most exciting new features in Spring 6 and Spring Boot 3.
Workshop Requirements
You'll need…
- Java (17 or higher)
- An IDE of your choosing (I'll be using either Spring Tools or IntelliJ, but VSCode or even NetBeans will be fine if you prefer)
- A web browser (who doesn't have one of those?)
- Docker Desktop (https://www.docker.com/products/docker-desktop/)
Although Java originally promised write once, run anywhere, it failed to fully deliver on that promise. As developers, we can develop, test, and build our applications into WAR or executable JAR files and then toss them over the wall to a Java application server and Java runtime that we have no control over, giving us zero confidence that the application will behave the same as when we tested it.
Containers fulfill the write-once, run anywhere promise that Java wasn't able to, by packaging the runtime and even the operating system along with our application, giving greater control and confidence that the application will function the same anywhere it is run. Additionally, containers afford several other benefits, including easy scaling, efficiency in terms of resource utilization, and security by isolating containers from their host system and from other containers.
While deploying Spring applications in containers has always been possible, Spring Boot makes it easier to containerize our applications and run them in container architectures such as Kubernetes. Spring Boot's support for containerization includes two options: Creating containers based on buildpacks or using layers as a means of modularizing and reducing the size of our application deployments. Moreover, new components in the Spring ecosystem can make your Spring applications Kubernetes-savvy so that they can take advantage of what a containerized architecture has to offer.
In this example-driven session, we're going to look at how to create and deploy Spring applications as container images and deploy them into a Kubernetes cluster. Along the way, we'll also get to know a few of the most useful tools that a Spring developer can employ in their development workflow when building containerized Spring applications. We'll also see how to apply patterns of Spring Cloud–such as configuration, service discovery, and gateways–using native Kubernetes facilities instead of Spring Cloud components. And we'll look at how components of the Spring ecosystem can work with your Spring applications to enable them to thrive in a Kubernetes cluster.
Workshop Requirements
- Java (17 or higher)
- An IDE of your choosing (I'll be using either Spring Tools or IntelliJ, but VSCode or even NetBeans will be fine if you prefer)
- Docker Desktop (https://www.docker.com/products/docker-desktop/)
- Kind (https://kind.sigs.k8s.io/)
- Kubectl (https://kubernetes.io/docs/reference/kubectl/)
- Skaffold (https://skaffold.dev/)
Test your setup: Make sure that the Docker Desktop is running and then type “kind create cluster”. It should take a minute or so, but then you should be able to type “kubectl config current-context” and see “kind-kind” listed.
In this session, we'll look at various ways that the latest features of Spring and Spring Boot can help with testing the tough-to-test portions of an application.
TBD
In this session, you'll see how to take Spring Data's automatic repository generation to a whole new level. We'll look at ways to model data and manipulate Spring Data to produce repositories and APIs that are more than just CRUD layers on top of a database.
TBD
I like to call Reactive Programming as Functional Programming++. There is so much similarity between FP and Rx and yet there are some significant differences. In this hands on workshop we will dive into what Reactive Programming is, learn about the APIs and capabilities, using RxJava as a vehicle.
While the examples will use RxJava, the concepts are general enough that you can readily benefit from the content, like backpressure and error handling, even if you are using other reactive libraries.
I like to call Reactive Programming as Functional Programming++. There is so much similarity between FP and Rx and yet there are some significant differences. In this hands on workshop we will dive into what Reactive Programming is, learn about the APIs and capabilities, using RxJava as a vehicle.
While the examples will use RxJava, the concepts are general enough that you can readily benefit from the content, like backpressure and error handling, even if you are using other reactive libraries.
Functional and reactive programming is gaining popularity and use. One hurdle developers face using these approaches is in exception handling. Dealing with exceptions in these styles is confusing in the beginning and is often messy and error prone. In this presentation we will step back and take a closer look at exception handling, about the functional and reactive programming and discuss the dos and don'ts for exception handling. We will learn using concrete examples and live coding to illustrate the problem and the possible solutions.
We will explore options available in different languages and libraries and learn from them
Event-driven architectures look great on paper (or a whiteboard), but it's easy to run into snags when trying to implement them. In this talk, we'll see how tools from the Apache Kafka ecosystem can make this task easier and a lot more fun!
In this session, with Apache Kafka as the backbone, we'll use Micronaut to implement an event-driven architecture that is loosely coupled and easily extensible. Then we'll extend it with a Kafka Streams application without affecting any of the existing applications.
We live in a world of microservices. Yet, what is a microservice? What defines the boundaries of a microservice? How do we define the relationships between microservices? Thankfully domain-driven design gives us the concepts and practices to better design and decompose our services.
In this session we will consider many of the concepts of DDD — How bounded contexts use Ubiquitous language to model the domain, how context maps can be used to establish the interconnections between services as well aggregates and domains events, all of which will service us well as we go about creating our microservices.
We will also discuss the “tactical” patterns of DDD — We will see how we can “embed” the ubiquitous language in code, and the architectural influences of DDD.
This workshop will have you thinking about how to think in DDD using DDD concepts and ideas. Using polls, and mini-exercises we attempt to better cement the ideas of DDD so we can start applying them at work.
We live in a world of microservices. Yet, what is a microservice? What defines the boundaries of a microservice? How do we define the relationships between microservices? Thankfully domain-driven design gives us the concepts and practices to better design and decompose our services.
In this session we will consider many of the concepts of DDD — How bounded contexts use Ubiquitous language to model the domain, how context maps can be used to establish the interconnections between services as well aggregates and domains events, all of which will service us well as we go about creating our microservices.
We will also discuss the “tactical” patterns of DDD — We will see how we can “embed” the ubiquitous language in code, and the architectural influences of DDD.
This workshop will have you thinking about how to think in DDD using DDD concepts and ideas. Using polls, and mini-exercises we attempt to better cement the ideas of DDD so we can start applying them at work.
Docker compose has been a part of the docker ecosystem since the beginning. It allows us to “stitch” together our services so that we can deploy all our services and related infrastructure using the “one” button. Furthermore, we can now use docker-compose to target Kubernetes, exemplifying the role that docker compose has to play in our day to day interaction with Docker.
If you are new to docker-compose then this is the session for you. Lets take a look at the capabilities of docker-compose, see what it takes to use it for local development and testing, and finally see how we can target Kubernetes so we can mimic our production deployment on our laptops.
You have been using Git for a while. You know how to stage and commit your work, create and delete branches and collaborate with your team members using remotes. But Git often leaves your confused — ever committed to your work to the wrong branch? Even worse, ever accidentally delete a branch that you needed to keep around? And what is God's good name is “Detached HEAD state”? Why tag commits, when we have branches? Is there a better work-flow than just using merges? What's the difference between a merge and a rebase?
The answer to all of these questions, and more, lies in the constitution of a commit, and the directed acyclic graph (DAG) that Git uses to manage your history. This, right here, is the key to understanding everything in Git.
In this hands-on workshop, we will level up your Git skills. We will foray into the underbelly of Git, and reveal the mystery behind the arcane interface that is the Git CLI.
By the end of this workshop, you will have a keen understanding on how best to use Git, as well as know how to dig yourself any prickly situation you might find yourself in. You will become your team's hero(ine). Most importantly, you will walk away with a keen appreciation of how beautiful and elegant Git really is.
You have been using Git for a while. You know how to stage and commit your work, create and delete branches and collaborate with your team members using remotes. But Git often leaves your confused — ever committed to your work to the wrong branch? Even worse, ever accidentally delete a branch that you needed to keep around? And what is God's good name is “Detached HEAD state”? Why tag commits, when we have branches? Is there a better work-flow than just using merges? What's the difference between a merge and a rebase?
The answer to all of these questions, and more, lies in the constitution of a commit, and the directed acyclic graph (DAG) that Git uses to manage your history. This, right here, is the key to understanding everything in Git.
In this hands-on workshop, we will level up your Git skills. We will foray into the underbelly of Git, and reveal the mystery behind the arcane interface that is the Git CLI.
By the end of this workshop, you will have a keen understanding on how best to use Git, as well as know how to dig yourself any prickly situation you might find yourself in. You will become your team's hero(ine). Most importantly, you will walk away with a keen appreciation of how beautiful and elegant Git really is.
Continuous refactoring is critical to succeeding in projects and is an important part of sustainable agile development.
In this workshop, we will start by discussing how to approach refactoring, the essential steps we need to take, and look into how to incrementally improve the internal design of code to make it extensible, maintainable, and cost-effective to change. In addition to discussing the concepts, we will take several code examples from real projects, discuss the code smells and explore the refactoring techniques. Along the way, we will also dive into refactoring short code samples and measure the quality of code before and after refactoring.
Workshop Requirements
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
Continuous refactoring is critical to succeeding in projects and is an important part of sustainable agile development.
In this workshop, we will start by discussing how to approach refactoring, the essential steps we need to take, and look into how to incrementally improve the internal design of code to make it extensible, maintainable, and cost-effective to change. In addition to discussing the concepts, we will take several code examples from real projects, discuss the code smells and explore the refactoring techniques. Along the way, we will also dive into refactoring short code samples and measure the quality of code before and after refactoring.
Workshop Requirements
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
Your team has embarked or about to embark on a journey to create Microservices. Journeys are exciting, often adventurous, but much more rewarding if we start with enough knowledge of both the route and the destination. That is true especially for the journey of creating Microservices.
In this presentation, we will focus on the reasons to create microservices, the benefits of creating them, the dos and dont's, and the set of practices that can help us succeed in reaching the destination.
Java 8 has been around for a few years and by now we all have immersed into the Streams API and the lambda expressions. But, what does it mean to program in functional style? How can we leverage the functional APIs to solve problems. How do we think in functional style when we have so much experience with imperative style. And flat…what and do they really mean we should honor immutability?
This presentation will answer those questions using practical examples so you can leverage the power of functional Java in your own applications.
We all have seen our share of bad code and some really good code as well. What are some of the common anti patterns that seem to be recurring over and over in code that sucks? By learning about these code smells and avoiding them, we can greatly help make our code better.
Come to this talk to learn about some common code smell and to share your experiences as well.
Don't fear entropy, embrace it.
When you move toward distributed computing the likelihood of failure proportionally increases. It's not your fault, it's simply physics. Once you start spreading your data and applications across more devices, then access to resources such as CPU, memory, and I/O have a higher rate of failure.
Embrace entropy with chaos experiments and increase your cloud native capability model. We’ll investigate some of the leading chaos frameworks for Kubernetes and dive into hands-on experiments targeted within blast radiuses.
Java developers and specifically Spring enthusiasts, fear not, Spring-based containers on Kubernetes continue to improve!
Write once, run anywhere, the promise of the JVM (WORA). Package once, run anywhere, the promise of containers (PORA). Given these two postulates, isn't WORA and PORA the same goal with different technologies? Yes, it’s completely redundant, and wasteful on expensive cloud servers. GraalVM has given us a way to reduce this waste with significant CPU and memory advantages. This solution has arrived with Spring Native.
We’ll walk through a hands-on session to see how much Spring Native can save you.
Over the last decade, DevOps has emerged as an influential business philosophy and practice, helping businesses drive high quality software to market faster. DevOps focuses on the elimination of bottlenecks that occur when development and operational resources are too divorced from one another. But what about friction in the development and test process? What about the delayed feedback cycles that come from slow builds and test flakiness? How can we reduce friction in areas that are outside of the focus of DevOps? Raju Gandhi, Developer Advocate at Gradle Enterprise, will talk about how the emerging practice of DPE addresses these questions. The presentation will include examples of DPE practices in action from Java projects using the Maven or Gradle build tool.
Attendees will walk away from this presentation with a better understanding of:
- Acceleration technologies for speeding up feedback cycles
- How to use data analytics to quickly determine the root cause of problems and prevent problems from happening in the first place
- The costs of a low productivity environment with wasted time waiting for builds, tests, and CI/CD pipelines
- The importance catching errors earlier, including incorrect signals like flaky tests
- How to make the practice of developer productivity engineering a respected discipline
Kubernetes has become the de-facto orchestrator for containers and now is the best way to start engaging with portable distributed computing. This workshop is for software application developers who want to understand what Kubernetes is all about and how it works. It can be a seemingly complex ecosystem full of terms, architectures, and misinformation. We will break it down so you have a solid understanding of how it works so you can start writing applications that run on this distributed platform.
We will cover many topics such as:
- Rise of Kubernetes and containers
- Terms and architecture
- What does it give me?
- App Patterns on Kubernetes
- Building, deploying, serving, and observing apps on Kubernetes.
- Hands on labs
Kubernetes has become the de-facto orchestrator for containers and now is the best way to start engaging with portable distributed computing. This workshop is for software application developers who want to understand what Kubernetes is all about and how it works. It can be a seemingly complex ecosystem full of terms, architectures, and misinformation. We will break it down so you have a solid understanding of how it works so you can start writing applications that run on this distributed platform.
We will cover many topics such as:
- Rise of Kubernetes and containers
- Terms and architecture
- What does it give me?
- App Patterns on Kubernetes
- Building, deploying, serving, and observing apps on Kubernetes.
- Hands on labs
Secure, Efficient, Resilient, High-performing, Sustainable, and Cost-effective
Are your applications well-architected? This talk will explore the best practices for operational excellence, Security, Reliability, Performance Efficiency, and cost optimization. Think of systems and services which provide business values. Do you know if all of these services are well-architected? You will learn how to create mechanisms, a repeatable process that allows you to improve over time. We will explore the best practices using real-world examples to make them more concrete and actionable.
Well-Architected helps cloud architects build secure, high-performing, resilient, and efficient infrastructure for various applications and workloads. They are built around six pillars—operational excellence, security, reliability, performance efficiency, cost optimization, and sustainability.
Join expert Rohit Bhardwaj to gain the knowledge and skills you need to solve current cloud implementation problems.
What you'll learn — and how you can apply it
By the end of this live, hands-on, online course, you'll understand the following:
– How to create responsive, maintainable, extensible architecture
– How to manage identities for people and machines and understand the significance of role-based, service-based, and attribute-based access
– How to design network topology and protect your network resources
– How to design interactions in a distributed system to prevent failures and improve performance and resiliency
– How to select the best-performing architecture and choose performant storage and databases
– How to manage demand and supply resources
– How to take advantage of user behavior patterns to support your sustainability goals
Topics covered:
Design Principles
– Scaling patterns
– Architecture Design Principles
– Capacity calculations
– Impact of data on design decisions
– Shared Responsibility Model
Reliability
– Resilient Architecture principles
– Herds of complex real-time distributed systems
– Hands-on Exercises / Case Studies
– Blast radius- fault isolation to protect your workload
– Availability patterns
– Recovery Point Objective and Recovery Time Objectives
– Data backup data patterns
– Routing Strategies
– Service quotas and constraints
– Design your workload service architecture
– Failure management in a distributed system
– Monitoring workload resources
– Calculating the response times
– Fallacies of Distributed Systems
– Testing reliability
– Cost Optimization
– Design cost-optimized storage
– Cost-optimized compute
– Data transfer costs
– Manage demand and supply resources
– Hands-on Exercises / Case Studies
Sustainability
– User behavior patterns
– Data access and usage patterns
– Development and deployment processes
– Hands-on Exercises / Case Studies
Performance Efficiency
– Select the best-performing architecture
– Choosing performant storage and databases?
– No-SQL for performance
– Caching strategies
– DOS attacks
– Tradeoffs to improve performance
– Evolving your workload
– Handle skewed data
– CDN networks like Cloudfront to solve the caching requirements for static and Dynamic
contents
– Monitor and set alarms for performance and network issues
– Hands-on Exercises / Case Studies
Operational Excellence
– Principles for Perform Operation Infrastructure as code
– Annotate Documentation - PlayBooks - Part of code
– Create Runbooks - Server down
– Capture failures and analyze them using Events and Real-Time Actions
– KPIs for cloud dashboard
– Incidence response - Root Cause Analysis
– Hands-on Exercises / Case Studies
Security, Privacy, and Compliance
– Manage identities for people and machines
– Identify Access Management
Role-Based, Service-Based, and Attribute-Based Access
– Securely operate your workload.
– Detect and investigate security events
– Web Application Firewall
– Virtual Private Cloud - design network topology
– Protecting your network resources
– Bastion Hosts
– Data classification
– Protecting data in Transit
– Protecting data at Rest
Hands-on Exercises / Case Studies
Secure, Efficient, Resilient, High-performing, Sustainable, and Cost-effective
Are your applications well-architected? This talk will explore the best practices for operational excellence, Security, Reliability, Performance Efficiency, and cost optimization. Think of systems and services which provide business values. Do you know if all of these services are well-architected? You will learn how to create mechanisms, a repeatable process that allows you to improve over time. We will explore the best practices using real-world examples to make them more concrete and actionable.
Well-Architected helps cloud architects build secure, high-performing, resilient, and efficient infrastructure for various applications and workloads. They are built around six pillars—operational excellence, security, reliability, performance efficiency, cost optimization, and sustainability.
Join expert Rohit Bhardwaj to gain the knowledge and skills you need to solve current cloud implementation problems.
What you'll learn — and how you can apply it
By the end of this live, hands-on, online course, you'll understand the following:
– How to create responsive, maintainable, extensible architecture
– How to manage identities for people and machines and understand the significance of role-based, service-based, and attribute-based access
– How to design network topology and protect your network resources
– How to design interactions in a distributed system to prevent failures and improve performance and resiliency
– How to select the best-performing architecture and choose performant storage and databases
– How to manage demand and supply resources
– How to take advantage of user behavior patterns to support your sustainability goals
Topics covered:
Design Principles
– Scaling patterns
– Architecture Design Principles
– Capacity calculations
– Impact of data on design decisions
– Shared Responsibility Model
Reliability
– Resilient Architecture principles
– Herds of complex real-time distributed systems
– Hands-on Exercises / Case Studies
– Blast radius- fault isolation to protect your workload
– Availability patterns
– Recovery Point Objective and Recovery Time Objectives
– Data backup data patterns
– Routing Strategies
– Service quotas and constraints
– Design your workload service architecture
– Failure management in a distributed system
– Monitoring workload resources
– Calculating the response times
– Fallacies of Distributed Systems
– Testing reliability
– Cost Optimization
– Design cost-optimized storage
– Cost-optimized compute
– Data transfer costs
– Manage demand and supply resources
– Hands-on Exercises / Case Studies
Sustainability
– User behavior patterns
– Data access and usage patterns
– Development and deployment processes
– Hands-on Exercises / Case Studies
Performance Efficiency
– Select the best-performing architecture
– Choosing performant storage and databases?
– No-SQL for performance
– Caching strategies
– DOS attacks
– Tradeoffs to improve performance
– Evolving your workload
– Handle skewed data
– CDN networks like Cloudfront to solve the caching requirements for static and Dynamic
contents
– Monitor and set alarms for performance and network issues
– Hands-on Exercises / Case Studies
Operational Excellence
– Principles for Perform Operation Infrastructure as code
– Annotate Documentation - PlayBooks - Part of code
– Create Runbooks - Server down
– Capture failures and analyze them using Events and Real-Time Actions
– KPIs for cloud dashboard
– Incidence response - Root Cause Analysis
– Hands-on Exercises / Case Studies
Security, Privacy, and Compliance
– Manage identities for people and machines
– Identify Access Management
Role-Based, Service-Based, and Attribute-Based Access
– Securely operate your workload.
– Detect and investigate security events
– Web Application Firewall
– Virtual Private Cloud - design network topology
– Protecting your network resources
– Bastion Hosts
– Data classification
– Protecting data in Transit
– Protecting data at Rest
Hands-on Exercises / Case Studies
We face problems big and small as part of our job. Problems are stepping stones for success. The question is, how efficiently and creatively are we solving a problem? How accurate is the solution? Can we apply creativity in solving problems? Without critical thinking, we can not solve the problem well.
In this session, we will explore step-by-step approaches to solve a problem.
How to reduce the ambiguity?
How to identify future issues?
How to pick the best solution?
How to identify the root cause?
What tools can we use to solve problems?
What skills do we need to develop?
Explore case studies
Jamie Zawinski once said “Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.“. Many consider regular expressions to be indecipherable, but the truth is that every programmer should consider regular expressions an integral part of their toolkit. From the command line to your favorite text editor, from parsing user input to scraping HTML pages once you know regular expressions you will find a use for them in almost every programming context.
In this highly interactive workshop we will decipher the cryptic construct that is a Regular Expression. Starting with the basics, we will work our way towards advanced usage, including anchors, modifiers, groups, and look arounds.
This is a HIGHLY interactive workshop — Not only will we have a lot of exercises, we will use a playground that will allow us to experiment to our heart's content! Feel free to come in with issues you may have seen at work!
Agenda:
The basics and how to read regular expressions
Character Classes
Negation
Ranges
Shortcuts
Alternations
Repetitions
Word Boundaries
Capture Groups
Anchors
Modifiers
Let's once and for all make sense of this powerful tool.
I hope to see you all there.
Jamie Zawinski once said “Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.“. Many consider regular expressions to be indecipherable, but the truth is that every programmer should consider regular expressions an integral part of their toolkit. From the command line to your favorite text editor, from parsing user input to scraping HTML pages once you know regular expressions you will find a use for them in almost every programming context.
In this highly interactive workshop we will decipher the cryptic construct that is a Regular Expression. Starting with the basics, we will work our way towards advanced usage, including anchors, modifiers, groups, and look arounds.
This is a HIGHLY interactive workshop — Not only will we have a lot of exercises, we will use a playground that will allow us to experiment to our heart's content! Feel free to come in with issues you may have seen at work!
Agenda:
The basics and how to read regular expressions
Character Classes
Negation
Ranges
Shortcuts
Alternations
Repetitions
Word Boundaries
Capture Groups
Anchors
Modifiers
Let's once and for all make sense of this powerful tool.
I hope to see you all there.
At its core, Spring is built on a dependency injection framework that enables (among other things) loose coupling of application components. But dependency injection is not the only way to achieve loose-coupling. Event-driven design, as its name implies, enables components to react to events, not knowing where they came from, process those events, and then publish new events not knowing who (if anybody) will be handling those events.
In this session, you'll learn how to apply events in Spring applications to achieve looser coupling of components. We’ll start by looking at some fundamental abilities that the core framework offers for handling events. Then we'll quickly move into a higher-level form of event-driven architecture where events aren’t just handled within a single deployment, but span across multiple microservices by employing Spring Cloud Stream and Spring Cloud DataFlow. And then we’ll see how, when paired with serverless functions based on Spring Cloud Function, we can achieve not only loose-coupling of microservices, but also an efficient yet scalable use of resources in our event-driven architecture.
At its core, Spring is built on a dependency injection framework that enables (among other things) loose coupling of application components. But dependency injection is not the only way to achieve loose-coupling. Event-driven design, as its name implies, enables components to react to events, not knowing where they came from, process those events, and then publish new events not knowing who (if anybody) will be handling those events.
In this session, you'll learn how to apply events in Spring applications to achieve looser coupling of components. We’ll start by looking at some fundamental abilities that the core framework offers for handling events. Then we'll quickly move into a higher-level form of event-driven architecture where events aren’t just handled within a single deployment, but span across multiple microservices by employing Spring Cloud Stream and Spring Cloud DataFlow. And then we’ll see how, when paired with serverless functions based on Spring Cloud Function, we can achieve not only loose-coupling of microservices, but also an efficient yet scalable use of resources in our event-driven architecture.
As developers we not only operate in different contexts, but also often have these different contexts interplay as part of our work.
Each of the tools that we use — version control systems like Git (along with collaborative tools like Github/Gitlab), IDE's like Eclipse/IntelliJ, build systems like Gradle, Ci/Cd tooling like Jenkins, IaaC tools like Ansible, the command line — all introduce context.
To be effective developers we need to know when to operate in a certain context, combine or tease apart how these contexts interplay.
Can you improve your release announcements if format your commit messages consistently? You bet!
How should your build tool interact with your version control system?
What does naming your files have to do with how you use your IDE?
This session will take a look at several of these contexts — it will attempt to discern between them, explore when you should separate them and when you attempt to bring them together.
With lots of examples, and lots of quizzes this session will definitely leave you thinking about a few things.
Vue.js, the new kid on the JavaScript framework block is taking the world by storm. Vue has bypassed React in their count of Github stars, alluding to how popular this framework is starting to become. Vue attempts to provide just enough support with libraries like Vuex and the Vue Router, and tooling like the Vue CLI to get developers productive, without aiming to be too opinionated, and too flexible.
If you are curious about Vue, this workshop is for you.
In this workshop we will build a full application using Vue.js. We will start by discussing how you can start working with Vue, all the way to seeing what it takes to build an app with Vue, including communicating with the backend, and routing. List of topics include:
- Creating Vue.js components
- Creating component hierarchies
propsand custom events- Smart vs. Dumb components
- Ajax using
axios - Routes, routing, and the router-view
- Forms using Vue.js
- Using the best practices for naming and project layout
- Understanding the role of the Vue CLI, and development tools like the Vue Developer Tools for Chrome
If time permits, we will also look into:
- Unit/integration/e2e testing
- The Composition API introduced in Vue 3
Instructions
Please visit https://github.com/looselytyped/web-apps-with-vue for detailed installation instructions
Workshop Requirements
Please visit https://github.com/looselytyped/web-apps-with-vue for detailed installation instructions
Vue.js, the new kid on the JavaScript framework block is taking the world by storm. Vue has bypassed React in their count of Github stars, alluding to how popular this framework is starting to become. Vue attempts to provide just enough support with libraries like Vuex and the Vue Router, and tooling like the Vue CLI to get developers productive, without aiming to be too opinionated, and too flexible.
If you are curious about Vue, this workshop is for you.
In this workshop we will build a full application using Vue.js. We will start by discussing how you can start working with Vue, all the way to seeing what it takes to build an app with Vue, including communicating with the backend, and routing. List of topics include:
- Creating Vue.js components
- Creating component hierarchies
propsand custom events- Smart vs. Dumb components
- Ajax using
axios - Routes, routing, and the router-view
- Forms using Vue.js
- Using the best practices for naming and project layout
- Understanding the role of the Vue CLI, and development tools like the Vue Developer Tools for Chrome
If time permits, we will also look into:
- Unit/integration/e2e testing
- The Composition API introduced in Vue 3
Instructions
Please visit https://github.com/looselytyped/web-apps-with-vue for detailed installation instructions
Workshop Requirements
Please visit https://github.com/looselytyped/web-apps-with-vue for detailed installation instructions
Real-world applications nowadays are designed using both art and science. What is the process of coming up with a solution which works, scales, and is resilient?
What is it challenging to design a system for disruptive technologies?
System design is unstructured, and there are many ways to solve problems.
Gaining experience in new applications and technologies
Best practices change with time. The best way ten years ago can quickly become an anti-pattern.
In this talk, we will explore step by step guide to approach System design using real-world applications.
Come prepared to design a system for following applications interactively.
We will gain more knowledge with collective experience and best practices.
UBER System Design
NETFLIX System Design
INSTAGRAM System Design
YELP System Design
TWITTER System Design
Search Engines
Auto Suggestions / Recommendations System Design
Fraud Detection System Design
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Real-world applications nowadays are designed using both art and science. What is the process of coming up with a solution which works, scales, and is resilient?
What is it challenging to design a system for disruptive technologies?
System design is unstructured, and there are many ways to solve problems.
Gaining experience in new applications and technologies
Best practices change with time. The best way ten years ago can quickly become an anti-pattern.
In this talk, we will explore step by step guide to approach System design using real-world applications.
Come prepared to design a system for following applications interactively.
We will gain more knowledge with collective experience and best practices.
UBER System Design
NETFLIX System Design
INSTAGRAM System Design
YELP System Design
TWITTER System Design
Search Engines
Auto Suggestions / Recommendations System Design
Fraud Detection System Design
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
As a software architect, you're at the forefront of building scalable, secure, and resilient systems that drive innovation while safeguarding critical digital assets. This workshop is designed to equip you with actionable strategies, cutting-edge tools, and deep technical insights into embedding security into every phase of the software development lifecycle.
In this immersive, hands-on session, we will explore how to elevate your DevSecOps practices to meet the challenges of today’s evolving threat landscape while ensuring productivity and operational excellence.
What You'll Learn:
- Integrating Security into CI/CD Pipelines: Discover how to build efficient, secure workflows that empower teams to deliver faster without compromising security. Learn to implement security gates and automate vulnerability detection with tools like SAST, DAST, and dependency scanning.
- Tracking Metrics for Success: Understand key DevSecOps metrics such as lead time, deployment frequency, mean-time-to-recover (MTTR), and change fail rate. Learn how observability tools provide actionable insights to optimize performance and reliability.
- Proactive Security with Ethical Hacking: Dive into penetration testing and simulate real-world attacks to uncover vulnerabilities in your systems before attackers do. Get hands-on with industry-standard tools such as OWASP ZAP.
- OWASP Top 10 for Applications, APIs, LLMs, and Mobile:
- Applications: Learn to identify and mitigate risks such as injection flaws, broken authentication, and misconfigurations.
- APIs: Secure APIs with best practices for authorization, schema validation, and rate limiting to combat vulnerabilities like excessive data exposure.
- LLMs: Explore unique challenges in securing Large Language Models (AI-driven applications), including prompt injection and data leakage.
- Mobile: Address mobile app vulnerabilities such as insecure storage and transport layer protection, ensuring your applications are robust across platforms.
- Aligning Security with Business Outcomes: Bridge the gap between technical practices and business goals by aligning DevSecOps with operational KPIs. Demonstrate how secure development drives measurable business value, customer satisfaction, and operational excellence.
Why You Should Attend:
- Hands-On Experience: Participate in live demonstrations of vulnerabilities, attacks, and their mitigation across applications, APIs, LLMs, and mobile systems.
- Cutting-Edge Tools and Techniques: Gain exposure to the latest tools and practices in CI/CD, ethical hacking, and observability.
- Business-Driven Approach: Learn how to connect DevSecOps efforts to organizational success, making security an enabler of productivity.
- Collaborate with Experts: Engage with peers and experts to discuss real-world challenges and share actionable solutions.
Who Should Attend:
This workshop is ideal for:
- Software Architects seeking to embed security into every layer of system design.
- Senior Developers striving to deliver secure, high-performing applications.
- Technical Leads responsible for ensuring compliance and operational excellence in development pipelines.
Join us for this transformative session to gain the skills and knowledge necessary to design secure, scalable, and resilient systems that protect your organization and enable innovation.
Salient Points Architects Will Learn in This Talk
- Shift-Left Security: Embed security early in the CI/CD process to catch and resolve vulnerabilities proactively.
- Key DevSecOps Metrics: Track and optimize lead time, deployment frequency, MTTR, and change fail rate for operational excellence.
- Ethical Hacking: Learn how to simulate real-world attacks to identify and fix vulnerabilities before they become threats.
- OWASP Top 10 Insights: Gain actionable strategies to mitigate risks across applications, APIs, LLMs, and mobile platforms.
- API Security Best Practices: Implement schema validation, token-based authentication, and rate limiting to safeguard APIs.
- AI Security for LLMs: Address unique vulnerabilities in Large Language Models, including prompt injection and data leakage.
- Mobile App Security: Protect mobile systems from insecure data storage and transport vulnerabilities using OWASP Mobile Top 10.
- Business Alignment: Connect DevSecOps practices to measurable business KPIs, demonstrating security’s value in driving success.
This session is a must-attend for architects aiming to design secure, scalable systems while staying ahead in the rapidly evolving security landscape.
Serverless is the promise of short bursts of functions all provided by some magical cloud platform. As a developer, you write the function and automagically something else ensures your code is served and evented. It’s sorcery based on your sourcery. But how can this work on Kubernetes? Serverless is ideal for Kubernetes!
We’ll pick apart a few Kubernetes-based serverless frameworks and dive into Knative which promises a standard framework for your potions.
Embraced containers yet? If so, that only presents the beginning of the journey. Designing your images to be lean, and your containers configurable requires us to leverage Dockerfiles to their maximum potential. At scale, everything matters—build times, testing, multi-stage builds, conventions around tagging and logging. There is a whole ecosystem of tools around how we can best build our images and containers.
In this session we will learn many a trick on how we can leverage Docker's own tooling as well as third-party tools to ensure that our first steps in the container world are the right ones.
Multithreading has been in Java from day one but there is no such similar concept in the JavaScript world. Programmers using JavaScript have predominantly used asynchronous programming, callback, promises, and async-await. May be not too surprising, however, both the .NET platform/C# and the JVM/Java introduced asynchronous programming much later in their evolution. On the JVM we now have three options, multithreading APIs, CompletableFuture, and, soon to be released Virtual Threads (as part of Project Loom). In this keynote we will discuss the APIs of the present and the future.
We will then dive into the nature of the problems and the approaches to solutions where one particular API may be better suited than the other. We will tease apart the details of these APIs to improve clarity of what they provide and when and where we should use one over the other.
Kubernetes out of the box is a strong platform for running and coordinating large collections of services, containers, and applications. As is, Kubernetes is powerful for many solutions.
Remember Underdog? He was a mild-mannered dog, but when stress and conflict were introduced to the plot he took a magic pill, he became a superhero. Istio is a superhero for Kubernetes.
Istio is an open, platform-independent service mesh that manages communications between services in a transparent way. With a distributed architecture many things can fail, slow down and become less secure. Istio provides solutions to those stresses in our plot toward this architecture style:
• Traffic management
• Observability
• Policy enforcement
• Service identity and security
We will explore these benefits with Istio through some working examples on Kubernetes. The key point is this meshing solution allows your Java code to be less coupled to the inherent weaknesses of a distributed platform.