Awareness is the knowledge or perception of a situation or fact, which based on myriad of factors is an elusive attribute. Likely the most significant unasked for skill… perhaps because it's challenging to “measure” or verify. It is challenging to be aware of aware, or is evidence of it's adherence. This session will cover different levels of architectural awareness. How to surface awareness and how you might respond to different technical situations once you are aware.
Within this session we look holistically an engineering, architecture and the software development process. Discussing:
* Awareness of when process needs to change (original purpose of Agile)
* Awareness of architectural complexity
* Awareness of a shift in architectural needs
* Awareness of application portfolio and application categorization
* Awareness of metrics surfacing system challenges
* Awareness of system scale (and what scale means for your application)
* Awareness when architectural rules are changing
* Awareness of motivation for feature requests
* Awareness of solving the right problem
The focus of the session will be mindful (defined as focusing on one's awareness), commentating in sharing strategies for heightening awareness as an architect and engineer.
Just as sharpening the saw is the best way to cut down a tree… sharpening your development environment allows for a more focused more productive experience.
This session is a collection of scripts, aliases, shells, editors and tools which will super charge your development experience.
This session will cover:
Bring your machine and lets have you productive within 2 hours!
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.
In this example-driven session, we'll review several tips and tricks to make the most out of your Spring development experience. You'll see how to apply the best features of Spring and Spring Boot, including the latest and greatest features of Spring Framework 6.x and Spring Boot 3.x with an eye to what's coming in Spring 7 and Boot 4.
Spring has been the de facto standard framework for Java development for nearly two decades. Over the years, Spring has continued to evolve and adapt to meet the ever-changing requirements of software development. And for nearly half that time, Spring Boot has carried Spring forward, capturing some of the best Spring patterns as auto-configuration.
As with any framework or language that has this much history and power, there are just as many ways to get it right as there are to get it wrong. How do you know that you are applying Spring in the best way in your application?
You'll need…
In this example-driven presentation, we'll take a high-level look at how Spring applies reactive programming at all layers of an application. You'll also learn the essentials of working with Project Reactor, the reactive programming library for Java that Spring's reactive support builds upon.
Traditionally, applications have been built using a blocking, synchronous model. Although comfortable and intuitive for most programmers, this model doesn't scale well. And although there are several new approaches to reactive programming, they don't necessarily fit into the familiar programming model that Spring developers are accustomed to working with.
Spring 5 introduced a set of new reactive features, enabling non-blocking, asynchronous code that scales well using minimal threads. Moreover, it builds on the same concepts and programming models that Spring developers have used for years.
In this example-driven presentation, we'll focus on working with reactive data persistence. We'll start by seeing how to create reactive repositories for relational databases with Spring Data R2DBC. Then we'll explore non-relational reactive persistence for MongoDB and Cassandra.
Traditionally, applications have been built using a blocking, synchronous model. Although comfortable and intuitive for most programmers, this model doesn't scale well. And although there are several new approaches to reactive programming, they don't necessarily fit into the familiar programming model that Spring developers are accustomed to working with.
Spring 5 introduced a set of new reactive features, enabling non-blocking, asynchronous code that scales well using minimal threads. Moreover, it builds on the same concepts and programming models that Spring developers have used for years.
In this example-driven presentation, we'll focus on how to build reactive APIs in Spring. We'll start with Spring WebFlux, a reactive reimagining of the popular Spring MVC framework for HTTP-based APIs. Then we'll have a look at RSocket, an intriguing new communication protocol that is reactive by design.
Traditionally, applications have been built using a blocking, synchronous model. Although comfortable and intuitive for most programmers, this model doesn't scale well. And although there are several new approaches to reactive programming, they don't necessarily fit into the familiar programming model that Spring developers are accustomed to working with.
Spring 5 introduced a set of new reactive features, enabling non-blocking, asynchronous code that scales well using minimal threads. Moreover, it builds on the same concepts and programming models that Spring developers have used for years.
In this example-driven session, we're going to look at how to implement GraphQL in Spring. You'll learn how Spring for GraphQL builds upon GraphQL Java, recognize the use-cases that are best suited for GraphQL, and how to build a GraphQL API in Spring.
Typical REST APIs deal in resources. This is fine for many use cases, but it tends to be more rigid and less efficient in others.
For example, in an shopping API, it's important to weigh how much or how little information should be provided in a request for an order resource? Should the order resource contain only order specifics, but no details about the order's line items or the products in those line items? If all relevant details is included in the response, then it's breaking the boundaries of what the resource should offer and is overkill for clients that do not need it. On the other hand, proper factoring of the resource will require that the client make multiple requests to the API to fetch relevant information that they may need.
GraphQL offers a more flexible alternative to REST, setting aside the resource-oriented model and focusing more on what a client needs. Much as how SQL allows for data from multiple tables to be selected and joined in response to a query, GraphQL offers API clients the possibility of tailoring the response to provide all of the information needed and nothing that they do not need.
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 domaindriven 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.
In this session we will go further with DDD, considering aspects like aggregates, domain events, factories and repositories, and consider how DDD can be represented in architecture, be that hexagonal, REST or RPC.
If you need a deeper dive into DDD, then this is the session for you.
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.
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.
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.
As a software architect, you're at the forefront of building scalable, secure, and resilient systems that drive innovation while safeguarding critical digital assets. This workshop is designed to equip you with actionable strategies, cutting-edge tools, and deep technical insights into embedding security into every phase of the software development lifecycle.
In this immersive, hands-on session, we will explore how to elevate your DevSecOps practices to meet the challenges of today’s evolving threat landscape while ensuring productivity and operational excellence.
What You'll Learn:
Why You Should Attend:
Who Should Attend:
This workshop is ideal for:
Join us for this transformative session to gain the skills and knowledge necessary to design secure, scalable, and resilient systems that protect your organization and enable innovation.
This session is a must-attend for architects aiming to design secure, scalable systems while staying ahead in the rapidly evolving security landscape.
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
The organization has grown and one line of business has become 2 and then 10. Each line of business is driving technology choices based on their own needs. Who and how do you manage alignment of technology across the entire Enterprise… Enter Enterprise Architecture! We need to stand up a new part of the organization.
This session will define the role of architects and architectures. We will walk through a framework of starting an Enterprise Architecture practice. Discussions will include:
Spock is a groovy based testing framework that leverages all the “best practices” of the last several years taking advantage of many of the development experience of the industry. So combine Junit, BDD, RSpec, Groovy and Vulcans… and you get Spock!
There are 3 tools I use on every Java project I control… this is one of them and with good reason.
This session assumes some understanding of testing and junit and builds on it. We will introduce and dig deep into Spock as a test specification and mocking tool. Topics include:
Unit testing
Data driven tests
Mocking and Stubbing
Partial Mocks
Spock Extensions
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.
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 const
Map
/ 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 const
Map
/ 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.
Are you a Java Developer looking to work on a Golang project? Are you looking to get involve on cloud native projects such as Kubernetes? This session is for you! This session assumes are are a Java developer and details the nuances of Go with comparisons against Java-isms.
This session will take a deep dive into Go as a language and provide details necessary to understand and write idiomatic go applications. In addition to differences in how to use the language and packaging structures, we will look at options for standard idiomatic Java. This will include:
In the process, we will look at several Go projects in the Open Source space as style examples.
This workshop discusses the features added to Java since Java 8. After a review of the functional additions (streams, lambda expressions, and method references), topics will include Local Variable Type Inference (LVTI), collection factory methods, the Java shell, the new HTTP client, the enhanced switch statement, text blocks, records, pattern matching, and sealed classes.
Features will be demonstrated for Java versions from 8 through 17, using preview versions where available.
java.time
PackageList.of
Set.of
Map.of
Map.ofEntries
This workshop discusses the features added to Java since Java 8. After a review of the functional additions (streams, lambda expressions, and method references), topics will include Local Variable Type Inference (LVTI), collection factory methods, the Java shell, the new HTTP client, the enhanced switch statement, text blocks, records, pattern matching, and sealed classes.
Features will be demonstrated for Java versions from 8 through 17, using preview versions where available.
java.time
PackageList.of
Set.of
Map.of
Map.ofEntries
The Mockito framework is the most popular library for creating mocks, stubs, and spies for your tests. This talk reviews why and how you might want to do that, including unit vs integration tests, creating your own mocks and stubs, setting expectations, and verifying the results.
The Mockito documentation is notoriously misleading if you don't already know the principles behind the library. This talk gives an example that hopefully clears up any confusion and makes the docs useful. Many examples will be provided covering a wide range of capabilities. In addition to the basics, issues like mocking static methods, mocking final methods and classes, using spies for existing classes, and more will be examined.
The fundamental testing libraries in Java have undergone complete redesigns in the past few years. JUnit 5, known as JUnit Jupiter, redesigns the most well-known tool in all of testing. This talk will demonstrate the new features, how they are intended to be used, and discuss experimental ideas 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.
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.
Genetic algorithms are a nonlinear optimization technique. They encode a set of solutions, called a population, that are evaluated using a fitness function. Successful solutions are chosen to form new solutions, called offspring, through a process called crossover. In each generation, random mutations are introduced as well, to maintain a good level of genetic diversity. In addition to the basic concepts, examples will be shown in Java using the Jenetics library.
This talk will show several problems that are ideally suited to genetic algorithms, including the Traveling Salesman Problem, Ant Colony Optimization, the Knapsack Problem, and more.
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.
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.
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.
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.
Seven steps methodology for designing superior AI-Enabled Microservices
In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs.
In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs.
In this talk, we will explore ten steps methodology for designing superior Cloud Native RESTFul Microservices APIs. Firstly, define the business domain objects and how they relate to use cases. If the use-case is to support <500 ms response time and availability of 99.99%, design the application for Consistency, Availability, and Partition tolerant. Next, Create an ideal design which solves the use-cases, refer to the industry standard JSONs and designs from schema.org, iana.org, and microformats.org. Later, find the fail points in the process and go back to the first step to resolving the pain points: Go back to Define the problem. Question to ask is what can go wrong? When can it go wrong? Next, create a Facade pattern to connect to either the existing Monolithic App or create a new App to support the new cloud use-cases. Create API Gateway, so other companies can build software and create more offerings. Next, design common Layers for error handling, logs, and security. For API security, perform Threat Modeling to find security vulnerabilities and plan for mitigation of risks. Use generic authentication using SAML, OAuth, and JWT to support Authentication and Authorization. Next, create an API Versioning strategy so that the REST API can evolve with minimal client changes. Apply Cloud Native design patterns for Resiliency. In the end, test APIs using contract driven testing and PACT files.
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Seven steps methodology for designing superior AI-Enabled Microservices
In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs.
In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs.
In this talk, we will explore ten steps methodology for designing superior Cloud Native RESTFul Microservices APIs. Firstly, define the business domain objects and how they relate to use cases. If the use-case is to support <500 ms response time and availability of 99.99%, design the application for Consistency, Availability, and Partition tolerant. Next, Create an ideal design which solves the use-cases, refer to the industry standard JSONs and designs from schema.org, iana.org, and microformats.org. Later, find the fail points in the process and go back to the first step to resolving the pain points: Go back to Define the problem. Question to ask is what can go wrong? When can it go wrong? Next, create a Facade pattern to connect to either the existing Monolithic App or create a new App to support the new cloud use-cases. Create API Gateway, so other companies can build software and create more offerings. Next, design common Layers for error handling, logs, and security. For API security, perform Threat Modeling to find security vulnerabilities and plan for mitigation of risks. Use generic authentication using SAML, OAuth, and JWT to support Authentication and Authorization. Next, create an API Versioning strategy so that the REST API can evolve with minimal client changes. Apply Cloud Native design patterns for Resiliency. In the end, test APIs using contract driven testing and PACT files.
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
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?
This talk will not only prepare you for the interviews but will also give confidence on how to crack the coding challenges.
In this talk, we will be exploring analytical skills and coding skills of the top algorithms and common problems from the real-world, including
Single Source Shortest Paths
Traveling Salesman problems
Pattern Search Algorithms
Greedy Algorithms
KnapSack problem
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.
Topics we will cover are:
Arrays and Strings - Palindrome permutations
Linked Lists - Runner technique, Recursions
Stacks and queues
Trees and Graphs - Binary Tree, Binary Search Tree, Tries
Sorting and Searching
Single-Source Shortest Paths: Bellman-Ford, BFS, DFS, Dijkstra, Dynamic Programming
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
The Spring Data JPA allows you to work with relational databases quickly and easily. Spring Data adds an abstraction layer over Hibernate or other JPA providers. It provides transactional support, pagination, sorting, dynamic query execution, and the ability to integrate custom data access code into your projects. This presentation will cover the basics of mapping domain classes to database tables, working with relationships, transactional attributes like propagation and isolation, eager vs lazy fetching, and more.
Examples will use Spring Boot projects, both that let Hibernate generate the database schema and from existing databases. If time is available, demos will show how to add auditing information, optimistic locking, executing stored procedures, and more.
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 session we will attempt to unriddle the mystery that regular expressions pose. We will start at the basics and work our way towards more complex expressions.
A large part of embracing DevOps involves embracing automation. Over the last decade we have seen the emergence of “as Code” — Build-as-Code, Configuration-as-Code and Infrastructure-as-Code. The benefits to utilizing such tools are huge! We can codify the state of the world around our applications, giving us the ability to treat everything that our code needs like we treat the code itself. Version control, release management, tagging, even rolling backs are now possible. Terraform, an open-source tool from HashiCorp allows us to build, control and modify our infrastructure. Terraform exposes a Domain-specific language (DSL) that we can use to express what our infrastructure should look like. Terraform can work with all the major cloud providers, including Amazon AWS, Google GCP and Microsoft Azure. If you are curious about what this tool has to offer, this session is for you. Come on in, and let's learn how to terraform your cloud.
This session will focus on Terraform. We will look in to how this tool works, explore its capabilities, and see how it can play a pivotal role in our Infrastructure-as-Code (IaC) strategy. With lots of code and demos, this session will certainly give you enough fodder for thought, and provide a baseline so you can decide if Terraform is right for you.