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
Are you losing revenue to performance? 53% of mobile site visits are abandoned if a page takes longer than 3 seconds to load. Pinterest reduced load times by 40% and saw a 15% increase in sign ups. Starbucks implemented a 2x faster time to interactive resulting in a 65% increase in rewards registrations. AliExpress reduced load by 36% and saw a 10.5% increase in orders.
Performance is important. Tooling can be hard. Do flame charts intimidate you? Come learn how to audit and fix common performance issues using Chrome DevTools, Lighthouse, PageSpeed Insights, and webpagetest.org.
During this hands-on, full-day workshop, you will learn how to:
We will profile real applications to both learn the tools of measurement as well as see real performance problems in action. By the end of this workshop, you will be familiar with the following performance concepts. Many will be covered in-depth with exercises, and others will be covered in an overview with resources to learn more.
Prerequisites: To attend this workshop, you must already have a working understanding of JavaScript, HTML, CSS, git, and the command line, including installing npm packages and running npm scripts (or yarn). You must also have a basic understanding of Chrome DevTools, including inspecting an element and using the console. You do not need advanced mastery of DevTools as we will be learning about the Network and Performance tabs plus other tools during this session. A basic understanding of webpack would be very helpful, but the concepts can still be learned during this segment of the workshop.
Preparation: Please come with a laptop ready for development. You must have Chrome and Node (v 8+) installed.
Prerequisites: To attend this workshop, you must already have a working understanding of JavaScript, HTML, CSS, and the command line. You must also have a basic understanding of Chrome DevTools, including inspecting an element and using the console. You do not need advanced mastery of DevTools as we will be learning about the Network and Performance tabs plus other tools during this session. A basic understanding of webpack would be helpful but is not required.
Preparation: Please come with a laptop ready for development. You must have Chrome and Node (v 8+) installed.
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.ofSet.ofMap.ofMap.ofEntriesAccording to a CareerBuilder study, only 40% of new tech leaders receive formal training when they become a boss for the first time. The rest are forced to get scrappy to quickly equip themselves with new skills, techniques, and mindsets to effectively transition into their new roles.
This workshop was designed to fill this gap; providing tactical techniques and resources for both new and seasoned technical leaders!
In this full day workshop, you will learn how successfully navigate the complexities of Engineering Management. Topics include:
Purposeful leadership, emotional intelligence, self awareness, time management, prioritizing the right things, social styles, giving feedback, career conversations, 1:1s, psychological safety, recruiting, interviewing, onboarding, measuring team metrics, motivation, engagement, team building, and building sustainable relationships.
Interactive group exercises will help you practice these new ideas and techniques in a safe and engaging environment.
You will leave with new perspectives on Engineering Management, as well as handouts and plenty of resources to grow and further develop skills in your daily work.
Please download (and print if possible) the handout before joining this workshop! (located with session slides).
Please download (and print if possible) the handout before joining this workshop! (located with session slides).
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…
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
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.
In recent years the development of the Java language has accelerated significantly. Some of the more recent features are quite exciting and can lead to better modeling, fewer errors, less verbosity, and better developer productivity. In this presentation we will take a close look at these features and their significance. We will use concrete examples as use cases to explore the modern features. In addition to looking at these features we will also take a look under the hood at how these are implemented. This will help us to gain a better understanding of the builtin efficiencies these features come with.
Get ready to take part in some live coding as we dive into these amazing features.
There are some amazing features that are being introduced in Java in the coming years. Some of these features are just around the corner. However, these features, in various forms, have been in other languages for a while.
In this presentation we will take a look at some features in Kotlin, Scala, and JavaScript that are soon to be features of Java, understand their power and benefits and how we can make use of them. We will relate these features to how they are manifesting in Java.
Imperative style of programming is the most popular, familiar, and widely used and yet is packed with accidental complexity. Functional programming is gaining popularity, has less accidental complexity, and makes it easier to understand code once we're familiar with the paradigm. However, it has its own set of limitations.
Should we choose to program in imperative or should we use functional? Which one is better or should we be choosing one over the other on different occasions? We'll explore the answers for these questions in this presentation.
We all have read good books that tell us to choose delegation over inheritance. Yet, we often choose inheritance? Why is that?
In this presentation we will discuss the reasons, from the OO design point of view when we should choose inheritance and when we should choose delegation. Then we will discuss why we tend to lean towards inheritance. We will then model a problems to use delegation, using Java (plus some libraries), Groovy, and Kotlin and achieve fluent implementations of delegation. We will conclude with good recommendations on when to choose which approach.
The power of Java's functional programming goes far beyond lambdas and the filter, map of the Stream API. In this presentation we will look at various data transformations and see how the functional APIs in the JDK can provide concise solutions for these.
We will start with the Stream's API and quickly dive into some newer functions and also the utilities of the Collectors. Along the way you will get a deeper understanding of some of the excellent functions that are hidden in plain sight.
Game of Life is an intriguing game. At first look it looks simple, but as you look closer, it appears to be quite complex. How can we implement this game with different constraints, what are the constraints? Is it possible to use functional programming for this, to honor immutability? You see, it is intriguing.
We will discuss the constraints, think about how we may be able to solve them, and along the way discover how functional programming can play a role. We will have a fully working program, using live coding, at the end of this session, to illustrate some nice ideas that will emerge from our discussions.
Becoming a software architect is a longed-for career upgrade for many software developers. While the job title suggests a work day focused on technical decision-making, the reality is quite different. In this workshop, software architect Nathaniel Schutta constructs a real world job description in which communication trumps coding.
Discover the skill sets needed to juggle multiple priorities, meetings, and time demandsLearn why your best team leadership tool is not a hammer, but a shared cup of coffeeHear the best ways to give and take criticismUnderstand the necessity of writing effective email and formal architecture documentsGet tips for delivering confident career-building presentations to any audienceReview essential techniques for stakeholder management and relationship buildingExplore the critical needs for architecture reviews and an effective process for conducting themThrough lecture and small group exercises, Nathaniel will help you understand what it means to be a successful architect. Working through various problems, attendees will have opportunities to think through architectural decisions and patterns, discuss the importance of non functional requirements and why architects cannot afford to practice resume driven design.
Becoming a software architect is a longed-for career upgrade for many software developers. While the job title suggests a work day focused on technical decision-making, the reality is quite different. In this workshop, software architect Nathaniel Schutta constructs a real world job description in which communication trumps coding.
Discover the skill sets needed to juggle multiple priorities, meetings, and time demandsLearn why your best team leadership tool is not a hammer, but a shared cup of coffeeHear the best ways to give and take criticismUnderstand the necessity of writing effective email and formal architecture documentsGet tips for delivering confident career-building presentations to any audienceReview essential techniques for stakeholder management and relationship buildingExplore the critical needs for architecture reviews and an effective process for conducting themThrough lecture and small group exercises, Nathaniel will help you understand what it means to be a successful architect. Working through various problems, attendees will have opportunities to think through architectural decisions and patterns, discuss the importance of non functional requirements and why architects cannot afford to practice resume driven design.
By now your organization has planted a flag in “the Cloud” and it up to you to figure out just what that means to your application portfolio. Should everything be a microservice? Wait, what is a microservices anyway? How do you deal with massively distributed applications? How can event storming fix the gap between your business problems and domain model?
In this workshop, you will take a kata from event storming through to an initial design stopping along the way to discuss:
By now your organization has planted a flag in “the Cloud” and it up to you to figure out just what that means to your application portfolio. Should everything be a microservice? Wait, what is a microservices anyway? How do you deal with massively distributed applications? How can event storming fix the gap between your business problems and domain model?
In this workshop, you will take a kata from event storming through to an initial design stopping along the way to discuss:
With globally distributed applications (and teams!) the job of software architect isn’t getting any easier; applications are growing increasingly complex and architects are spread thin. You can’t be involved with every decision, you must empower your teams while ensuring they are making good choices. How do you do that? How can frameworks like Spring not only make your life easier but help your teams deliver robust applications to production? Spring Cloud has a veritable plethora of sub projects from circuit breakers to functions simplifying the task of building cloud native applications while making it easy for developers to adhere to best practices. At the same time it can be overwhelming to get your head wrapped around all the features Spring offers. This talk will show how Spring allows architects to focus on the critical design decisions they need to make while ensuring developers are empowered to implement critical business use cases. Today’s cloud native applications have similar pitfalls, luckily Spring is here to help you resolve them!
This talk will show how Spring allows architects to focus on the critical design decisions they need to make while ensuring developers are empowered to implement critical business use cases. Today’s cloud native applications have similar pitfalls, luckily Spring is here to help you resolve them!
As we migrate towards distributed applications, it is more than just our architectures that are changing, so too are the structures of our teams. The Inverse Conway Maneuver tells us small, autonomous teams are needed to produce small, autonomous services. Architects are spread thin and can’t be involved with every decision. Today, we must empower our teams but we need to ensure our teams are making good choices. How do we do that? How do you put together a cohesive architecture around distributed teams?
This talk will discuss creating “paved roads”, well worn paths that we know works and we can support. We will also explore the importance of fitness functions to help our teams adopt appropriate designs.
Rich Hickey once said programmers know the benefits of everything and the trade offs of nothing…an approach that can lead a project down a path of frustrated developers and unhappy customers. As architects though, we must consider the trade offs of every new library, language, pattern or approach and quickly make decisions often with incomplete information. How should we think about the inevitable technology choices we have to make on a project? How do we balance competing agendas? How do we keep our team happy and excited without chasing every new thing that someone finds on the inner webs?
As architects it is our responsibility to effectively guide our teams on the technology journey. In this talk I will outline the importance of trade offs, how we can analyze new technologies and how we can effectively capture the inevitable architectural decisions we will make. I will also explore the value of fitness functions as a way of ensuring the decisions we make are actually reflected in the code base.
Have you looked at the methods of CompletableFuture and wondered how to actually use them? Do the function names appears strange or at least different from what we're used to. Let's take another look so those names become easier to remember and also to make use of.
In this presentation we will take a practical look at CompletableFuture and how to make good use of it, and how to deal with exceptions.
Java introduced sealed classes. We've had enums over the years which gave us control over the members of the hierarchy but Sealed classes take those capabilities far and beyond. In this presentation we will take a deep dive into sealed classes, their capabilities, how to work with them, how they behave across packages and modules, and how they can help us model our applications.
We will take an example driven approach to get a good grasp of this nice feature that has strong influence on our design.
Threads are considered lightweight but that's quite relative and in some context it appears to be rather heavyweight. The blocking nature of threads makes it rather unsuitable for asynchronous programming. That's the reason Java is introducing Virtual Threads.
In this presentation we will discuss the deficiencies of the current Thread infrastructure and, using practical examples, see how the virtual threads provide a much better model for asynchronous programming.
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
We all are familiar with SOLID and other software design principles and have explored many design patterns. There is no better way to get a deeper understanding than to practice the concepts. Furthermore, some of the principles and patterns manifest themselves in what appear to be rather unconventional ways when applied under a set of constraints and requirements.
In this hands-on intensive workshop, we will take some problems and device elegant lightweight design, in code, and discuss the tradeoffs. Come experience the evolution of ideas into code and take shape by way of incremental development.
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
We all are familiar with SOLID and other software design principles and have explored many design patterns. There is no better way to get a deeper understanding than to practice the concepts. Furthermore, some of the principles and patterns manifest themselves in what appear to be rather unconventional ways when applied under a set of constraints and requirements.
In this hands-on intensive workshop, we will take some problems and device elegant lightweight design, in code, and discuss the tradeoffs. Come experience the evolution of ideas into code and take shape by way of incremental development.
Computer with git client to access git repository.
Java 8 or newer
Your favorite IDE
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.
If there is one thing guaranteed to be part of the micro-services story, networking and service stand out. Network management in a highly orchestrated world of networks, subnets and overlays increases the challenge. Add the topic of security and traffic management and the picture can be overwhelming.
This session will cover solutions to day 2 operations of networking a micro-service based cluster leveraging Istio, Jaeger and Kiali. Labs of specific solutions and on the fly network management will part of the presentation covering the following:
You will need for the labs:
If there is one thing guaranteed to be part of the micro-services story, networking and service stand out. Network management in a highly orchestrated world of networks, subnets and overlays increases the challenge. Add the topic of security and traffic management and the picture can be overwhelming.
This session will cover solutions to day 2 operations of networking a micro-service based cluster leveraging Istio, Jaeger and Kiali. Labs of specific solutions and on the fly network management will part of the presentation covering the following:
You will need for the labs:
If there is one thing guaranteed to be part of the micro-services story, networking and service stand out. Network management in a highly orchestrated world of networks, subnets and overlays increases the challenge. Add the topic of security and traffic management and the picture can be overwhelming.
This session will cover solutions to day 2 operations of networking a micro-service based cluster leveraging Istio, Jaeger and Kiali. Labs of specific solutions and on the fly network management will part of the presentation covering the following:
You will need for the labs:
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:
We build development teams based on individual ability to write code but development of a software project of any significance is beyond a single persons effort with a very particular set of skills. It requires a team of members with a number array of skills. It requires social skills. It requires tools and alignment. It requires shared contextual models.
This session will distill a couple decades of software consulting lessons learn in software engineering along with Ugandan fun to uncover the true way to developing more with less.
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
Performance is important. Tooling can be hard. Do flame charts and waterfalls intimidate you? Come learn how to use common performance tools such as Chrome DevTools, Lighthouse, and webpagetest.org. We'll profile several websites with different performance issues to illustrate how to use each tool.
In this talk, I'll live-profile several sites to help you see how to approach performance analysis. It's best if you already know how to use the Chrome Dev Tools inspector, but we will approach the performance tools from a beginner's starting point. Attendees should be comfortable with HTML at a minimum.
Help! My app bundle is 5MB! My users are angry that my app is so slow! It’s easy to forget that performance matters when we are under pressure to deliver features quickly. What data should we use to inform our decisions?
From code splitting, lazy loading, and tree shaking to bundle analysis, progressive rendering, and modern transpiling, come learn how you can deliver a better experience to your users with high-performing front-end apps. This talk is library-agnostic (React, Angular, Vue, etc.).
See the code repository link for a gist that includes slides, resources, and more: https://github.com/siakaramalegos/web-performance-long
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.
Mob Programming is a style of programming in which the entire team sits together and
works on a single task at a time. Teams that have worked this way have found that
many of the problems that plague normal development just melted away, possibly because communication and learning increases. Teams also find that the quality of their code increases. They find their capacity to create increases. However, the best part of all this is that teams end up being happier and more cohesive.
In this session we introduce the core concepts of mob programming and then get handson mobbing on a coding kata.
Integration, once a luxury, is now a necessity. Doing this well, however, continues to be elusive. Early attempts to build better distributed systems such as DCOM, CORBA, and SOAP were widely regarded as failures. Today the focus is on REST, RPC, and graphql style APIs.
Which is best? The goto answer for architects is, of course, “it depends.”
In this session, we look at the various API approaches, how they attempt to deal with the challenge of decoupling client from server, evolvability, extensibility, adaptability, composability.
The biggest challenge is that needs change over time, and APIs must necessarily evolve. Versioning is challenging, and breaking changes are inevitable. You'll leave this session with a highlevel understanding of these approach, their respective tradeoffs and ultimately how to align your API approach with your architectural and organizational goals.
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.
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!
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.
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.
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.
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.
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
Software metrics can be used effectively to judge the maintainability and architectural quality of a code base. Even more importantly, they can be used as canaries in a coal mine to warn early about dangerous accumulations of architectural and technical debt.
First we will introduce some key metrics that every architect should know (e.g., average component dependency, propagation cost, structural debt index, and more). Then we talks about the journey to create a metric to measure maintainability and introduces a new metric maintainability level. This metric is promising because its value usually matches quite well the gut feeling of developers about the maintainability of their software systems. Also covered is the use of free and commercial tools to gather metrics and follow their trends in an automated way.
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 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 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 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.
In this example-driven session, we'll use the Skill Flow Builder to create an interactive fiction game for Alexa from the ground up. We'll see how to manage the player's inventory of items, apply conditional effects, and add sounds and imagery to bring interactive fiction games to the voice-first generation.
“You are standing in a room with a table. On the table is black cylindrical device with the word 'Amazon' on the side. What do you want to do next?”
For as long as there have been computers, there have been computer games. Some of the earliest games were text-based adventure games like Colossal Cave Adventure and the Zork series. These games invited intrepid adventurers to use their imagination and wits to navigate complex worlds, solving puzzles to achieve the game's objective. Modern games are far more sophisticated than those early text adventures. Even so, there was still something amazingly endearing and fun about exploring caves and dungeons looking for treasure in games that were more like books where you are the main character.
Voice-enabled devices like Alexa are now breathing new life into the interactive fiction game genre. Rather than typing in your next move, you can speak it to Alexa; and she will describe the outcome to you, possibly with music and sound effects to set the mood. When played on a screen-based Alexa device, images can accompany the textual description for a richer immersion into the fictional world.
In this day-long work workshop, we will walk through a catalog of all the common architectural design patterns. For each design pattern, we will run docker-compose files that demonstrate the strengths and weaknesses of those design patterns. So you have a first-hand, full-on, and highly engaged full-day workshop to give you the knowledge you need to make critical architectural choices.
We will cover:
A GitHub Account
In this day-long work workshop, we will walk through a catalog of all the common architectural design patterns. For each design pattern, we will run docker-compose files that demonstrate the strengths and weaknesses of those design patterns. So you have a first-hand, full-on, and highly engaged full-day workshop to give you the knowledge you need to make critical architectural choices.
We will cover:
A GitHub Account
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.
Hopefully, we started moving on from Java 8. One of the great benefits of doing so, and there are many, is a module system. It is a controversial topic indeed, but I am hoping in this presentation to make some solid arguments that it is an essential part of our development.
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.
This presentation is the Dagobah of efficient editing and flow. Come only what you take with you.
Most efficient you will be, when keyboard tricks learned. You'll see. Hmmmm. You must unlearn what you have learned. A Jedi's power comes from knowledge of the tools used. Luminous beings are we… not crude typists. Mouse is your weakness. Learn to use more of the keyboard, you will.
Learn:
Hey. Remember that time when we used to create jar or war files and we used to just ssh into a box and deploy on a single box? Well, it was simpler but also maybe that wasn't that great of an idea. Time has certainly moved on, and our releases have become very advanced with very technical CI/CD pipelines, docker or debian packages, multi-purpose testing, producing signatures, perform security scans, perform releases, and then when you're done tell the whole world about it. Whew! This presentation introduces JReleaser, a release platform for Java that does a multitude of chores for you.
In this session we will discuss:
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.
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.
In this session, we’ll focus on a key paradigm shift on what to measure — rather than measuring the code itself, you’ll learn a technique for measuring the developers’ experience with the code, and how to build explicit risk models for project decision-making.
Since the dawn of software development, we've struggled with a huge disconnect between the management world and the engineering world. We try to explain our problems in terms of “technical debt”, but somehow the message seems to get lost in translation, and we drive our projects into the ground, over and over again.
What if we could detect the earliest indicators of a project going off the rails, and had data to convince management to take action? What if we could bridge this communication gap once and for all?
In this session, we’ll focus on a key paradigm shift on what to measure — rather than measuring the code itself, you’ll learn a technique for measuring the developers’ experience with the code, and how to build explicit risk models for project decision-making.
Are you an effective Angular developer? This presentation highlights the newest features of Angular and the impact they may have on your productivity and delivery of amazing solutions. Angular moves pretty fast - you may not need the feature now, however knowing it exists and what it can do is important. Did you miss or forget about a major feature? Each of the last 5 releases has some amazing capabilities, are you taking advantage of them?
We will review features released in each of the Angular versions going back to version 6. Why back to version 6? Version 6 contains one of the biggest game-changers in web development that provide new architectural and code reuse capabilities - you might have missed this one!. We will cover the features that affect application configuration, build, and testing. Including features to build custom and reusable components, libraries, and packages - even micro-applications.
This session provides guidance on creating and using custom code generators using the tools provided by Angular and Nx Dev Tools. If you are a fan of the Angular CLI or want to become more familiar with its capabilities this session is for you. The CLI and generators help your team to create consistent code using your own recipes and patterns.
The same engine that drives the Angular CLI can be used to create and run your custom code generators. These generators can create parts of or entire applications, libraries, services, components, and infrastructure code within a few seconds. The This session will demonstrate:
Learn how to implement cross cutting concerns for an Angular application starting with a configuration loader during application initialization. The presentation will discuss implementation practices for implementing, loading, configuring, and using cross-cutting concerns within an application.
The presentation will demonstrate the use of cross-cutting concerns using a monorepo (Angular Workspace) with custom libraries.
Learn strategies, concepts, and patterns to create and reuse these cross-cutting concerns in multiple applications.
CLEAN Code and CLEAN Architecture are not just great buzz-words! They contain principles and patterns that can save you time while allowing you to create amazing application architecture. You may have heard about layered architectures before, but have you wondered if it can be done with modern web technologies like Angular. These concepts were once reserved for backend applications - now modern web applications have these capabilities. Architecture is a concern for all developers and team members, not just architects. Let's take our Angular applications to the CLEANers.
Discover the principles and patterns of CLEAN Architecture. Learn what layered architecture is and what problems it solves. The presentation provides practical guidance and exploration of different layered architecture approaches. It will focus on the tools and capabilities we have with the Angular platform, TypeScript, and with Visual Studio Code. You will learn about using Single Responsibility and Separation of Concerns and how they relate to boundaries between layers. Higher quality business logic and testability is a must for complex enterprise applications. Learn how testability is a key focus for CLEAN architectures.
During this session, we will cover how to apply CLEAN and SOLID principles to Angular applications to simplify your application code base and maximize your code sharing and reuse. A reference application will also demonstrate a reactive design approach using the powers of RxJS.
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.
In this session we will build a full application using Vue.js. We will start by discussing how you can start working with Vue, all the way to seeing what it takes to build an app with Vue, including state management and routing.
Note: We'll be covering Vue version 3
Vue.js, the new kid on the JavaScript framework block is taking the world by storm. Vue has bypassed React in their count of Github stars, alluding to how popular this framework is starting to become. Vue attempts to provide just enough support with libraries like Vuex and the Vue Router, and tooling like the Vue CLI to get developers productive, without aiming to be too opinionated, and too flexible.
If you are curious about Vue, this is the session for you. Come in for 180 minutes of a thrill ride as we explore this fascinating new framework and mindset.
Note: We'll be covering Vue version 3
In this session we will build a full application using Vue.js. We will start by discussing how you can start working with Vue, all the way to seeing what it takes to build an app with Vue, including state management and routing.
Note: We'll be covering Vue version 3
Vue.js, the new kid on the JavaScript framework block is taking the world by storm. Vue has bypassed React in their count of Github stars, alluding to how popular this framework is starting to become. Vue attempts to provide just enough support with libraries like Vuex and the Vue Router, and tooling like the Vue CLI to get developers productive, without aiming to be too opinionated, and too flexible.
If you are curious about Vue, this is the session for you. Come in for 180 minutes of a thrill ride as we explore this fascinating new framework and mindset.
Note: We'll be covering Vue version 3
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.
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.
We will be using AWS as our playground for this workshop
Agenda
apply-ing terraformdata and output in your terraform scriptsInstructions
Please visit https://github.com/looselytyped/terraform-workshop/ for detailed instructions. They might seem a tad arduous but it's not as bad as it looks :)
Please visit https://github.com/looselytyped/terraform-workshop/ for detailed instructions. They might seem a tad arduous but it's not as bad as it looks :)
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.
We will be using AWS as our playground for this workshop
Agenda
apply-ing terraformdata and output in your terraform scriptsInstructions
Please visit https://github.com/looselytyped/terraform-workshop/ for detailed instructions. They might seem a tad arduous but it's not as bad as it looks :)
Please visit https://github.com/looselytyped/terraform-workshop/ for detailed instructions. They might seem a tad arduous but it's not as bad as it looks :)
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.
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.
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.
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.
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.
Everywhere you look, security breeches, phishing attacks and ransomware attacks are in the news and should be in the forefront of every technical leader's top 10 concerns. An effective strategy to combat such attacks and vulnerabilities begins with a zero-trust inspired authentication strategy, application architecture and deployment infrastructure.
Join us for an in depth analysis of the current options and best practices around implementing zero-trust compliant, modern authentication architectures and systems.
Everywhere you look, security breeches, phishing attacks and ransomware attacks are in the news and should be in the forefront of every technical leader's top 10 concerns. An effective strategy to combat such attacks and vulnerabilities begins with a zero-trust inspired authentication strategy.
Join us for an in depth analysis of the current options and best practices around implementing zero-trust compliant, modern authentication, architectures and systems.
Zero Trust Security and Authentication is on most CISOs, CTOs and architects top 10 'must do' lists and for good cause! Everywhere you read about bad actors, phishing and ransomware attacks with ever increasing frequency. Join us to learn how to implement one of the safest, most hacker-proof means of authenticating your users available today: Hardware-based authenticators!
Hardware based authenticators include security keys as well as device-resident bio-authenticators such as TouchId and Windows Hello. In this presentation, we will explore these devices, how they are accessed, managed and used to provide virtually hacker-proof authentication in modern web applications. We will discuss the current industry standards and specs which govern these devices and their use including FIDO and WebAuthn.
Many of our apps allow users to upload files which then become available for some users to (re)download. Viruses and malware could tailgate these files into your system and infect your users! Join us to learn how to avoid this potential fatal mistake!
Malware and virus-based attacks are on the rise. We have all seen the news stories all around us. How do you easily prevent damage to your corporate reputation and potentially devistating damage to your users from such threats?
Join us for an in-depth discussion and exploration of an effective architecture which detects, isolates and prevents downloading of infected uploaded files. We will also discuss other practical limits you should place on file uploads to avoid performance and UX issues.
What if we could achieve completely ‘contactless’ software security scanning? As the lines between physical and digital security become blurrier and blurrier, software quality standards and testing methodologies must continue to keep pace. Software fuzzing has long been a trusted method for finding vulnerabilities that are difficult to discover using traditional methods.
The application of AI and ML to this field has already begun to bear very promising results. By leveraging deep learning techniques to improve our input corpus and better understand our program's states, we can shine areas on the code logic that would be hidden by approaches like vulnerability scanning and static code analysis, and even traditional software fuzzing.
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!
Containers are all the rage these days – from Docker to Kubernetes and everywhere in-between. But to get the most out of them it can be helpful to understand how containers are constructed, how they depend and interact with the operating system, and what the differences and interactions are between layers, images, and containers. Join R&D Director, Brent Laster as he does a quick, visual overview of how containers work and how applications such as Docker work with them.
Topics to be discussed include:
• What containers are and the benefits they provide
• How containers are constructed
• The differences between layers, images, and containers
• What does immutability really mean
• The core Linux functionalities that containers are based on
• How containers reuse code
• The differences between containers and VMs
• What Docker really does
• The Open Container Initiative
• A good analogy for understanding all of this
What you will learn:
Kubernetes has won the war when it comes to running and managing containerized workloads. It is essentially the operating system for containers. But beyond Kubernetes itself, there are a large set of community applications and tools that can greatly extend its value and integrate directly with it.
In this full-day workshop, author, trainer, and DevOps leader Brent Laster will provide you with an introduction AND hands-on experience with these various applications and tools. You'll learn not only what they are and how they interact with Kubernetes but get to experience actually using them to accomplish a task.
We'll cover orchestration with Helm & Kustomize, service meshes with Istio, CI/CD pipelines with Tekton, GitOps with ArgoCD and, if time allows - creating and managing Custom Resources in Kubernetes with the Operator pattern.
The planned workshop outline follows (subject to change).
Class outline
Part 1: Introduction and brief refresher/level-set on core concepts in Kubernetes. Agenda for class and quick overview of technologies.
Part 2: What is Helm? Basic concepts and function. Helm charts.
Lab 1: Working with Helm - in this lab, we'll compare a Helm chart against standard Kubernetes manifests and then deploy the Helm chart into Kubernetes
Part 3: Using custom values and functions in Helm charts
Lab 2: Templating with Helm - in this lab, we'll see how to change hard-coded values into templates, override values, and upgrade releases through Helm
Part 4: What is Kustomize? Basic concepts and function. How does Kustomize differ from Helm?
Lab 3: Run a basic Kustomize example - in this lab, we'll see how to make a set of manifests usable with Kustomize to add additional changes without modifying the original files
Part 5: Working with variants, overlays, and bases to create different versions of K8s manifests
Lab 4 - Creating Variants - in this lab, we'll see how to create production and stage variants of our simple application
Part 6: Service mesh leveraging Istio - what is it? How does it work? When should you use it?
Lab 5: Working with Istio - in this lab, we'll look at Istio and see how we can leverage some of its functionality with the sidecar containerss to do traffic-shifting, fault injection and more.
Part 7: CD with Tekton - defining Tasks as building blocks. What is Tekton and what are the advantages and disadvantages of it?
Lab 6: Working with Tekton Tasks - in this lab, we'll see how to run and use a basic Tekton Task.
Part 8: CICD with Tekton Pipelines - explaining how tasks are combined in Pipelines and how those can be used for CD
Lab 7: Creating Tekton Pipelines - in this lab, we'll see how to create a Tekton Pipeline to orchestrate our tasks and run them together.
Part 9: What is GitOps? How and why is it used? Intro to ArgoCD.
Lab 8: Getting Started with Argo CD.
Part 10: How to manage Custom Resources in Kubernetes with Operators. What is a custom resource, a custom resource definition, a control loop, and an operator? When do you need/use custom resources and operators?
Lab 9: Kubernetes Operators - in this lab, we'll get to install and work with a simple Kubernetes operator.
Thank you for signing up for the Beyond Kubernetes workshop. We're excited that you'll be joining us and want to help you get the most out of your session. With that in mind, please read through the preparation steps below and in the referenced docs to ensure you are ready to go on the day of the session. ( You MUST have one of the environments - the pre-configured VM or the user-supplied option setup and ready to go prior to the workshop.)
The WIFI setup at the conference location will NOT allow you to do all the prep at that location, so you need to ensure that if you are attending at the location, the setup of the environment is done prior to your arrival where you can download large images and come to the workshop without needing to do that.
This workshop is a combination of lecture and hands-on labs. It assumes you have a basic working knowledge of Kubernetes. (There will not be an opportunity to provide substantial foundational Kubernetes knowledge given the time constraints.)
To do the labs, you will need a modern laptop to use during the workshop. Since the workshop will be all day, you should make sure to bring your charger.
In advance of the workshop, you should ensure that your laptop is setup to use one of the environments below - either the virtual machine image with VirtualBox or an environment that you configure yourself with Docker, Kubernetes, Helm, Tekton, ArgoCD and Istio as outlined.
TO-DO:
To setup the pre-configured environment with the virtual machine and VirtualBox, follow the instructions in https://github.com/skilldocs/beyond-k8s/blob/main/beyond-k8s-setup-vm-environment-option.pdf
Or to setup the user-supplied environment with your own cluster, follow the instructions at https://github.com/skilldocs/beyond-k8s/blob/main/beyond-k8s-setup-user-supplied-environment-option.pdf
Real-world applications nowadays are designed using both art and science. What is the process of coming up with a solution which works, scales, and is resilient?
What is it challenging to design a system for disruptive technologies?
System design is unstructured, and there are many ways to solve problems.
Gaining experience in new applications and technologies
Best practices change with time. The best way ten years ago can quickly become an anti-pattern.
In this talk, we will explore step by step guide to approach System design using real-world applications.
Come prepared to design a system for following applications interactively.
We will gain more knowledge with collective experience and best practices.
UBER System Design
NETFLIX System Design
INSTAGRAM System Design
YELP System Design
TWITTER System Design
Search Engines
Auto Suggestions / Recommendations System Design
Fraud Detection System Design
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
Real-world applications nowadays are designed using both art and science. What is the process of coming up with a solution which works, scales, and is resilient?
What is it challenging to design a system for disruptive technologies?
System design is unstructured, and there are many ways to solve problems.
Gaining experience in new applications and technologies
Best practices change with time. The best way ten years ago can quickly become an anti-pattern.
In this talk, we will explore step by step guide to approach System design using real-world applications.
Come prepared to design a system for following applications interactively.
We will gain more knowledge with collective experience and best practices.
UBER System Design
NETFLIX System Design
INSTAGRAM System Design
YELP System Design
TWITTER System Design
Search Engines
Auto Suggestions / Recommendations System Design
Fraud Detection System Design
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
We are all familiar with the 3rd Normal form. Does that scale? What are the best practices for designing resilient, multi-tenant, performant databases? In this talk, we will explore the database evaluation process, where we will make choices on technology stacks based on requirements and analyzing the CAP theorem. We will discover different Consistency, Availability, and Partition Tolerance techniques, investigate No-SQL databases, and help new cloud deployments using the 3rd Platform.
Big data has characteristics in the new Cloud domain, which requires storing various data for different use-cases. We will explore the Document data store, Key-value, Columnar NoSQL, Graph NoSQL and NewSQL databases.
Next, we will look at how to do data modeling for NoSQL columnar databases to support highly available partition tolerant use-cases. We will discover different strategies to help multi-tenant requirements. In the end, we will look at how to choose the right database? We will also see what the future of Databases are comparing based on Consistency Models, Schema Models, Database Languages, and Database storage.
We will look at data quality patterns and issues and how to use MDM strategy to fix these issues. We will explore survivor ship records and how to validate if the data is correct in system. In the end we will also look at GDPR and PII data strategies.
We will be exploring following databases types:
Key-value stores
Wide column stores
Document stores
Time Series DBMS
Graph DBMS
Object oriented DBMS
Search engines
RDF stores
Spatial DBMS
Event Stores
Content stores
A few of the technologies we will explore are
Cassandra
Amazon DynamoDB
MongoDB, HBase
REDIS, MemcacheDB,
RDF / SPARQL
Graph Databases, Neo4J
CockroachDB
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
We are all familiar with the 3rd Normal form. Does that scale? What are the best practices for designing resilient, multi-tenant, performant databases? In this talk, we will explore the database evaluation process, where we will make choices on technology stacks based on requirements and analyzing the CAP theorem. We will discover different Consistency, Availability, and Partition Tolerance techniques, investigate No-SQL databases, and help new cloud deployments using the 3rd Platform.
Big data has characteristics in the new Cloud domain, which requires storing various data for different use-cases. We will explore the Document data store, Key-value, Columnar NoSQL, Graph NoSQL and NewSQL databases.
Next, we will look at how to do data modeling for NoSQL columnar databases to support highly available partition tolerant use-cases. We will discover different strategies to help multi-tenant requirements. In the end, we will look at how to choose the right database? We will also see what the future of Databases are comparing based on Consistency Models, Schema Models, Database Languages, and Database storage.
We will look at data quality patterns and issues and how to use MDM strategy to fix these issues. We will explore survivor ship records and how to validate if the data is correct in system. In the end we will also look at GDPR and PII data strategies.
We will be exploring following databases types:
Key-value stores
Wide column stores
Document stores
Time Series DBMS
Graph DBMS
Object oriented DBMS
Search engines
RDF stores
Spatial DBMS
Event Stores
Content stores
A few of the technologies we will explore are
Cassandra
Amazon DynamoDB
MongoDB, HBase
REDIS, MemcacheDB,
RDF / SPARQL
Graph Databases, Neo4J
CockroachDB
This talk is ideal for the following roles:
Architects
Technical Leads
Programers
Integration Architects
Solution Architects
As a software architect, you're at the forefront of building scalable, secure, and resilient systems that drive innovation while safeguarding critical digital assets. This workshop is designed to equip you with actionable strategies, cutting-edge tools, and deep technical insights into embedding security into every phase of the software development lifecycle.
In this immersive, hands-on session, we will explore how to elevate your DevSecOps practices to meet the challenges of today’s evolving threat landscape while ensuring productivity and operational excellence.
What You'll Learn:
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.
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.
What you will learn
In this half-day workshop, open-source author, trainer and DevOps director Brent Laster will provide a solid introduction to GitHub Actions. You’ll learn about the core parts and pieces that make up an action, as well as the types of functionality and features they provide. You’ll also see how to combine them in simple workflows to accomplish basic tasks as well as how they can fit into a CI/CD environment. And you’ll learn about how to create and self-host your own actions.
This course will leverage hands-on, guided labs using GitHub and GitHub Actions so that participants can gain “real-world” experience with GitHub Actions.
Draft course outline (subject to change)
Section 1: A quick intro to GitHub Actions
Content: In this section, we’ll cover the basics of GitHub actions – what are they and why would we use them? We’ll cover what “event driven” means and what events, jobs, actions, steps, runners and workflows are. And we’ll see how they all related to each other and work together. We’ll see how to create and store a GitHub action. Finally, we’ll look at how to create a simple action.
Lab 1: Creating a simple example – In this lab, we’ll get a quick start learning about GitHub Actions by creating a simple project that uses them.
We'll also see what a first run of a workflow with actions looks like. this lab, attendees will create and use a basic GitHub Action
Section 2: Taking actions further
Content: In this section, we’ll cover how to find GitHub actions that might be of interest. We’ll look at how to share and version actions. And we’ll see how to use additional features with actions.
Lab 2: Learning more about Actions – In this lab, we'll see how to get more information about Actions and how to update our workflow to use others. We'll also see how to add jobs and commit changes through the browser interface.
Section 3: Working with your own action
Content: For this section, we’ll look at how to create and then use your own custom action
Lab 3: Adding your own action - in this lab, we'll see how to create and use a custom GitHub Action
Section 4: Looking at action logs and getting details
Content: For this section, we’ll dive into the logs produced for GitHub actions to understand what's really happening on the runner systems and also look at how to add some simple markup to add a status badge on your project.
Lab 4: Exploring logs - in this lab, we'll take a closer look at the different options for getting information from logs.
Section 5: Getting debug info
Content: In this section, we’ll cover how to get debug information when running through actions and workflows.
Lab 5: Looking at debug info - in this lab, we'll look at some ways to get more debugging info from our workflows
Part 6: Working with advanced workflows
Content: In this section, we'll look at various examples of advanced workflows including chaining workflows, using conditionals, and working with REST APIs to drive other events in GitHub.
Lab 6: Chaining workflows, using conditionals, and working with REST APIs in workflows.
Attendees will need the following to be successful in the course and labs:
What you will learn
In this half-day workshop, open-source author, trainer and DevOps director Brent Laster will provide a solid introduction to GitHub Actions. You’ll learn about the core parts and pieces that make up an action, as well as the types of functionality and features they provide. You’ll also see how to combine them in simple workflows to accomplish basic tasks as well as how they can fit into a CI/CD environment. And you’ll learn about how to create and self-host your own actions.
This course will leverage hands-on, guided labs using GitHub and GitHub Actions so that participants can gain “real-world” experience with GitHub Actions.
Draft course outline (subject to change)
Section 1: A quick intro to GitHub Actions
Content: In this section, we’ll cover the basics of GitHub actions – what are they and why would we use them? We’ll cover what “event driven” means and what events, jobs, actions, steps, runners and workflows are. And we’ll see how they all related to each other and work together. We’ll see how to create and store a GitHub action. Finally, we’ll look at how to create a simple action.
Lab 1: Creating a simple example – In this lab, we’ll get a quick start learning about GitHub Actions by creating a simple project that uses them.
We'll also see what a first run of a workflow with actions looks like. this lab, attendees will create and use a basic GitHub Action
Section 2: Taking actions further
Content: In this section, we’ll cover how to find GitHub actions that might be of interest. We’ll look at how to share and version actions. And we’ll see how to use additional features with actions.
Lab 2: Learning more about Actions – In this lab, we'll see how to get more information about Actions and how to update our workflow to use others. We'll also see how to add jobs and commit changes through the browser interface.
Section 3: Working with your own action
Content: For this section, we’ll look at how to create and then use your own custom action
Lab 3: Adding your own action - in this lab, we'll see how to create and use a custom GitHub Action
Section 4: Looking at action logs and getting details
Content: For this section, we’ll dive into the logs produced for GitHub actions to understand what's really happening on the runner systems and also look at how to add some simple markup to add a status badge on your project.
Lab 4: Exploring logs - in this lab, we'll take a closer look at the different options for getting information from logs.
Section 5: Getting debug info
Content: In this section, we’ll cover how to get debug information when running through actions and workflows.
Lab 5: Looking at debug info - in this lab, we'll look at some ways to get more debugging info from our workflows
Part 6: Working with advanced workflows
Content: In this section, we'll look at various examples of advanced workflows including chaining workflows, using conditionals, and working with REST APIs to drive other events in GitHub.
Lab 6: Chaining workflows, using conditionals, and working with REST APIs in workflows.
Attendees will need the following to be successful in the course and labs:
Knowledge graphs are a rapidly emerging concept for machine-processable models of complex and dynamic domains. They represent the intersection of Web architecture and information. 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.
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.
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 concept of doing machine learning in JavaScript in the browser seems ludicrous at first blush. The reality is, however, it makes all the sense in the world. The question is how to do so performantly.
We will introduce you to a variety of use cases of why this makes sense and how Google has managed to make it a reality through a combination of WebGL, WebAssembly, CUDA, and more.
We will cover:
The concept of doing machine learning in JavaScript in the browser seems ludicrous at first blush. The reality is, however, it makes all the sense in the world. The question is how to do so performantly.
We will introduce you to a variety of use cases of why this makes sense and how Google has managed to make it a reality through a combination of WebGL, WebAssembly, CUDA, and more.
We will cover:
There is no question JavaScript has become one of the most popular and widely-used programming languages. Unfortunately popularity doesn't necessarily translate to easy-to-maintain or always appropriate. Large code bases become difficult to reason over due to JavaScript's dynamic nature and flexible development style.
As a result of their own internal struggles with large JavaScript projects, Microsoft tasked Anders Hejlsberg of Delphi and C# fame to design a solution to the problem. The result is an incredibly useful, fun and effective approach to improving JavaScript development without impacting how you deploy your projects.
TypeScript is a superset of JavaScript that brings static typing, modern JavaScript features that may not yet be supported in your environment and improved tooling and documentation. Surprisingly, the results are then transpiled down to whatever flavor of JavaScript you need for your runtime environment.
In this workshop, we will introduce to you:
There is no question JavaScript has become one of the most popular and widely-used programming languages. Unfortunately popularity doesn't necessarily translate to easy-to-maintain or always appropriate. Large code bases become difficult to reason over due to JavaScript's dynamic nature and flexible development style.
As a result of their own internal struggles with large JavaScript projects, Microsoft tasked Anders Hejlsberg of Delphi and C# fame to design a solution to the problem. The result is an incredibly useful, fun and effective approach to improving JavaScript development without impacting how you deploy your projects.
TypeScript is a superset of JavaScript that brings static typing, modern JavaScript features that may not yet be supported in your environment and improved tooling and documentation. Surprisingly, the results are then transpiled down to whatever flavor of JavaScript you need for your runtime environment.
In this workshop, we will introduce to you:
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.
Java 17 has come and gone, but development on Java continues on! What has changed since Java 11? And what changes are being added in Java 18 and Beyond? Come find out!
In this presentation, we will look at some of the key changes that have been added to Java post-8. The large changes; the Module System and Records, quality of life improvements; var, text blocks, pattern matching, and the many performance and runtime improvements. We will finish the presentation with a brief look ahead to some of the changes that will be coming to Java in the near future and why Java’s future is bright.
JDK Flight Recorder, like its namesake, the flight recorder in an airplane, can be an excellent tool for collecting information on a Java application as it is running and when problems occur.
In this presentation, we will get an intro on how to use JDK flight recorder to collect information about our Java applications, interpret the results, and how to use the information to improve our applications!
Sharing code and internal libraries across your distributed microservice ecosystem feels like a recipe for disaster! After all, you have always been told and likely witnessed how this type of coupling can add a lot of friction to a world that is built for high velocity. But I'm also willing to bet you have experienced the opposite side effects of dealing with dozens of services that have had the same chunks of code copied and pasted over and over again, and now you need to make a standardized, simple header change to all services across your platform; talk about tedious, frictional, errorprone work that you probably will not do! Using a variety of codesharing processes and techniques like inner sourcing, module design, automated updates, and service templates, reusing code in your organization can be built as an asset rather than a liability.
In this talk, we will explore the architectural myth in microservices that you should NEVER share any code and explore the dos and don'ts of the types of reuse that you want to achieve through appropriate coupling. We will examine effective reuse patterns, including what a Service Template architecture looks like, while also spending time on the lifecycle of shared code and practically rolling it out to your services. We will finish it off with some considerations and struggles you are likely to run into introducing code reuse patterns into the enterprise.
Modern HTTP APIs power today’s connected world, acting as the core interface not only for developers, but also for the ever-growing ecosystem of machines, services, and now AI agents. As every organization is increasingly expected to produce and consume APIs at scale, the ability to design, build, deploy, and operate consistent, high-quality APIs has become a key competitive differentiator. With AI accelerating the need for composable, well-structured, and discoverable interfaces, API maturity is no longer optional—it’s essential. However, building and scaling effective API Design First practices across an enterprise is still fraught with manual processes, inconsistent standards, and slow governance models. To succeed, organizations must reimagine API Governance as a strategic enabler—one that prioritizes collaboration, stewardship, and automation.
In this session, we’ll explore the core stages of the API design lifecycle and share how to implement practical, modern governance models that increase productivity without sacrificing control. Drawing on real-world examples from SPS Commerce, as well as off-the-shelf tooling and custom solutions, we’ll show how to align your teams, accelerate delivery, and produce APIs that are robust, reusable, and ready for both human and AI consumers.
A lot of development teams have built out fully automated CI/CD pipelines to deliver code to production fast! Then you quickly discover that the new bottleneck in delivering features is their existence in longlived feature branches and no true CI is actually happening. This problem compounds as you start spinning up microservices and building features across your multirepo architecture and coordinating some ultrafancy release schedule so it all deploys together. Feature flags provide you the mechanism to reclaim control of the release of your features and get back to shortlived branches with true CI. However, what you're not told about feature flags in those simple “if/else” getting started demos is that there is an upfront cost to your development time, additional complexities, and some pitfalls to be careful of as you begin expanding feature flag usage to the organization. If you know how to navigate these complexities you will start to unleash true velocity across your teams.
In this talk, we'll get started with some of the feature flagging basics before quickly moving into some practical feature flagging examples that demonstrate its usage beyond the basic scenarios as we talk about UI, API, operations, migrations, and experimentation. We will explore some of the hard questions around “architecting feature flags” for your organization.
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!
The JVM can perform some marvelous feats of optimization but for most developers, its inner workings remain a mystery.
In this talk, we'll walk through how the JVM optimizes a seemingly simple piece of Java code. Starting with how the JVM decides what to compile and then going step-by-step through the different optimizations that are performed. In doing so, you'll learn how the JVM makes your code run fast, but also some things to avoid to keep it running fast.
Thankfully, Java garbage collectors have come a long way in the last 25 years. While the latest GCs: G1 and ZGC usually just work, their inner workings can be harder to understand the GCs that came before.
In this presentation, you'll learn basic garbage collection strategies used by the JVM starting with older collectors and following through the evolution to the modern GCs that we enjoy today.
While we know that different programming languages are good at different things and perform differently, it would be tempting to conclude that optimizations that work in one language work just as well in another. Unfortunately, that's not true.
In this talk, we'll learn about the different ways that language runtimes work from interpreters to just-in-compilers from JavaScript to Python to Java. We'll explore the strengths and weaknesses of each approach and how to make the most of them.
Our modern JVMs and CPUs are capable of some amazing feats of optimization. In general, for day-to-day work, these optimizations just work, but they also mean that the optimal approach can be surprisingly unintuitive.
In this presentation, we'll examine some surprising performance anomalies. Through learning the mechanisms behind these performance paradoxes, you'll gain insight into how modern compilers and hardware work.
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
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
A barrage of software philosophies have hit the industry over the last few years, all claiming to reduce friction in digital transformation. But what does that mean organizationally and where does open source play into all of this?
We'll talk about the roots of DevOps in the Theory of Constraints, how 12-Factor principles can guide your microservice and cloud migration refactor efforts, and how building an optimal strategy for the use of open source within your organization can tie all of these concepts together.
You’ve taken your first steps into Node.js. You’ve learned how to initialize your projects, you’ve played with some dependencies, and you’re ready to get into some serious Node work.
In this session, we’ll dive further into Node as a framework. We’ll learn how to master Node’s inherently asynchronous nature, take advantage of Node’s events and streams capabilities, and learn about sophisticated Node deployments at scale. Participants will leave with a richer understanding of what Node has to offer and higher confidence in dealing with some of Node’s more difficult concepts.
You’ve taken your first steps into Node.js. You’ve learned how to initialize your projects, you’ve played with some dependencies, and you’re ready to get into some serious Node work.
In this session, we’ll dive further into Node as a framework. We’ll learn how to master Node’s inherently asynchronous nature, take advantage of Node’s events and streams capabilities, and learn about sophisticated Node deployments at scale. Participants will leave with a richer understanding of what Node has to offer and higher confidence in dealing with some of Node’s more difficult concepts.
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.
In this day-long work workshop, we will walk through a catalog of all the common architectural design patterns. For each design pattern, we will run docker-compose files that demonstrate the strengths and weaknesses of those design patterns. So you have a first-hand, full-on, and highly engaged full-day workshop to give you the knowledge you need to make critical architectural choices.
We will cover:
A GitHub Account
In this day-long work workshop, we will walk through a catalog of all the common architectural design patterns. For each design pattern, we will run docker-compose files that demonstrate the strengths and weaknesses of those design patterns. So you have a first-hand, full-on, and highly engaged full-day workshop to give you the knowledge you need to make critical architectural choices.
We will cover:
A GitHub Account
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
When things get a little bit cheaper, we buy a little bit more of them. When things get cheaper by several orders of magnitude, you don't just see changes in the margins, but fundamental transformations in entire ecosystems. Apache Pinot is a driver of this kind of transformation in the world of real-time analytics.
Pinot is a real-time, distributed, user-facing analytics database. The rich set of indexing strategies makes it a perfect fit for running highly concurrent queries on multi-dimensional data, often with millisecond latency. It has out-of-the box integration with Apache Kafka, S3, Presto, HDFS, and more. And it's so much faster on typical analytics workloads that it is not just a marginally better data warehouse, but the cornerstone of the next revolution in analytics: systems that expose data not just to internal decision makers, but to customers using the system itself. Pinot helps expand the definition of a “decision-maker” not just down the org chart, but out of the organization to everyone who uses the system.
In this talk, you'll learn how Pinot is put together and why it performs the way it does. You'll leave knowing its architecture, how to query it, and why it's a critical infrastructure component in the modern data stack. This is a technology you're likely to need soon, so come to this talk for a jumpstart.
Have you ever stopped to think about how to build a database? The thing is, there isn't just one way, as we can see by the massive number of data infrastructure options we have to choose from. It's a nonstop series of tradeoffs, each motivated by the constraints the database wants to satisfy. An in-memory transactional database would be one thing. A general-purpose, single-server relational database would be another. A low-latency, horizontally scalable analytics database would be…the journey we're going to take.
In this talk, we'll start by picking a data model, make decisions about serialization and storage, choose indexing strategies, pick a query language, and figure out how to scale, eventually ending up with something that looks remarkably like Apache Pinot, a real-time analytics database. Pinot was built on a journey like this, always optimized for ultra low-latency, user-facing analytics at scale. In the real world, Pinot is used by applications like LinkedIn and UberEats to expose the state of the system not just to internal decision-makers, but to the users of the system itself, including all of us people who consumers of analytical queries. By focusing on the internals of Pinot and the tradeoffs made along the way to build a database of its kind, we'll see how it enables a new class of applications that every user of a system into a decision maker.
Event-driven architectures are not new, but they are newly ascendant. For the first time since the client-server revolution of 40 years ago, a new architectural paradigm is changing the way we build systems. Apache Kafka and microservices are at the center of this movement.
In this workshop, we’ll discuss the issues that arise turning a monolith into a set of reactive services, including issues like data contracts, integrating with the systems you can't change, handling request-response interfaces, and more. We'll also discuss common infrastructure choices like Apache Flink and Apache Pinot. Hands-on exercises will focus on understanding your organization's data and forming a plan to refactor that monolith that seems like it will never go away.
I'm looking forward to having you in the Event-Driven Architecture Workshop! To get the best use of our time together, the in-person exercises will focus on understanding the systems you're currently using at work and planning their refactoring to microservices. You should bring a laptop, a pen, and energy for the day!
Alistair Cockburn has described software development as a game in which we choose among three moves: invent, decide, and communicate. Most of our time at No Fluff is spent learning how to be better at inventing. Beyond that, we understand the importance of good communication, and take steps to improve in that capacity. Rarely, however, do we acknowledge the role of decision making in the life of software teams, what can cause it to go wrong, and how to improve it.
In this talk, we will explore decision making pathologies and their remedies in individual, team, and organizational dimensions. We'll consider how our own cognitive limitations can lead us to to make bad decisions as individuals, and what we might do to compensate for those personal weaknesses. We'll learn how a team can fall into decisionmaking dysfunction, and what techniques a leader might employ to healthy functioning to an afflicted group. We'll also look at how organizational structure and culture can discourage quality decision making, and what leaders to swim against the tide.
Software teams spend a great deal of time making decisions that place enormous amounts of capital on the line. Team members and leaders owe it to themselves to learn how to make them well.
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.
It’s all about productivity – or maybe it’s all about delivering value. Or is it creating secure applications and dealing with changing directions? Whatever it is we often feel that we’re lacking - it’s hard enough to be any sort of developer, let alone a mythical 10x!
In this keynote, we’re going to examine how to think more clearly about being a developer, help you understand the tools and approaches that can offer practical insight into how you work now, and provide guidance on alternatives that just might give you the powered armor you need. A mix of tools, proven processes, new techniques, and lessons learned the hard way make up a keynote designed to help you understand that being a 10x developer isn’t about having super powers - it’s about using the powers you already have in wiser, more considered ways.
Over the last decade, DevOps has emerged as an influential business philosophy and practice, helping businesses drive high quality software to market faster. DevOps focuses on the elimination of bottlenecks that occur when development and operational resources are too divorced from one another. But what about friction in the development and test process? What about the delayed feedback cycles that come from slow builds and test flakiness? How can we reduce friction in areas that are outside of the focus of DevOps? The presentation will include examples of DPE practices in action from Java projects using the Maven or Gradle build tool.
Attendees will walk away from this presentation with a better understanding of:
Please follow the workshop requirements here:
https://nfjs.nyc3.cdn.digitaloceanspaces.com/static/pdf/DPE_Workshop_Prerequisites.pdf
How do we move information realtime and connect machine learning models to make decisions on our business data? This presentation goes through machine learning and Kafka tools that would help achieve that goal.
In this presentation, we start with Kafka as our data backplane and how we get information to our pub/sub. As they enter Kafka, how do we sample that data and train our model, then how do we unleash that model on our real-time data? In other words, picture extracting samples for credit card approvals for training, then attaching the model for online processing: The moment we receive an application, we can either approve or disapprove a credit application based on a machine learning model trained on historical data. We will discuss other options as well like Spark, H2O, and more.
Property-based testing (PBT) validates the expected behavior of a system by checking it against a range of data points. A well-chosen set of properties will give the user a lot of confidence that the system is behaving as expected. The idea is that when the code is modified, failures in the tests reveal problems that would not have been found otherwise. This talk will cover the basic principles and several examples of PBT, using the jqwik library.
PBT allows you to define invariants (like reversing a list twice should result in the original list) and verify that they hold given generated changes that include a wide range of random inputs, including edge and corner cases. The jqwik library works well with JUnit to provide an important part of your testing strategy.