Architecture is not a static representation of a system. There are several complexities and risks involved in creating them. One way to mitigate the risk is to evolve the architecture. But, there are risks of evolving as much as there are the risks of not evolving. In this interactive workshop we will explore a set of practices that we can use to mitigate the risks. Then we will dive into discussing some common and popular architectural patterns.
Finally, we will take some example applications and discuss how to evolve architecture to meet the needs of those applications.
Computer with git client installed to access the version control system which will have lab related material.
Application Programmer Interfaces (APIs) by definition are directed at software developers. They should, therefore, strive to be useful and easy to use for developers. However, when engaging design elements from the Web, they can be useful in much larger ways than simply serializing states in JSON.
There is no right or perfect API design. There are, however, elements and choices that induce certain properties. This workshop will walk you through various approaches to help you find the developer experience and long-term strategies that work for you, your customers and your organization.
We will cover:
The Web Architecture as the basis of our APIs
The REST Architectural Style and its motivations
The Richardson Maturity Model as a way of discussing design choices and induced properties
The implications of contentnegotiation and representation choices such as JSON or JSONLD
The emergence of metadata approaches to describing and using APIs such as OpenAPI and HydraCG
Security considerations
Client technologies
API Management approaches
Our software engineering teams are facing new challenges every day that come with the rapidly changing industry and recent events.
People don't seem to be motivated by the same things that they previously found compelling. Organizations are giving up glamorous office spaces and pivoting to remote teams. These changes require us to quickly pivot as leaders to learn new skills, frameworks, and techniques to continue supporting our teams while maintaining our own sanity.
In this workshop, you will learn and practice key skills to help your team propel through today's modern challenges and setbacks. The topics will be relevant to all Software Engineering leaders who wish to find ways to motivate and inspire their teams - regardless of their organization's existing circumstances.
Specific topics will include:
Activities will require a handout - please download (and print if preferred) the course handout located in the Slides folder.
There is pain inherent in development - monoliths, confusing deployment processes, conflict between dev/ops/security/business… IT is complicated, and hard to do well, and the pace of change expected by customers makes it all even MORE difficult.
It can also be massively overwhelming to try to fix any of these pain points. A plan can help, but…how do you go about making that plan, and how do you share the plan with other people in a way that's easy to understand?
Join Josh and Laine as they talk about how to create a version of this map for your organization - by focusing on what you want to accomplish and the pain points in the way. You'll leave with a version of the problems in the way of accomplishing CD at your organization, along with some “huh, this isn't as overwhelming as it seemed before!”
This workshop will include a lot of discussion and interaction, and probably some feels!
This workshop builds an entire event driven data pipeline with Machine Learning and Kafka. From Kafka where we use producers or Kafka Connect to generate information, we then will Kafka Streams to apply a machine learning model to make business decisions.
This intensive lab will start by integrating sources into our backplane, then train our models, and operationalize our model using Kafka Streams. We will then create result topics when we can read in as a report and display visualizations of our data. The result will also be scalable and fault tolerant.
*Github Account
Over the past few years, the basic idioms and recommended programming styles for Java development have changed. Functional features are now favored, using streams, lambda expressions, and method references. The new sixmonth release schedule provides the language with new features, like modules and local variable type inference, much more frequently. Even the new license changes in the language seem to complicate installation, usage, and especially deployment.
The purpose of this training course is to help you adapt to the new ways of coding in Java. The latest functional approaches are included, including using parallel streams for concurrency, and when to expect them to be useful. All the new significant features added to the language will be reviewed and evaluated, with the goal understanding what problems they were designed to handle and when they can be used effectively in your code.
The workshop will use Java 21. You can get that from any major vendor, including Oracle. If you don't have a preferred vendor, then https://adoptium.net/ offers pre-built OpenJDK binaries for free.
We'll use IntelliJ IDEA for coding, but nothing in the materials requires any particular IDE. Only the Community edition is necessary, though the instructor will be using the Ultimate edition.
We will also use Gradle as our build tool, but most of the major IDEs can create Gradle-based Java projects without additional installs. You are welcome to use Maven if you prefer, but the instructor may not be able to help if you run into issues.
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.
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.
The fundamental testing libraries in Java have undergone complete redesigns in the past few years. JUnit 5 redesigns the most well-known tool in all of testing. The most popular mocking library, Mockito, has also been rebuilt. This workshop will introduce the new features, help you use them as intended, and discuss experimental ideas still in the pipeline.
JUnit has been remarkably stable over the years and is one of the most widely adopted frameworks in the Java world. The latest version, JUnit 5, takes JUnit to the next level. Full of new features like conditional test execution, parametric testing, labeling and filtering tests, and more, it brings all the modern thinking on testing into the JUnit world. It also takes advantage of the functional features added to Java since version 8 to create a powerful, new library for testing your code. With the release of Mockito 3, the mocking library now requires functional features from Java 8 and takes advantage of them in interesting ways. This workshop helps you work with both libraries.
The fundamental testing libraries in Java have undergone complete redesigns in the past few years. JUnit 5 redesigns the most well-known tool in all of testing. The most popular mocking library, Mockito, has also been rebuilt. This workshop will introduce the new features, help you use them as intended, and discuss experimental ideas still in the pipeline.
JUnit has been remarkably stable over the years and is one of the most widely adopted frameworks in the Java world. The latest version, JUnit 5, takes JUnit to the next level. Full of new features like conditional test execution, parametric testing, labeling and filtering tests, and more, it brings all the modern thinking on testing into the JUnit world. It also takes advantage of the functional features added to Java since version 8 to create a powerful, new library for testing your code. With the release of Mockito 3, the mocking library now requires functional features from Java 8 and takes advantage of them in interesting ways. This workshop helps you work with both libraries.
Learn the basic syntax and semantics for the Kotlin programming language. Kotlin is an alternative JVM language that provides null safety, static typing, and powerful IDE support. This workshop will give you the chance to code in Kotlin, highlighting its similarities and differences from Java, how to use functional programming skills, work with collections, access restful web services, and more.
This workshop will examine features of Kotlin at a greater depth than most tutorials. Coroutines – the most popular feature of the language – will also be covered, as well as higher order functions, reduction operations like reduce and fold, and lambdas with receivers. Those topics progress toward building DSLs and builders in Kotlin. Terms like “apply”, “let”, “use”, “also”, and “with” will be covered along with their typical use cases.
Details of the type system, including the Any, Unit, and Nothing classes, will be included. Examples will be provided on how to define extension functions, infix operators, and inlining functions for efficiency.
Learn the basic syntax and semantics for the Kotlin programming language. Kotlin is an alternative JVM language that provides null safety, static typing, and powerful IDE support. This workshop will give you the chance to code in Kotlin, highlighting its similarities and differences from Java, how to use functional programming skills, work with collections, access restful web services, and more.
This workshop will examine features of Kotlin at a greater depth than most tutorials. Coroutines – the most popular feature of the language – will also be covered, as well as higher order functions, reduction operations like reduce and fold, and lambdas with receivers. Those topics progress toward building DSLs and builders in Kotlin. Terms like “apply”, “let”, “use”, “also”, and “with” will be covered along with their typical use cases.
Details of the type system, including the Any, Unit, and Nothing classes, will be included. Examples will be provided on how to define extension functions, infix operators, and inlining functions for efficiency.
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.
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.
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.
A Docker image is the artifact of the container world. Leaner images allow easier for quicker build times, less resource management (disk pressure and network usage), fewer attack vectors, and better performance when pulling or pushing images for storage or upon deployment. Lean images also produce smaller containers, which in turn require fewer resources at runtime, allowing for higher server density. Multistage Dockerfiles can help reduce the complexity of CI/CD pipelines by reducing the number of moving parts in building, testing, and producing a production-grade image. The key to building leaner (smaller) images, with little build-time overhead is to understand how Docker uses the Union File System (UFS), how Docker builds (and when it busts) the cache, and how to use the Dockerfile specification to it's fullest potential.
In this exercises driven, hands-on workshop, we will dive deep, peeking under the hood to get a glimpse of the Union File System, and then proceed to look at the effects of many of the important Dockerfile instructions. We will see how best to use them, and highlight any caveats that we should be aware of.
By the end of this class you will have gained a keen understanding of how best to write your Dockerfiles, and effectively build and design lean images, and containers.
A Docker image is the artifact of the container world. Leaner images allow easier for quicker build times, less resource management (disk pressure and network usage), fewer attack vectors, and better performance when pulling or pushing images for storage or upon deployment. Lean images also produce smaller containers, which in turn require fewer resources at runtime, allowing for higher server density. Multistage Dockerfiles can help reduce the complexity of CI/CD pipelines by reducing the number of moving parts in building, testing, and producing a production-grade image. The key to building leaner (smaller) images, with little build-time overhead is to understand how Docker uses the Union File System (UFS), how Docker builds (and when it busts) the cache, and how to use the Dockerfile specification to it's fullest potential.
In this exercises driven, hands-on workshop, we will dive deep, peeking under the hood to get a glimpse of the Union File System, and then proceed to look at the effects of many of the important Dockerfile instructions. We will see how best to use them, and highlight any caveats that we should be aware of.
By the end of this class you will have gained a keen understanding of how best to write your Dockerfiles, and effectively build and design lean images, and containers.
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.
Java is now on a six-month release schedule, with new features being added all the time. This talk summarizes the features that have been added to Java, including collection factory methods, private methods in interfaces, records, the enhanced switch statement, and more. The goal is to show not only what has been added, but why and where to use them.
Additional topics will include Local Variable Type Inference, the new HTTP client, the pattern matching, and text blocks. This talk will be updated throughout the year as more features are added to new releases.
JavaScript now has a yearly release cycle. Every release introduces new features that aim to make us (JavaScript developers) more productive, while making our code succinct, expressive, and (potentially) bug-free.
By the end of this workshop you will be intimately familiar with the newer set of JavaScript features, and ready to dive into your next JavaScript project with confidence.
This workshop allows you to explore many of the new features that we use on a daily basis, including
let and constMap / Set data-structuresclass syntax as well as static/private members and methodsThis workshop uses tests to verify and validate all of your changes, so you can be confident in your changes as you go about refactoring your code to use modern JavaScript language features.
Each section of the workshop builds on the previous one, allowing you to continuously refactor code and get tons of practice.
If you want to be fully caught up with all of the changes that have landed in JavaScript between 2015 and 2021, this is the workshop you want to attend!
Please follow the instructions in the README.md file of https://github.com/looselytyped/refactoring-to-modern-javascript
NOTE — If you get an error be sure that your Node version is up-to-date. Older versions of Node did not support ES modules natively, and you might run into issues.
If you cannot upgrade Node, consider using a tool like https://github.com/nvm-sh/nvm/blob/master/README.md (Mac/Linux) or https://github.com/coreybutler/nvm-windows (Windows) so you can run multiple version of Node simultaneously.
JavaScript now has a yearly release cycle. Every release introduces new features that aim to make us (JavaScript developers) more productive, while making our code succinct, expressive, and (potentially) bug-free.
By the end of this workshop you will be intimately familiar with the newer set of JavaScript features, and ready to dive into your next JavaScript project with confidence.
This workshop allows you to explore many of the new features that we use on a daily basis, including
let and constMap / Set data-structuresclass syntax as well as static/private members and methodsThis workshop uses tests to verify and validate all of your changes, so you can be confident in your changes as you go about refactoring your code to use modern JavaScript language features.
Each section of the workshop builds on the previous one, allowing you to continuously refactor code and get tons of practice.
If you want to be fully caught up with all of the changes that have landed in JavaScript between 2015 and 2021, this is the workshop you want to attend!
Please follow the instructions in the README.md file of https://github.com/looselytyped/refactoring-to-modern-javascript
NOTE — If you get an error be sure that your Node version is up-to-date. Older versions of Node did not support ES modules natively, and you might run into issues.
If you cannot upgrade Node, consider using a tool like https://github.com/nvm-sh/nvm/blob/master/README.md (Mac/Linux) or https://github.com/coreybutler/nvm-windows (Windows) so you can run multiple version of Node simultaneously.
The world around us exists as a collection of events - things that happen and data points that we take in and process and decide what to do about (or not do about), all the time, every day. So…why shouldn't the systems we interact with be structured in the same way?
In this hands-on workshop, Laine and Josh will explain event-driven architecture, and why it's different from traditional monolith and also microservice architecture. They'll explain the pros and cons, and go over some of the technology that's currently out there to implement systems in this more customer-centric way.
They'll also explain more in depth how the serverless model of implementing architecture is especially helpful for accomplishing the goal of event-driven architecture, and then lead you through a workshop that ties it all together using Knative on a Kubernetes cluster (OpenShift).
The world around us exists as a collection of events - things that happen and data points that we take in and process and decide what to do about (or not do about), all the time, every day. So…why shouldn't the systems we interact with be structured in the same way?
In this hands-on workshop, Laine and Josh will explain event-driven architecture, and why it's different from traditional monolith and also microservice architecture. They'll explain the pros and cons, and go over some of the technology that's currently out there to implement systems in this more customer-centric way.
They'll also explain more in depth how the serverless model of implementing architecture is especially helpful for accomplishing the goal of event-driven architecture, and then lead you through a workshop that ties it all together using Knative on a Kubernetes cluster (OpenShift).
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.
Most of us, including your humble speaker, have been very used to imperative style. We all have read about functional programming, seen examples, and have even written code using that style. Yet, the journey to writing functional style seems rather unnatural often times. When refactoring existing code, we may be tempted to transform the code to functional style, but how do we approach that.
In this presentation we will take six different problems, all with unit tests, and refactor the working code from imperative to functional style. Along the way we will discuss the thought process, the approaches, the APIs that will help with that transformation of code.
Many developers around the world have jumped on the Microservices bandwagon. Several organizations, in the past and also in the present, have built around monolithic and also service oriented architectures. What separate, however, Microservices from those efforts at large? How does a Microservices based architecture influence the design of the software applications, what are the key design principles we should keep in mind, and how to leverage design goals like reuse and extensibility?
In this presentation we will revisit the design goals we often focus on in software development and how those evolve in the context of Microservices.
Want to bring in [new cool thing X] or [necessary technology change Y] to your company, because you know there's a need for it? GOOD IDEA! Except…now what? If your company is more than about 3 people, how do you explain, enable, and encourage the adoption of this change, especially if it will require some work on everyone’s part?
In How to Technology Good, Josh and Laine will explain how bringing in technology is subject to one of the biggest problems in IT - how to scale it. They'll also talk about tips and tricks for how to be as successful as you can, and the main things to keep track of and watch out for. They'll go through each phase of bringing in new tech, all the way from how to pick your success criteria through what to think about when it comes to maintenance.
Serverless! Functions as a service! DIGITAL TRANSFORMATION!
…just kidding.
One of the ideas in IT that's been gathering buzz for a while is “serverless.” Or sometimes “functions as a service,” used interchangeably. And…okay, but what does that actually mean? And…how does it help what you're trying to accomplish in your organization?
In this talk, Josh and Laine talk about what serverless is, and what it isn't, along with why you should care and how it can help with actual “digital transformation.” They'll go over the benefits and drawbacks of this method of implementing applications and show a demo of how it works using Knative (https://knative.dev/) on a Kubernetes cluster.
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:
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:
The Java Platform has seen a tremendous amount of evolution and improvements over the past 5 years in many different areas including: language features in Java, Kotlin, and Scala, Functional Programming, dev environments, test workflows, Reactive, Stream processing, distributed data, containerization, Serverless, and AoT compilation.
This talk will give you a tour of the most important improvements, why they matter, and how to take advantage of them.
Over the past few years architectural patterns for distributed data have gained more importance and adoption. At the same time similar patterns have emerged for decentralized data. You will learn how CQRS and CRDTs are used in trusted and untrusted environments to overcome the challenges of eventual consistency, data privacy, and global scalability.
Through code examples you will learn how to use these patterns and will see how they are applied through higher-level abstractions like GraphQL, Cloudstate, and even Blockchain.
In Cloud Integrations and Data Architecture talk, we will examine secure, scalable integrations on Enterprise applications. Through various scenarios, we will explore designing and implementing intricate integration patterns on multiple platforms. We will review how to communicate the solution and design trade-offs to business and technical people.
We will explore the following topics:
– Design high-performing, secure, and reliable integrations with applications.
– Analyze existing as-is and future to-be integration models.
– Integration Architecture blueprint. Streaming patterns.
– MDM Tools (Master Data Management).
– Integration with cloud applications. Error handling.
– Effectively communicate architecture design to various stakeholders at many levels.
– Follow best Domain practices in integration.
– Data modeling/Database Design. Data Stewardship. Data Quality Skills (concerned with clean data). Data Governance. Large Data Volume Considerations. Data Migration best practices.
– Architect robust, scalable security mechanisms for interfaces.
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
In Cloud Integrations and Data Architecture talk, we will examine secure, scalable integrations on Enterprise applications. Through various scenarios, we will explore designing and implementing intricate integration patterns on multiple platforms. We will review how to communicate the solution and design trade-offs to business and technical people.
We will explore the following topics:
– Design high-performing, secure, and reliable integrations with applications.
– Analyze existing as-is and future to-be integration models.
– Integration Architecture blueprint. Streaming patterns.
– MDM Tools (Master Data Management).
– Integration with cloud applications. Error handling.
– Effectively communicate architecture design to various stakeholders at many levels.
– Follow best Domain practices in integration.
– Data modeling/Database Design. Data Stewardship. Data Quality Skills (concerned with clean data). Data Governance. Large Data Volume Considerations. Data Migration best practices.
– Architect robust, scalable security mechanisms for interfaces.
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
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
Modern applications are all built using Serverless Computing. Serverless is one of the top-paying cloud skills. In this talk, we will explore the AWS Serverless framework. Serverless architecture is a way to build and run applications and services without having to manage infrastructure.
You’ll learn Serverless Computing from beginning to end. We will take a deep dive into best practices, core features, and advanced features including step functions.
We will go over the following topics:
– AWS Lambda
– AWS API Gateway
– Amazon DynamoDB
– AWS Step Functions
– AWS SAM (Serverless Application Model)
– Serverless Framework design patterns
– AWS Continuous Integration Tools like Git, CodeCommit, CodeBuild, CodePipeline
Serverless Integrations Best Practices
Who will benefit from this course?
– Developers and Architects to discover AWS Serverless Lambda and the Serverless Architecture
– DevOps Professionals who want to understand CICD pipelines
– Developers or Architects who want to design serverless applications using the best practices in serverless computing
Prerequisites?
Have access to an AWS Account, some familiarity to AWS
JavaScript knowledge
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Modern applications are all built using Serverless Computing. Serverless is one of the top-paying cloud skills. In this talk, we will explore the AWS Serverless framework. Serverless architecture is a way to build and run applications and services without having to manage infrastructure.
You’ll learn Serverless Computing from beginning to end. We will take a deep dive into best practices, core features, and advanced features including step functions.
We will go over the following topics:
– AWS Lambda
– AWS API Gateway
– Amazon DynamoDB
– AWS Step Functions
– AWS SAM (Serverless Application Model)
– Serverless Framework design patterns
– AWS Continuous Integration Tools like Git, CodeCommit, CodeBuild, CodePipeline
Serverless Integrations Best Practices
Who will benefit from this course?
– Developers and Architects to discover AWS Serverless Lambda and the Serverless Architecture
– DevOps Professionals who want to understand CICD pipelines
– Developers or Architects who want to design serverless applications using the best practices in serverless computing
Prerequisites?
Have access to an AWS Account, some familiarity to AWS
JavaScript knowledge
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
AWS Certified Architect is one of the hottest and most valuable certifications in 2021. Amazon Web Services is one of the most popular cloud platforms around.
Abilities Validated by the Certification are:
– Effectively demonstrate knowledge of how to architect and deploy secure and robust applications on AWS technologies.
– Define a solution using architectural design principles based on customer requirements
– Provide implementation guidance based on best practices to the organization throughout the life cycle of the project
In this workshop, we will explore the following topics with hands-on labs:
– Design using compute, networking, storage, and database AWS services, EC2, S3 storage, RDS, DynamoDB
– AWS deployment and management services, Cloud Formation, Identity Access Management
– API Gateway, Route 53
– Serverless architecture, AWS Lambda, Step Functions
– Simple Notification Service (SNS), Simple Queue Service(SQS)
– AWS Cloud Watch, AWS CloudTrail
– Identify and define technical requirements for an AWS-based application
– Recommended best practices for building secure and reliable applications on the AWS platform
– Architectural principles of building on the AWS Cloud
– AWS global infrastructure
– Network technologies as they relate to AWS, Virtual Private Cloud
– Security features and tools that AWS provides and how they relate to traditional services
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Please get free tier AWS account from following link:
https://aws.amazon.com/
AWS Account with free tier
Windows, Mac or Linux PC/laptop
Contrary to popular belief, software engineering culture is not about the free food, open office spaces, and ping pong tables.
You can sense a great team culture when you observe it, and unfortunately you've probably experienced (or are currently experiencing) elements of a bad team culture. Not to worry - it's never too late to grab the reins and make small changes to steer your team in the right direction!
In this talk, Kate will highlight 8 tactical tips that attendees can implement on their teams immediately to help shape their team's culture!
Engineering Leaders across industries and timezones are struggling to retain technical talent even after offering the shiniest of benefits and perks. Why is that?
This one hour session will uncover key factors that lead to highly engaged teams followed by 5 common reasons Engineers choose to leave an organization and changes we can make to proactively avoid these departures.
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.
Our industry never stops changing, but sometimes those changes are trivia and fluffy. Sometimes they are fundamental and enduring. This series is going to highlight some of the most important trends happening in the hardware, software, data and architecture spaces.
Networking technologies may seem like done deals, but that could not be further from the truth. We will introduce you to some of the most important advances happening in the world of networking including current and upcoming changes to HTTP.
Modern software developers need to understand the benefits and impacts of modern networking.
We will cover:
Our industry never stops changing, but sometimes those changes are trivia and fluffy. Sometimes they are fundamental and enduring. This series is going to highlight some of the most important trends happening in the hardware, software, data and architecture spaces.
The Web has clearly been a success, but as it exists in its third decade, there are cracks and warning signs about, censorship, content stability and long-term access to. The Interplanetary File System (IPFS) is an umbrella project covering a cornucopia of extremely well designed layers that will prop up and extend the Web in many new directions. Come here about a future that looks a little bit like combining the Web with Git, Bittorrent, Self-certifying file systems, Distributed Hash Tables and more.
Now that we are on the verge of communicating with people on the Moon and Mars, the modern software developer needs a more resilient and expansive Web.
We will cover:
Our industry never stops changing, but sometimes those changes are trivial and fluffy. Sometimes they are fundamental and enduring. This series is going to highlight some of the most important trends happening in the hardware, software, data and architecture spaces.
Modern software development needs to facilitate faster time to market, easier data integration and unlock new features for our applications, services and architectures. Incumbent to this vision is the need for a serialization format that is less about developer simplicity and more about flexible, evolvable and powerful systems. JSON-LD represents a vision for unifying the worlds of data, APIs and modern software systems. Useful in its own right, it also serves as the basis for much of the work being done in the standards world to engender annotations, activity streams, verifiable claims and more.
The modern software developer needs modern data models.
JSON-LD was developed in response to pushback to earlier standard serialization formats such as RDF/XML. It strikes a balance between developer-friendliness and support for LinkedData models built on standards. We are seeing a growing adoption of it as a format to project data and business value across a wider set of use cases than traditional Web APIs.
In this talk we will discuss the various JSON-LD file formats, tools for producing and consuming it, how it connects to the vision of the Semantic Web, how it can add value to any organization that needs to integrate information across sources with minimal need for consensus and coordination as well as how it is being used in an increasing number of important scenarios across industries.
We will cover:
Our industry never stops changing, but sometimes those changes are trivia and fluffy. Sometimes they are fundamental and enduring. This series is going to highlight some of the most important trends happening in the hardware, software, data and architecture spaces.
Knowledge graphs are a rapidly emerging concept for machine processable models of complex and dynamic domains. Whether you are Google needing to shore up your understanding of what people search for or a typical organization needing to free data from its silos, you will want to pay attention to what is happening in this standards-driven space. If your organization wants to resolve its most pernicious data integration problems or facilitate machine learning initiatives, knowledge graphs are likely to be part of your future.
Modern software developers need modern ways of projecting what they know via standards in network-friendly ways.
There are many attempts to build data-driven learning and reasoning capabilities these days in the worlds of machine learning and AI. Deep learning systems have had remarkable results, but even its thought leaders and strongest advocates acknowledge the need for “common sense” in the learning process. That means different things to different people, but Knowledge Graphs represent one approach to capture what we know about a domain. They are increasingly being used to present domain views that grow over time and aren't domain-specific using network-friendly standards.
We will discuss the emergence of Knowledge Graphs as an emerging solution to a missing capability in most organization's IT strategies. We will discuss how some of the biggest organizations in the world are heading in this direction, it's impact on API design and more. We will focus on specific tools, platforms and standards that are making Knowledge Graphs a crucial part of your overall solutions.
Our industry never stops changing, but sometimes those changes are trivia and fluffy. Sometimes they are fundamental and enduring. This series is going to highlight some of the most important trends happening in the hardware, software, data and architecture spaces.
It is a common perspective that you do not need to know how a car works to drive it. For much of the recent history of our industry that has been true for the software we develop and the hardware that it runs on. For most people this has mean compiled software targeting a particular platform with a particular general purpose CPU reflecting a Von Neumann Architecture. As the worlds of Moore's Law and machine learning combine with explosive data growth and cloud, edge, mobile and Internet of Things (IoT) computing environments, hardware has never been more important to software developers to help them do what they need to do in the fastest, cheapest, low-power consumption and low-latency ways. We will discuss the myriad computational environments that are increasingly important to us and how to target them with our software artifacts.
To be a good Modern Software Developer, you are going to need to know more about hardware.
We will cover:
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.
You'll need…
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.
You'll need…
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.
Machine Learning is all the rage, but many developers have no idea what it is, what they can expect from it or how to start to get into this huge and rapidly-changing field. The ideas draw from the fields of Artificial Intelligence, Numerical Analysis, Statistics and more. These days, you'll generally have to be a CUDA-wielding Python developer to boot. This workshop will gently introduce you to the ideas and tools, show you several working examples and help you build a plan to for diving deeper into this exciting new field.
We will cover:
Please install Anaconda for Python 3 before the workshop if possible. https://www.anaconda.com/download
Machine Learning is all the rage, but many developers have no idea what it is, what they can expect from it or how to start to get into this huge and rapidly-changing field. The ideas draw from the fields of Artificial Intelligence, Numerical Analysis, Statistics and more. These days, you'll generally have to be a CUDA-wielding Python developer to boot. This workshop will gently introduce you to the ideas and tools, show you several working examples and help you build a plan to for diving deeper into this exciting new field.
We will cover:
Please install Anaconda for Python 3 before the workshop if possible. https://www.anaconda.com/download
The Hypertext Transfer Protocol (HTTP) has been in use for decades. Almost as soon as it was released initially, those surrounding its design began extending it to meet the needs of evolving interaction styles.
HTTP 1.1 was a huge leap forward, but there were still performance issues that were not resolved until HTTP/2.
Now, we are on the cusp of the biggest changes to date with the introduction of HTTP/3 and QUIC. Developers need to understand what is happening so they can build modern, high performance Web-based systems that benefit from the new capabilities.
You will learn about:
- How HTTP has evolved over time
- What the major innovations and limitations have been along the way
- How HTTP/2 changed Web application and API design
- How HTTP/3 and QUIC will change Web application and API design
- How the co-evolution of TLS 1.3 combines with HTTP/3 and QUIC to
modernize the secure Web
The Hypertext Transfer Protocol (HTTP) has been in use for decades. Almost as soon as it was released initially, those surrounding its design began extending it to meet the needs of evolving interaction styles.
HTTP 1.1 was a huge leap forward, but there were still performance issues that were not resolved until HTTP/2.
Now, we are on the cusp of the biggest changes to date with the introduction of HTTP/3 and QUIC. Developers need to understand what is happening so they can build modern, high performance Web-based systems that benefit from the new capabilities.
You will learn about:
- How HTTP has evolved over time
- What the major innovations and limitations have been along the way
- How HTTP/2 changed Web application and API design
- How HTTP/3 and QUIC will change Web application and API design
- How the co-evolution of TLS 1.3 combines with HTTP/3 and QUIC to
modernize the secure Web
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.
In this hands-on workshop you will learn how to take a Cloud Native Application from inception to production. Starting with a base sample application we will learn how to break the application into separate services that communicate via gRPC Kotlin. We will then learn how to containerize and deploy the application to Kubernetes. Along the way we will learn how to address some of the major challenges of deploying applications to Kubernetes, such as scaling and service discovery.
Some of the topics to be covered include:
Service communication using gRPC, a fast and efficient binary protocol
Creating Kubernetes Deployment Files
Deploying, Managing and Scaling services using Kubernetes
Using Kubernetes Service Discovery with gRPC
In this hands-on workshop you will learn how to take a Cloud Native Application from inception to production. Starting with a base sample application we will learn how to break the application into separate services that communicate via gRPC Kotlin. We will then learn how to containerize and deploy the application to Kubernetes. Along the way we will learn how to address some of the major challenges of deploying applications to Kubernetes, such as scaling and service discovery.
Some of the topics to be covered include:
Service communication using gRPC, a fast and efficient binary protocol
Creating Kubernetes Deployment Files
Deploying, Managing and Scaling services using Kubernetes
Using Kubernetes Service Discovery with gRPC
The interactions between Alexa and her human users are significantly more natural than typing, clicking, and swiping. But without significant effort, they still feel somewhat stilted compared to human-to-human communication.
However, by applying a little bit of AI, trained with some predefined example dialogs, conversations with Alexa can seem just like you're talking to a friend or family member.
In this session, we'll explore Alexa Conversations, a new technology for creating conversational dialogs that aren't stiff and scripted. We'll build a simple Alexa Conversations-enabled skill to get started and then explore a complete (and award-winning) Alexa skill that is built on Alexa Conversations.
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
There is a new way of Threading on it's way to Java, and that means it is time to prepare. Project Loom will be introducing Java Virtual Threads which are small Threads meant to perform quick operations with the need of procuring long-running OS threads which can prove to be expensive. In this class we will learn how to use these threads, what does it mean in relationship with the rest of the Java API, what does it mean for third party libraries.
There is a new way of Threading on it's way to Java, and that means it is time to prepare. Project Loom will be introducing Java Virtual Threads which are small Threads meant to perform quick operations with the need of procuring long-running OS threads which can prove to be expensive. In this class we will learn how to use these threads, what does it mean in relationship with the rest of the Java API, what does it mean for third party libraries.
For those still grappling with Generics. This will be an attempt to clear the air about generics. What are wildcards? What is extends? What is super? What is covariance? What is contravariance? What is invariance? What is erasure? Why and when do I need this?
Generics or parameterized type is one of the more pain items in any statically typed language on the JVM. This presentation is set to overcome some of these hurdles and understand some of these confusing terms. We will cover the following:
Graal is a VM and an awesome VM at that. Able to run a variety of languages and fast. The execution times can be impressive too. This VM can run anything, JavaScript, Python 3, Ruby, R, JVM-based languages like Java, Scala, Kotlin, and LLVM-based languages such as C and C++.
We are living in truly exciting times. So much interesting technology including the VM space. Graal is a virtual machine and shared memory system for multiple languages. GraalVM can either run standalone or embedded in OpenJDK or node.js. Graal can even embed inside databases such as MySQL or Oracle. In the presentation, we look at this exciting VM, how to start it, how to run polyglot applications, and how to integrate all within the same VM.
Resilient architecture is fundamental when working in distributed, cloud-based systems. Designing and architecting large-scale applications managing millions of requests brings unique challenges with availability, performance, and integration. You will need to make difficult choices and evaluate tradeoffs. Luckily, you can use different architecture patterns to make a distributed application more resilient. Based on evolutionary architecture, this approach enables you to create systems designed to evolve with the ever-changing software development ecosystem. Resilient architecture patterns will allow you to create systems that continue functioning even when components fail.
Join expert Rohit Bhardwaj to learn how to implement an evolutionary architecture approach and understand resilient architecture patterns. This training will explore architecture decisions you may need to make when evaluating your architecture to improve performance and resiliency. For example, you will no longer struggle to handle millions of requests per second or face issues when routing traffic.
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 from resilient, elastic design utilizing message-driven services
How to design cost-effective Recovery Point Objectives (RPOs) and Recovery Time Objectives (RTOs)
How to identify blocking issues with microservices in the cloud
How to evaluate caching strategies that can help lower costs and protect from DOS attacks
And you'll be able to:
Design high availability, high scalability, low latency, and resilient architectures.
Analyze and review implementations.
Identify key scalability challenges in your company.
Prevent cascading failures and preserve functionality.
This training is for you because…
You have an existing need to evaluate your current architecture.
You want to understand best practices.
You need to design new systems and want to evaluate which pattern to use.
Prerequisites
Basic knowledge of software architecture
Familiarity with design principles
Thinking application as stateless for all the API calls makes the system available most of the time and requires creating a cache for common distributed data. Next, we examine how to deal with cascading failures and timeout scenarios. As part of auto-healing, applications need to Detect, Prevent, Recover, Mitigate, and Complement so that the service is resilient.
The key takeaways for the audience are as follows:
*Resiliency is essential for any feature in the cloud.
*Understanding the value chain is critical to identifying failure points.
*Challenges come in determining if there is a failure and designing the system for auto-
healing
*The focus should be first to prevent a failure from occurring.
*Identifying critical challenges in your company and tools and techniques to auto-heal and provide a sustainable solution
Course Schedule
Evolutionary Architecture:
– Scaling to 100 million customers
– Understanding Requirements - Empathy Map
– Fail Points
– Defining KPIs
Resilient Patterns:
– BulkHead pattern
– Routing Strategies
– Design Issues with Microservices
– API Gateway Pattern
– Database per Service Pattern
– Database Sharding Patterns
– Fan out Pattern
– Publish-Subscribe Pattern
– Command Query Responsibility Segregation (CQRS)
– Message filter pattern
– Topic-queue-chaining Pattern
– Message Partitioning Patterns
– Priority Queue Pattern
Caching:
– Caching and Failure Injection
– Distributed system challenges
– Caching Patterns
– Order in Chaos
– Resilient Steps
– Resources
Hey! Hey! Hey!
The world around us exists as a collection of events - things that happen and data points that we take in and process and decide what to do about (or not do about), all the time, every day. So…why shouldn't the systems we interact with be structured in the same way?
In this session, Laine and Josh will explain event-driven architecture, and why it's different from traditional monolith and also microservice architecture. They'll explain the pros and cons, and go over some of the technology that's currently out there to implement systems in this more customer-centric way.
Enterprise applications are complex. A transaction starting in the browser will go through proxies, api gateways, security appliances, application performance monitoring tools, logs, microservices and more microservices. Historically there has been no standard way to get observability and traceability between all the enterprise components. Each product and framework has it's own proprietary way of identifying a transaction making it difficult if not impossible to stitch together a complete picture of a transaction. This is changing with the introduction of the W3C Trace Context standard and the open source initiative of OpenTelemetry.
In this session, you will learn how using Trace Context, OpenTelemetry and other open source and commercial products can improve your observability to help you better triage production issues, improve performance, be proactive and make your users happier.
It seems like everyday there is a new headline about a security breach in a major company’s web application. These breaches cause companies to lose their credibility and cost them large sums of money. Security is everybody’s job and requires us to be proactive.
This hands-on workshop is designed to teach you how to identify, exploit (legally) and fix vulnerabilities in modern Java web applications. Using an existing web application, you will learn ways to scan and test for common vulnerabilities using common penetration testing tools. You will learn about OWASP Top 10 vulnerabilities such as hijacking, injection, cross-site scripting, cross-site forgery and more. You will learn best practices around logging, error handling, intrusion detection, authentication and authorization. You will also learn how to improve security in your applications using existing libraries, frameworks and techniques to patch and prevent vulnerabilities making your software safer.
Everyone wants to be successful in life. Many have found the SMART (specific, measurable, achievable, relevant & time boxed) goal setting framework to be a powerful tool to help clarify and validate their goals. Unfortunately having well defined goals is not enough to obtain them. This is where WINS (write, incentivize, network & share) comes in.
In this session, you will learn how to become more successful by putting goals into action with SMART WINS.
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.
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.
Spring is still the leading open source framework in the Java world for building web apps and web services. This workshop will walk through creating both, with special emphasis on deployable restful web services. In addition to the basic code, the workshop will look at how Spring operates, including the proxy design pattern, interceptors, managing singletons, and more.
=== Spring MVC architecture
=== Spring Boot Features
=== Special bean types
=== Annotated controllers
=== Functional endpoints
Spring is still the leading open source framework in the Java world for building web apps and web services. This workshop will walk through creating both, with special emphasis on deployable restful web services. In addition to the basic code, the workshop will look at how Spring operates, including the proxy design pattern, interceptors, managing singletons, and more.
=== Spring MVC architecture
=== Spring Boot Features
=== Special bean types
=== Annotated controllers
=== Functional endpoints
Kotlin is a JVM-based language, and many of its features are borrowed from related languages like Groovy and Scala. It is designed to work well with Java and to be easy for existing Java developers to learn. Nevertheless, Kotlin contains several features and practices that surprise Java developers. This talk will review several of those features, and help existing Java developers understand them and use them productively.
Examples will include how to create static properties and methods without a static keyword, overriding properties as well as functions, defining objects rather than classes, the Unit and Nothing classes, why const is useful when you already haveval for final, and more.
See how features of functional programming are implemented in three different JVM-based languages. Examples include how lambda expressions, method references, and streams are handled differently, as well as higher-order functions, closure composition, trampolining, currying, tail recursion, and more.
Kotlin, Groovy, and Java are all object-oriented languages with functional features. It's interesting to see what capabilities they implemented in similar ways and which are unique to that language.
Probabilistic Data Structures are the big data, cloud era, and streaming solution to efficiently storing counts. Especially when you are paying somebody else for disk space! Let me introduce you to Redis Bloom, a Redis Module that natively implements the most useful PDS.
The RedisBloom module provides four data structures: a scalable Bloom filter, a cuckoo filter, a count-min sketch, and a top-k.
Probabilistic Data Structures are the big data, cloud era, and streaming solution to efficiently storing counts. Especially when you are paying somebody else for disk space! Let me introduce you to Redis Bloom, a Redis Module that natively implements the most useful PDS.
The RedisBloom module provides four data structures: a scalable Bloom filter, a cuckoo filter, a count-min sketch, and a top-k.
In this session, we will explore the most common applications of these data structures in the context of a Spring RESTful Web Services application.
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.
Gradle has been described as the open source project with the most documentation that doesn't help. Key concepts, like the different steps Gradle takes at initialization time, configuration time, and execution time are not obvious, but must be understood to use Gradle effectively. This talk will cover those topics, as well as how to use source sets, IDE integration, testing in parallel, the build cache, and multi-project builds.
New topics to be included based include writing your own custom tasks, using version constraints, archiving and expanding files and folders, and incremental builds for efficiency.
Recently revised to include dependency conflict resolution, lazy task creation, the TOML file for versioning, and more.
The process and preferred practices for developing Android apps changed dramatically over the past few years. Google now recommends Kotlin as a development language of choice. In addition, Google introduced the Jetpack suite of libraries, like ViewModel, LiveData, and the Room ORM model for persistence. The recommended architecture now combines the components with networking libraries like OkHttp and Retrofit. Even dependency injection frameworks, like Dagger and now Hilt, are part of typical applications.
This talk will discuss how Android development has changed, and illustrate the newer, component-based approach to building robust mobile applications.
The web is arguably the single most impactful revolution in human history (to date). By agreeing on a simple set of standards, we have collectively unlocked all the world's information. Documents can be discovered, retrieved, published, and shared so easily we don't even think about it.
Data, on the other hand, is a different story. Our data remains stuck in the 1980s. Locked in silos, each with a different format, interface, and conventions that must be interpreted by a human, parsed, mapped, and converted. Data is at the heart of many problems we solve today, and we produce data exponentially faster than we can consume it.
Today I can request any document from any server on the web. I need to know nothing about the underlying technology the server uses, nothing about how the information is stored or retrieved, and consume it instantly. We've been evolving those same capabilities with data over the past 20 years and the standards, tools, and technologies are reaching critical mass. The linked data revolution is now one that you can no longer ignore. Join us to see what you've been missing.
Completely Rewritten for 2023
Although the Resource-Oriented Architecture is one of the oldest and most successful distributed architectures, it remains poorly understood and often completely overlooked today.
Much of the microservices architecture pattern is focused on taking applications apart although seemingly everyone has different ideas on how to put things back together again.
In this session, we will start with a summary of the resource-oriented architecture along with it's strengths and weaknesses. Michael will share hard-earned, real-world experience applying ROA concepts to complex microservice environments to successfully build an infinitely scalable, extensible, and understandable system.
The difference between a junior and a senior dev isn't coding skills. A developer's coding skills are just their ante; necessary to get into the game but, like an ante, they only get you into the game.
Everything that happens from that point on depends on what else you bring to the table.
In this session, we explore the key skills necessary to make an impact, be effective, and will ultimately pave the way to grow into senior/principal level developers and architects.
On the NFJS tour, there are questions that seem to come up again and again. One common example is “How do we determine which new tools and technologies we should focus our energy on learning?” another is “How do we stop management from forcing us to cut corners on every release so we can create better and more maintainable code?” which, after awhile becomes “How can we best convince management we need to rewrite the business application?”
There is a single metaanswer to all these questions and many others.
It begins with the understanding that what we as engineers value, and what the business values are often very different (even if the ultimate goals are the same) By being able to understand these different perspectives it's possible to begin to frame our arguments around the needs and the wants of the business. This alone will make any engineer significantly more effective.
This session picks up from where “Stop writing code and start solving problems” stops discussing what is value, how do we align the values of the business with the needs and values of the engineer.
Most developers are aware that Kotlin is the language of choice for Android applications, it can also be used effectively on the server side. The Spring Framework in particular makes excellent use of Kotlin features. Spring supports Kotlin data classes and reified types, provides extension functions and small domain-specific languages for bean configuration and testing, and more.
This talk will show how Kotlin fits into the Spring ecosystem and how Spring developers can benefit from its null safety, strong typing, and powerful support for concurrency.
Good discussions are supposed to diverge from their intended path. Free association is a feature, not a bug, and helps you see new connections between ideas. Without structure, however, it can be difficult to add context to new ideas and understand how they relate to more immediate problems. This talk discusses the technique of mental bookmarks – how to remember where you were when a discussion diverged. In addition to giving you a reputation for having an amazing memory, the skill also helps with personal awareness in general.
To give the technique context, we'll look at the fractal nature of success – the way we tend to see our current environment in relative terms, always comparing ourselves to those slightly more successful and slightly less successful.
Time management + prioritization - everyone needs it! We all seem to face a never-ending list of demands coupled with a finite amount of time to get it all done.
You will leave this 60 minute session armed with new tips and tools to effectively balance your time between meetings, writing code, putting out fires, and clarifying your role to ensure you are spending time on the things that actually matter!
Our industry never stops changing, but sometimes those changes are trivia and fluffy. Sometimes they are fundamental and enduring. This series is going to highlight some of the most important trends happening in the hardware, software, data and architecture spaces.
Machine Learning is clearly here to stay. While it is a far cry from actual Artificial Intelligence, it provides many invaluable and remarkable ways to learn from the data we are collecting about our customers, products and daily activities. The past afforded us machine learning libraries which became machine learning frameworks. Now, we are designing and building machine learning platforms that facilitate entire initiatives in reusable and extensible ways. We will discuss many of the drivers of modern machine learning systems and the platforms that we are seeing emerge.
Modern software developers who want to learn from their data need to understand the machine learning landscape.
We will cover:
We are all proud of being the best coders, but have we analyzed our code for optimization? What tools can help us guide toward creating algorithms with better time and space complexity?
How you approach a problem is critical. How do you solve the problem? How do you optimize the problem?
In this talk/workshop, we will be exploring the analytical skills and coding skills of the top algorithms and common problems from the real world, including Single Source Shortest Paths, Travelling Salesman problems, Pattern Search Algorithms, Greedy Algorithms, KnapSack problem, and priority queue. Problem-solving skills are valuable and help develop optimal algorithms. We will look at problem-solving flow charts to make the right decisions for a given problem.
Should Information Management systems apply the services architecture? Many data provisioning and BI systems are monolithic, tightly coupled, difficult to scale, and stumble when it comes to delivering MVP in a timely manner.
In this session we will look at the common obstacles such systems inherently bring with them, and how the Data as a Service architecture pattern addresses many of these issues.
Agenda
Business requirements are not the only influencers of our technical solutions. Laws and Regulations transform the technical landscape in ways that require us to redefine our architecture, as well as our skill-set. This is especially true with Data Privacy. Since GDPR and CCPA, our industry is witnessing a new career path emerge: the Privacy Engineer. Where security started 10 years ago, so does privacy engineering. Join us as we look at Privacy by Design (PbD) and introduce some architecture patterns that align with privacy strategies.
Agenda:
Privacy by Design is rapidly becoming the new focus for go forward architecture and application design. However, few companies have the luxury of building out new solutions and are struggling with ways to adapt their current systems to meet Privacy by Design criteria. If you find yourself in such a situation, know that you're not alone.
In this session we'll review some common legacy designs and provided suggestions for them that you can implement to better align your systems toward privacy strategies.
Agenda
Brian will introduce you to the power of RediSearch to query structured and unstructured data in Redis and show how RediSearch helps to narrow the SQL to NoSQL gap by allowing common SQL patterns to be implemented in a key-value and document data store like Redis.
Do you automatically reach for a relational database for your application’s data needs? There is an unspoken impedance mismatch between expected rates of maturity between an application’s model and its data model. NoSQL/NewSQL and now “beyond SQL” solutions are often met with incredulity from the die-hard SQL crowd. Brian will introduce you to the power of RediSearch to query structured and unstructured data in Redis and show how RediSearch helps to narrow the SQL to NoSQL gap by allowing common SQL patterns to be implemented in a key-value and document data store like Redis.
Using the RediSearch module, you’ll learn:
How to query data in Redis with SQL-like flexibility
How to use boolean logic, full-text search, numeric ranges, geo radiuses, and more
How to create secondary indexes for your existing Redis data
How to build reporting and analytics queries using aggregations (COUNT, SUM, etc.)
When we productionalize machine learning systems, we are taking our models and injecting them squarely into our production systems. It is astonishing how rarely the topic of security crosses anyone's mind with respect to these models, the training process and what it means for often inexplicable systems that have an increasing bearing on our lives.
In this talk we will highlight and contextualize a handful of security attacks or issues that could exist in machine learning systems based on some of the most current research on the topic.
A good software architecture is the foundation for any successful software system. Your architectural choices affect almost every aspect of the software you are building from maintainability to stability, scalability and cyber vulnerability. Matching software architecture patterns and styles with requirements is a difficult task that requires knowledge and experience as well as the willingness to pick the right trade-offs.
Way too often the originally intended architecture erodes during the development process making the software harder to understand, to maintain and to adapt to changing requirements. By losing architectural coherence you also lose all the other benefits coming from a good architectural foundation. This drives up cost, reduces the happiness of your development team and ultimately will also impact the users of your software negatively.
Join expert Alexander von Zitzewitz to learn the foundations of good architecture. You’ll explore the concept of architecture styles and architectural fitness functions and dive into software metrics with architectural relevance. You’ll also investigate architectural smells like cyclic dependencies and bottleneck classes along with ways to refactor to prevent quality issues.
After learning the fundamentals, you’ll do some real code analysis using a free tool called Sonargraph-Explorer. Get hands-on with basic assessment and analysis techniques as well as techniques and methods for breaking up or restructuring monolithic applications—and measure your progress every step of the way. Then we will talk about how you can enforce architectural models during development and therefore avoid the common problem of architectural erosion in the first place. At the end, we will look at techniques to break up monolithic applications into more manageable pieces.
Please register on ww.hello2morrow.com and download and install Sonargraph-Explorer. The license is free and you will need the tool if you want to actively want to join exercises. You can also bring one of your projects, if you want to analyze your own code. (Java, C#, C/C++ or Python). I will provide snapshots of some open source projects if you prefer to work with an example.
Download link for examples: https://www.dropbox.com/scl/fi/znp5m7x8giiqmkaxp6ktg/ArchConf.zip?rlkey=bifgjeqim939gv9w5noiaobvn&st=ziows6zg&dl=0
Kubernetes is a rich infrastructure that helps you tackle the complexities of distributed computing. As a developer you want to understand how you can architect your code to take advantage of the whole data center for your scaling, load balanced, and resilient microservices.
This course is for software engineers (architects, developers, DevOps, administrators, testers) who want to move their solutions to microservices and containers running on cloud native, distributed container platforms. This introduction course covers the key techniques to automate, deploy, and manage containerized applications on Kubernetes.
These concepts are presented and reinforced with hands-on exercises:
While this is much to cover in a day you will leave with a solid understanding of how Kubernetes actually works and a set of hands-on exercises your can share with your peers.
Some knowledge of how to build containers will be helpful. Bring a simple laptop with a standard browser for a full hands-on experience.
There's a lot of developers praising the hottest, and fastest, Java REST frameworks: Micronaut, Quarkus, and Spring Boot. In this session, you'll learn how to do the following with each framework:
✅ Build a REST API
✅ Secure your API with OAuth 2.0
✅ Optimize for production with Docker and GraalVM
I'll also share some performance numbers and pretty graphs to compare community metrics.
Web app security is not just authentication and authorization. It's also the things you do to protect your web app from attackers with their XSS (cross-site scripting), SQL injection, DoS/DDoS attacks, and CSRF (cross-site request forgery), to name a few.
Web app security is a central component of any web-based business. The internet exposes web apps to attacks from different locations and various levels of scale and complexity. Web application security deals specifically with the security surrounding websites, web applications, and web services such as APIs.
In this presentation, you'll learn seven ways to better web app security, using Spring Security for code samples. You'll also see some quick demos of Spring Boot, Angular, and JHipster with Okta.
This talk is designed to catapult your productivity, enhance your emotional intelligence, and refine your problem-solving skills. This talk is not just a series of presentations; it's a transformative experience tailored for the ambitious software developer and architect seeking to leave a mark in the fast-paced world of technology.
Dive into the essence of developer and architect productivity, where we unravel the secrets to optimizing your workflow and leveraging your skills for maximum impact. Discover the “24 Hours Instant Happiness” principle, a proven strategy to inject a dose of joy into your daily routine, fostering a positive work environment and personal life.
“Maximizing Your Impact” takes you deeper into the realm of influence, equipping you with the tools to excel in your projects and inspire those around you. Through “Effective Communication” and the intriguing “Mirror Technique,” learn how to build rapport, foster collaboration, and lead with empathy, amplifying your charisma in all professional interactions.
As we delve into the core of success, “Emotional Intelligence is 85% of Success” highlights the paramount importance of self-awareness, self-regulation, motivation, empathy, and social skills in achieving your goals. The “6 Phase Meditation Approach” and “Day Launcher” sessions are designed to refine your focus, creativity, and emotional stability, setting a solid foundation for a productive day ahead.
The inclusion of “Empathy Maps” and “IDEO Case Studies” offers a practical lens through which to view user-centric design and innovation. At the same time, the “SCAMPER Technique” provides a creative framework for problem-solving, ensuring you're equipped to tackle challenges with agility and inventiveness.
Elevate your productivity to new heights with “5 Choices for Super Productivity,” a comprehensive guide to prioritizing effectively, embracing extraordinary outcomes, and mastering your technology. Learn the art of “Managing Energy, Not Time,” a paradigm shift that promises to enhance your efficiency and job satisfaction.
As the talk culminates, “The Paradox of Choice” and the latest “Technology Trends to Focus On” prepare you to navigate the complexities of the modern tech landscape with confidence and curiosity.
This masterclass is more than just a talk; it's an invitation to transform how you work, lead, and innovate. Join us to unlock your full potential and reshape your future in software development and architecture. Whether you're looking to boost your productivity, enhance your emotional intelligence, or simply find more joy in your work, this talk is your gateway to a more fulfilling career and life.
Developers and Architects are designers, problem solvers, and innovative, creative artists. Software design is an art that requires both left and right brains to be active so you can understand what customers need. Next, we will explore habits and tools to plan, learn, research, organize, teach, develop, mentor, and architect.
Agenda
Enhancing Productivity and Personal Growth
– Developer and Architect Productivity
Strategies for improving daily workflow and efficiency in software development and architecture.
– 24 Hours Instant Happiness
Quick wins for boosting morale and happiness within the team and personal life.
– Maximizing Your Impact
Techniques to increase your influence and contributions in projects and teams.
– Effective Communication
Importance of clear communication and the Mirror Technique to improve understanding and rapport.
– Increasing Charisma
Tips for becoming more charismatic and influential in professional settings.
Building Emotional Intelligence and Mindfulness
– Emotional Intelligence is 85% of Success
Discussing the critical role of emotional intelligence in achieving professional success.
– 6-Phase Meditation Approach
Introducing a meditation technique to enhance focus, creativity, and emotional stability.
– Day Launcher
A strategy to start your day with intention and focus, setting the tone for productivity and success.
– Empathy Map
Utilizing empathy maps to better understand user needs and enhance team collaboration.
– IDEO Case Studies
Examining case studies from IDEO to illustrate successful applications of empathy in design.
– Understanding a Problem with SCAMPER Technique
Exploring the SCAMPER technique to creatively solve problems and innovate solutions.
Strategies for Super Productivity
– 5 Choices for Super Productivity
Detailed strategies for enhancing productivity by prioritizing important tasks, aiming for extraordinary outcomes, scheduling priorities (“big rocks”), mastering technology use, and maintaining energy levels.
– Managing Energy, Not Time
Shifting focus from time management to energy management to maximize productivity and well-being.
– Increasing Frequency to Do What You Want
Techniques to align daily actions with personal and professional goals more effectively.
– The Paradox of Choice
Understanding how reducing options can lead to increased satisfaction and productivity.
– Technology Trends to Focus On
Highlighting current technology trends that developers and architects should be aware of to stay ahead in their field.
There are multiple elements to Kubernetes where each component seems like a character in a book, pods, services, deployments, secrets, jobs, config maps, and more. In this presentation, we just focus on the security aspect of Kubernetes and the components involved. Particularly centered around RBAC and ServiceAccounts. What they are, what they do. We discuss etcd and secrets. We will also discuss other options for security in Kubernetes.
There are multiple elements to Kubernetes where each component seems like a character in a book, pods, services, deployments, secrets, jobs, config maps, and more. In this presentation, we just focus on the security aspect of Kubernetes and the components involved. Particularly centered around RBAC and ServiceAccounts. What they are, what they do. We discuss etcd and secrets. We will also discuss other options for security in Kubernetes.
Service Accounts
Secrets
Kubernetes API
Authentication
Authorization
RBAC
Roles and Cluster Roles
Delivering feedback is arguably the hardest part of being a leader. Eventually, the time will come when someone on your team isn’t meeting expectations, and you will be faced with a choice. You can choose to ignore the situation, hope it improves organically, and accept the toll it takes on the broader team, or you can choose to have the tough conversation.
In this interactive session, you will learn more about your communication style, a simple framework to provide actionable feedback, common red flags to watch out for, and advice on how to quickly course correct on a dev team. You’ll leave with a template for giving feedback that you can tie directly to a situation you’re currently facing as well as plenty of examples that you can leverage in the future.
By the end of this conference you will have learned many new tools and technologies. The easy part is done, now for the hard part: getting the rest of the teamand managementon board with the new ideas. Easier said than done.
Whether you want to effect culture change in your organization, lead the transition toward a new technology, or are simply asking for better tools; you must first understand that having a “good idea” is just the beginning. How can you dramatically increase your odds of success?
You will learn 12 concrete strategies to build consensus within your team as well as 6 technique to dramatically increase the odds that the other person will say “Yes” to your requests.
As a professional mentalist, Michael has been a student of psychology, human behavior and the principles of influence for nearly two decades. There are universal principles of influence that neccessary to both understand and leverage if you want to be more effective leader of change in your organization.
In this session we discuss strategies for getting your team on board as well as when/how to approach management within the department and also higherup in the organization.
There's nothing new or exciting about relational databases. We abstract them away with ORMS, grudgingly write a query here or there, but generally try to forget about them entirely. Then the performance and scalability problems begin. “Shading, the secret ingredient to the web-scale sauce” often won't help us.
The database is at the heart of nearly every system we build. Reading data and writing data account for the majority of performance bottlenecks. When it comes to SQL and relational databases, the syntax is easy, but the concepts often aren't. The most important knowledge is not obvious but it is necessary to make the right design, query, and optimization decisions.
Indexing, a glimpse under the hood of the storage engine and the query optimizer, and some best practices are all you need to know bring your DB skills head and shoulders above your peers and ready to build bigger, better, faster apps.
In Part 1, you learned the core principles of influence and persuasion. How to we take this back to the office and apply what we've learned?
We dive deep in to specific strategies to get both the team and the business on board with your ideas and solutions. We cover several realworld patterns you can follow to be more effective and more persuasive. Part 1 was conceptual, part 2 is practical.
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.
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.
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
Spring has always been defined by its lightweight core. While there has been an overwhelming explosion in the external projects and protocols it integrates seamlessly with, it has also evolved internally to meet the needs of modern development requirements.
One of the biggest changes in the last several years has been the emergence of Reactive Spring, an attempt to embrace the idea of Reactive Systems in the Spring ecosystem. This is a vision of responsive, resilient, elastic systems. Unfortunately, code alone cannot solve the problems so this is a case where software and architecture meet.
You will learn about:
- The Reactive System vision
- How Spring absorbed these ideas without complicating or
eliminating the more conventional styles
- How to build, test and consume Reactive Spring applications
- How to architect entire Reactive chains of interacting systems
Spring has always been defined by its lightweight core. While there has been an overwhelming explosion in the external projects and protocols it integrates seamlessly with, it has also evolved internally to meet the needs of modern development requirements.
One of the biggest changes in the last several years has been the emergence of Reactive Spring, an attempt to embrace the idea of Reactive Systems in the Spring ecosystem. This is a vision of responsive, resilient, elastic systems. Unfortunately, code alone cannot solve the problems so this is a case where software and architecture meet.
You will learn about:
- The Reactive System vision
- How Spring absorbed these ideas without complicating or
eliminating the more conventional styles
- How to build, test and consume Reactive Spring applications
- How to architect entire Reactive chains of interacting systems
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.
I know what you are thinking. Another unit testing presentation/workshop? That is so early 2000s. But a lot has changed if you haven't been keeping up with the unit testing space recently. Frameworks such as Junit 5 and Mockito 3 have been updated significantly. New programming styles such as lamdas and reactive are becoming mainstream, changing how we test our code. We also have new frameworks for integration testing, such as Testcontainer.
Whether you're a unit testing veteran or a newbie, this hands-on workshop will give you the experience and confidence necessary to write unit tests today.
Java 11+
Clone https://github.com/cjudd/modern-java-unit-testing-workshop
Intellij (preferred)
I know what you are thinking. Another unit testing presentation/workshop? That is so early 2000s. But a lot has changed if you haven't been keeping up with the unit testing space recently. Frameworks such as Junit 5 and Mockito 3 have been updated significantly. New programming styles such as lamdas and reactive are becoming mainstream, changing how we test our code. We also have new frameworks for integration testing, such as Testcontainer.
Whether you're a unit testing veteran or a newbie, this hands-on workshop will give you the experience and confidence necessary to write unit tests today.
Java 11+
Clone https://github.com/cjudd/modern-java-unit-testing-workshop
Intellij (preferred)
CRI-O and Buildah and Podman, OH MY. (…and Skopeo, and what on Earth happened with Docker, and……) Containers are really cool, and also useful. Everyone knows it! The open source community has rallied around them and are constantly making improvements and tweaks to their capabilities. But…the tools generated by those open source communities are constantly evolving, and it ends up really hard to keep up on what does what and…why you should care.
Laine and Josh will explain containers as a whole, their lifecycle, and the tools currently among the landscape of awesome. They'll talk about when you should use what, and they'll demo how it all fits together to help with container-based application development and deployment.
Our industry never stops changing, but sometimes those changes are trivia and fluffy. Sometimes they are fundamental and enduring. This series is going to highlight some of the most important trends happening in the hardware, software, data and architecture spaces.
While still new to most people, WebAssembly provides a formidable vision of safe, fast, portable code. Through clever choices and well-considered design, the basic vision allows us to target browsers as a platform using a variety of languages other than (but compatible with) Javascript. This technology coupled with advancements in the Web platform are setting up the future of Web-delivered applications to look more like (and likely to replace) desktop applications.
Modern software developers need to understand how just about every aspect of their industry is about to change.
We will cover:
Since 1994, the original Gang of Four Design Patterns book, “Design Patterns: Elements of Reusable Object-Oriented Software” has helped developers recognize common patterns in development. The book was originally written in C++, but there have been books that translate the original design patterns into their preferred language. One feature of “The Gang of Four Design Patterns” that has particularly stuck with me has been testability for the most part. With the exception of singleton, all patterns are unit testable. Design Patterns are also our common developer language. When a developer says “Let's use the Decorator Pattern” we know what is meant.
What's new though is functional programming, so we will also discuss how these patterns change in our new modern functional programming world. For example, functional currying in place of the builder pattern, using an enum for a singleton and reconstructing the state pattern using sealed interfaces. We will cover so much more, and I think you will be really excited about this topic and putting it into practice on your own codebase.
We will be using a cloud environment, so you can relax
But if you want to, you don't have to, but if you want to run locally, you should have JDK 19
Since 1994, the original Gang of Four Design Patterns book, “Design Patterns: Elements of Reusable Object-Oriented Software” has helped developers recognize common patterns in development. The book was originally written in C++, but there have been books that translate the original design patterns into their preferred language. One feature of “The Gang of Four Design Patterns” that has particularly stuck with me has been testability for the most part. With the exception of singleton, all patterns are unit testable. Design Patterns are also our common developer language. When a developer says “Let's use the Decorator Pattern” we know what is meant.
What's new though is functional programming, so we will also discuss how these patterns change in our new modern functional programming world. For example, functional currying in place of the builder pattern, using an enum for a singleton and reconstructing the state pattern using sealed interfaces. We will cover so much more, and I think you will be really excited about this topic and putting it into practice on your own codebase.
We will be using a cloud environment, so you can relax
But if you want to, you don't have to, but if you want to run locally, you should have JDK 19
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.
There is pain inherent in development - monoliths, confusing deployment processes, conflict between dev/ops/business.
IT is hard and the pace of change now makes it even more difficult. Join Josh and Laine as they talk about how focusing on solving this pain can help in a lot of surprising ways - kickstarting DevOps, speeding up product delivery, and even enabling the business as a whole.
Conflict between technical professionals and traditional managers is inevitable, because you want different things. Worse, most employees feel that when conflicts arise, their only options are either to go along with what the manager wants, or leave. Neither option gets you what you want when you want it.
This talk discusses a third option: how to build a relationship over time that makes your boss an ally. The goal is to build a productive relationship that allows you to push back against decisions you don't like, while maintaining a constructive, loyalty-based relationship that satisfies both sides. Topics will include the two messages to keep in mind whenever you interact with the boss, how to use solutions to the iterated Prisoner's Dilemma problem to resolve conflicts, how to structure communications in way most likely to be heard and understood, and more.
Albert Einstein once said — “We cannot solve our problems with the same thinking we used when we created them.”
As developers, architects, managers, tech-leads, our job entails solving big problems. However, our systems are composed of parts, and it is the interaction of those parts that ensure the system works, and tells us where to go looking when things fail. What does it mean to think in systems? What are the benefits, and what are tools are available to us? If any of this intrigues you (and it should) come join me as we explore a new way of thinking about problems, both big and small.
In this session we will take a page from Donella H. Meadows fantastic book “Thinking in Systems” and attempt to get an understanding of what makes up a system, how we can tease apart the moving parts of the system, and get into the mindset of a “systems thinker”.
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.
Many have already seen what Reactive Streaming can do: RXJava, Akka Streams, Project Reactor. Now reactive streaming is a part of the canonical package for Java and now we can handle asynchronous pipelines with boundaries and make better well thought out applications
This session introduces you to the core components of Reactive Streams: Publisher, Subscriber, and Processor. We will discuss when to use Reactive Stream and how to avoid complicated scenarios like Backpressure. We will also cover some of the core problem spaces and how to overcome them. After understanding the core interfaces we will see how we use them with RXJava, Akka Streams, Reactor.
Starting with JDK 5, we have had Futures, and they mostly went ignored. Now with concurrency and reactive technology in demand, it is essential that we understand what futures are, and how to handle them and make use of their power in asynchronous systems.
This presentation is a basic ground-up introduction to Futures. We start with Futures and how they came packaged with JDK 5. We take a look at Executors, how to create a thread pool, which pools you should choose. How to model Futures in the JDK and show the difference for awaiting the answer and taking on the answer asynchronously. We also take a look at what a Promise is and when to use one.
It seems like everyday there is a new headline about a security breach in a major company’s web application. These breaches cause companies to lose their credibility and cost them large sums of money. Security is everybody’s job and requires us to be proactive.
This hands-on workshop is designed to teach you how to identify, exploit (legally) and fix vulnerabilities in modern Java web applications. Using an existing web application, you will learn ways to scan and test for common vulnerabilities using common penetration testing tools. You will learn about OWASP Top 10 vulnerabilities such as hijacking, injection, cross-site scripting, cross-site forgery and more. You will learn best practices around logging, error handling, intrusion detection, authentication and authorization. You will also learn how to improve security in your applications using existing libraries, frameworks and techniques to patch and prevent vulnerabilities making your software safer.
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.
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.
This talk discusses the progression from a monolithic application, where the application and user data are in the same database, to a microservice architecture, where the application and user data are in separate databases.
It covers the history behind sessions and some of the issues with them. It then builds on this by introducing tokens to manage identity and finally ends with a complete discussion of JSON Web Tokens (JWTs) and OpenID Connect. I cover JWTs, how we use OpenID Connect, and the benefits and drawbacks of these systems.