Cloud Integrations & Data Architecture for Enterprise Apps

In Cloud Integrations and Data Architecture talk, we will examine secure, scalable integrations on Enterprise applications. Through various scenarios, we will explore designing and implementing intricate integration patterns on multiple platforms. We will review how to communicate the solution and design trade-offs to business and technical people.

Kubernetes for Developers - 1 Day Deep Dive

Kubernetes is a rich infrastructure that helps you tackle the complexities of distributed computing. As a developer, you want to understand how you can architect your code to take advantage of the whole data center for your scaling, load-balanced, and resilient microservices.

This course is for software engineers (architects, developers, DevOps, administrators, testers) who want to move their solutions to microservices and containers running on cloud native, distributed container platforms. This introduction course covers the key techniques to automate, deploy, and manage containerized applications on Kubernetes.

Resilient Cloud Architecture Design Patterns

Resilient architecture is fundamental when working in distributed, cloud-based systems. Designing and architecting large-scale applications managing millions of requests brings unique challenges with availability, performance, and integration. You will need to make difficult choices and evaluate tradeoffs. Luckily, you can use different architecture patterns to make a distributed application more resilient. Based on evolutionary architecture, this approach enables you to create systems designed to evolve with the ever-changing software development ecosystem. Resilient architecture patterns will allow you to create systems that continue functioning even when components fail.  

Join expert Rohit Bhardwaj to learn how to implement an evolutionary architecture approach and understand resilient architecture patterns. This training will explore architecture decisions you may need to make when evaluating your architecture to improve performance and resiliency. For example, you will no longer struggle to handle millions of requests per second or face issues when routing traffic.
What you'll learn — and how you can apply it

By the end of this live, hands-on, online course, you'll understand the following:
How to create responsive, maintainable, extensible architecture from resilient, elastic design utilizing message-driven services

How to design cost-effective Recovery Point Objectives (RPOs) and Recovery Time Objectives (RTOs)

How to identify blocking issues with microservices in the cloud

How to evaluate caching strategies that can help lower costs and protect from DOS attacks 

And you'll be able to:

Design high availability, high scalability, low latency, and resilient architectures.

Analyze and review implementations.


Identify key scalability challenges in your company.

Prevent cascading failures and preserve functionality. 

This training is for you because...

You have an existing need to evaluate your current architecture.

You want to understand best practices.

You need to design new systems and want to evaluate which pattern to use.

Prerequisites  

Basic knowledge of software architecture

Familiarity with design principles


Architecting AI Enabled Microservices

Seven steps methodology for designing superior AI-Enabled Microservices

In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs. 


System Design Bootcamp Day 1

Currently, real-world applications are designed using both art and science. What is the procedure for developing a solution that is effective, scalable, and resilient? Why is designing a system for disruptive technology challenging? System design could be more structured, and there are numerous approaches to problem-solving. The best practices evolve throughout time. The most effective strategy from 10 years ago can rapidly become obsolete.  

Come prepared to design a system for the 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

Systems Design Bootcamp Day 2

Currently, real-world applications are designed using both art and science. What is the procedure for developing a solution that is effective, scalable, and resilient? Why is designing a system for disruptive technology challenging? System design could be more structured, and there are numerous approaches to problem-solving. The best practices evolve throughout time. The most effective strategy from 10 years ago can rapidly become obsolete.  

This workshop will explore a step-by-step guide to approach System design using real-world applications.

Come prepared to design a system for the following applications interactively.

Come prepared to design a system for the 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

Designing Well Architected Framework Workshop - Deep Dive

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.

Designing and Analyzing Software Architecture : Patterns, Techniques and Tools Deep Dive

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. But getting software architecture right is very hard - especially when working with larger teams. There are many reasons why so many projects end up as the dreaded big ball of mud.

Mastering Enterprise Architecture to create Roadmap- DEEP DIVE

Enterprise Architecture helps in describing what is the current state and helps build a future roadmap. Come prepared to solve many Enterprise Architecture challenges. 

As part of the journey, we will explore TOGAF to build our architecture. First, we will create a Baseline Architecture. Next, we will explore the path for the Target Architecture. Finally, after identifying gaps between the two, we will apply a step-by-step process to prepare a roadmap.

Domain Driven Design Deep Dive

Domain Driven Design has been one of the major cornerstones in large system design for many years. It has recently been in the zeitgeist as of late, especially when it comes to the terms bounded context and microservices.  This full-day class introduces you to Domain Driven Design, and why it is important.  We will cover the design and pattern, discuss subdomains, context mapping, tools, and management

Architectural Design Patterns Deep Dive

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:

Anti-corruption-layer
Claim Check
CQRS
Gatekeeper
Strangler Fig
Bulkhead
More …

Testing Legacy Code & Avoid Mocking

Our jobs usually deal with something other than new code. It is usually old spaghetti and difficult-to-read code. How do we test such code? How do we get through it? How can we surgically remove and make some of this harmful code testable?

Spring Data and the Java Persistence API

Learn the fundamentals of Spring Data JPA, which allows you to work with relational databases quickly and easily. Spring Data adds an abstraction layer over Hibernate or other JPA providers. It provides transactional support, both a primary and second level cache, pagination, dynamic query execution, and the ability to integrate custom data access code into your projects. This course will cover mapping domain classes to database tables, working with relationships, transactional attributes like propagation and isolation, eager vs lazy fetching, and query by example.

Test Driven Development Getting Started Deep Dive

Test Driven Development has been around since at least 2003 in Java and some years before in other languages like Smalltalk. We know we need to do it as Developers, but of course, it is a practice that we don't often do. One of the primary reasons we don't do it is because while it is simple in thought, it is not easy to perform. Some things are just hard to test. Also, many feel that once you create tests, then it is hard to change production code. In this full-day session, we will discuss not only the fundamental principles of Test Driven Development but also the modern tools we have at our disposal that will save us time. This workshop is about _the practice of Test Driven Development_, and not necessarily the tools. 



IntelliJ Dojo

Remember in the Matrix, when Neo said, "I know Kung Fu," and Morpheus said, "Show me." Well, we will be doing that except with IntelliJ. In this dojo, we will be using all the beautiful keymappings that are available in IntelliJ, and we will make you a lean, mean coding machine!  We are talking about high efficiency with minimal mouse usage.

Latest Features In Java

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.

The Java Sessions: Threading and Synchronizers Deep Dive

Threading has always been tough. Even with new frameworks that can make it easy, sometimes we don't have those frameworks at our disposal. This full-day session focuses on threading and the various synchronizers in Java. We will have material that you can use as reference and challenges that will help remember some pitfalls to avoid.

Modern Java: Functional Programming with Streams, Lambdas, and Method References

Java is now on a six-month release schedule, with new features being added all the time. This workshop will show the functional features that have been added to Java, focusing on streams, lambdas, method references, static and default methods in interfaces, and the Optional data type. The goal is to demonstrate not only what has been added, but why and where to use them.

Special capabilities that come with those features, like lambda composition, deferred execution, and parallel computation, will be included.

Upgrade To Modern Java

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 six-month 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.



What's New in Java Deep Dive

In this workshop, we will look at what the new advancements that we will need to prepare for either now or in the near future.  We start with a reminder of where we are now and what was delivered from JDK 9 all the way until today's latest release.  We will then look forward to what is in store with JDK 23 and beyond.

Java Design Patterns Deep Dive

Since 1994, the original Gang of Four Design Patterns book, "Design Patterns: Elements of Reusable Object-Oriented Software" has helped developers recognize common patterns in development.  The book was originally written in C++, but there have been books that translate the original design patterns into their preferred language. One feature of "The Gang of Four Design Patterns" that has particularly stuck with me has been testability for the most part.  With the exception of singleton, all patterns are unit testable.  Design Patterns are also our common developer language. When a developer says "Let's use the Decorator Pattern" we know what is meant.  What's new though is functional programming, we will also discuss how these patterns change in our new modern functional programming world, for example, functional currying in place of the builder pattern.

LangChain4J: A great framework for AI integration in Java

LangChain4j is an excellent framework for building AI-based applications in Java. It provides a unified API over many different LLM providers, including OpenAI, Mistral, Gemini, and Claude. It does the same with a variety of embedding stores, making it easy to implement Retrieval Augmented Generation (RAG) to add your own data to the models.

The Java Sessions: Monitoring the JVM

One of the other essential tasks regarding the JVM is monitoring.  How much stack and heap is your JVM using? What CPU saturation are you using?  How many threads are being used, and what kind of threads are being used? What is your garbage collector looking like? How can I tap into the JVM and monitor other aspects of the JVM? All these questions are essential to ask since often administrators of your Java application will need to know these values to deploy and monitor your application.

GitHub Copilot Deep Dive

GitHub Copilot is a generative AI tool for coding that assists developer in writing code more efficiently and faster.  This full-day course will help you gain a comprehensive understanding of the tool's capabilities and how to use it effectively in your day-to-day coding.

RAG Systems : Using LLMs with Guardrails

Large Language Models (LLMs) such as ChatGPT and Llama have impressed us with what they can do. They have also horrified us with what they actually do when they are employed with no protection: hallucinations, stale knowledge bases, no conceptual basis for reasoning, and a capacity for toxic and inappropriate content generation. Rather than avoid them altogether or risk legal liability or brand damage, we can put some guardrails around them to benefit from their best traits without fearing their worst.

Retrieval Augmented Generation (RAG) systems augment the process to make it behave more to our liking. Come hear what you can do to benefit from AI systems without fearing them.

AI Crash Course : Catching Up to the Future

It's not just you. Everyone is basically thinking the same thing: When did this happen?

We've gone from slow but steady material advances in machine learning to a seeming explosion and ubiquity of AIbased features, products, and solutions. Even more, we're all expected to know how to adopt, use, and think about all of these magical new capabilities.

Equal parts amazing and terrifying, what you need to know about these socalled "AI" solutions is much easier to understand and far less magical than it may seem. This is your chance to catch up with the future and figure out what it means for you.

Gen AI: Working with Hugging Face - the "GitHub" for Large Language Models

HuggingFace.co is the premier site for all things around large language models (LLMs). It has free and open source models and datasets to easily access, download and start working with. As well, it provides the well-known Transformers library of functions that you can use with Python to code up quick and simple apps that interface with LLMs for chatbots, sentiment analysis, classification, etc. And it also allows for direct access to use some models with no coding necessary. 

Join expert Brent Laster for an exploration of the site and learn how to navigate it and use its many features. We'll also see how to use its models and the Transformers library with simple Python coding to do typical LLM interactions.

Gen AI: Automating Testing with GitHub Copilot

Would you like to learn to use GitHub Copilot to write tests for you?  Would you like to learn how to use it to tell you how to test in a language or framework that you're not familiar with?  Would you like to have it help you find edge cases to test, or validate inputs?  Did you know you can have Copilot generate the tests *before* the code and then the code to implement Test-Driven Development?  

If you're a software engineer, writing tests is part of your job.  And, likely not the thing you want to spend most of your time on.  Join global trainer, speaker, and author of the upcoming book, Learning GitHub Copilot, Brent Laster, in this half-day workshop,  as he presents material on multiple ways to leverage Copilot for testing your code on any platform and framework.

Architecture Patterns for AIPowered Applications

Since ChatGPT rocketed the potential of generative AI into the collective consciousness there has been a race to add AI to _everything_. Every product owner has been salivating at the possibility of new AIPowered features. Every marketing department is chomping at the bit to add a "powered by AI" sticker to the website. For the average layperson playing with ChatGPT's conversational interface, it seems easy however integrating these tools securely, reliably, and in a costeffective manner requires much more than simply adding a chat interface. Moreover, getting consistent results from a chat interface is more than an art than a science. Ultimately, the chat interface is a nice gimmick to show off capabilities, but serious integration of these tools into most applications requires a more thoughtful approach.

MLOps Half Day Workshop

MLOps is a mix of Machine Learning and Operations. It is the new frontier for those interested in or knowledgeable about both of these disciplines.  MLOps supports operationalizing machine learning models developed by data scientists and delivering the model to be processed by streaming or batch operations.  Operationalizing Machine Learning Models is nurturing your data from notebook to deployment through pipelines.


Gen AI: Understanding  and Using RAG - Making LLMs smarter by pairing your data with Gen AI (1/2 day)

Large language models (LLMs) are great and provide a lot of utility out of the box - as long as you accept that the data they have is only as recent as their training.  And, as long as you understand that that they don't have context of any data they weren't trained on - which may be the local context you really care about.  In this session, we'll see how to augment their training and knowledge to include other content that they weren't trained on, such as your files.  And we'll see how to seamlessly combine that with the LLM's existing knowledge and query/prompt interfaces.

DIY Gen AI: Running LLMs locally with LM Studio, Hugging Face, and Ollama

LM Studio is an easy to use desktop app for experimenting with local and open-source Large Language Models (LLMs) by hosting them on your own system.
Here are some of the features it provides (quoted from its homepage):

Run LLMs on your laptop, entirely offline
Use models through the in-app Chat UI or an OpenAI compatible local server
Download any compatible model files from HuggingFace repositories
Discover new & noteworthy LLMs in the app's home page

Hugging Face is a community hub focused on creating and sharing AI models. It provides many free and pre-trained models as well as datasets and tools to use with them.

Ollama is a command line tool for downloading, exploring, and using LLMs on your local system. 

In this hands-on workshop, we'll cover the basics of getting up and running with LM Studio, Ollama and give you hands-on labs where you can use them and Hugging Face to find and load and run LLMs, interact with it via Chat and Python code and more!  

Machine Learning Platforms



Machine Learning is clearly here to stay. While it is a far cry from actual Artificial Intelligence, it provides many invaluable and remarkable ways to learn from the data we are collecting about our customers, products and daily activities. The past afforded us machine learning libraries which became machine learning frameworks. Now, we are designing and building machine learning platforms that facilitate entire initiatives in reusable and extensible ways. We will discuss many of the drivers of modern machine learning systems and the platforms that we are seeing emerge.

Building Intelligent Spring Applications with Spring AI

By now, you've no doubt noticed that Generative AI is making waves across many industries. In between all of the hype and doubt, there are several use cases for Generative AI in many software projects. Whether it be as simple as building a live chat to help your users or using AI to analyze data and provide recommendations, Generative AI is becoming a key piece of software architecture.

So how can you implement Generative AI in your projects? Let me introduce you to Spring AI.

For over two decades, the Spring Framework and its immense portfolio of projects has been making complex problems easy for Java developers. And now with the new Spring AI project, adding Generative AI to your Spring Boot projects couldn't be easier! Spring AI brings an AI client and templated prompting that handles all of the ceremony necessary to communicate with common AI APIs (such as OpenAI and Azure OpenAI). And with Spring Boot autoconfiguration, you'll be able to get straight to the point of asking questions and getting answers your application needs.

Cloud Integrations, Data Architecture, MDM, and GDPR WorkShop

In this Cloud Integrations and Data Architecture workshop, we will examine secure, scalable integrations on Enterprise applications. Through various scenarios, we will explore designing and implementing intricate integration patterns on multiple platforms. We will review how to communicate the solution and design trade-offs to business and technical people.

Advanced Kubernetes – Gaining Mastery over your Deployments

In this ½ day course, author and trainer and DevOps Director Brent Laster will take you beyond the basics of Kubernetes to understand the advanced topics you need to know to ensure your success with K8S.  

Mastering Secure Shell (SSH) For Developers

There are a handful of tools that will make your life as a developer easier and more productive no matter what other languages and frameworks you are using. The Secure Shell (SSH) is one of them. The problem is that it is easy to use but takes a while to learn effectively. In this half-day workshop, you will learn the basics as well as advanced features to get the most out of this ubiquitous and crucial tool for remote working or cloud-based developers.

Mastering Cloud Architecture Scalability and System Designs - DEEP DIVE

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.

Terraform-ing your Cloud

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.

Architecting NoSQL and NewSQL Cloud-Data Design Patterns

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.

Serverless

The term "Serverless" seems to be used everywhere and Serverless Functions, Functions as a Service (FaaS) and/or Lambda are taking the cloud by storm (pun intended). What are Serverless Functions and what’s all the fuss? During this workshop, we’ll build a Serverless Web Service, add an API management layer and database, all using Serverless computing options; it will be a 100% Serverless application.

During this workshop, we’ll look at a brief history of Cloud Computing, the Shared Responsibility Model, how Serverless enables you to do more with your cloud resources and how to build your first Serverless Web Service.

The Kubernetes Sessions: Monitoring and Tracing

You have your application rolled out in Kubernetes, but you want to keep track of its health and monitor your applications. This half-day session will discover open-source utilities to monitor your Kubernetes cluster and your applications: Prometheus, Grafana, and Jaeger

Kubernetes for Developers Deep Dive

In this full-day course, author and trainer and DevOps Director Brent Laster will take you from the basics of Kubernetes to understanding the ways to orchestrate and deploy entire Kubernetes applications and monitor Kubernetes clusters.


The Kubernetes Sessions: Getting Started Deep Dive

This is an introductory workshop to get started with Kubernetes.  This assumes that you, the attendee, are fresh to this technology.  This workshop begins with defining terms, deploying Kubernetes objects, tracking the health of your deployments, and exposing your application to the outside world. Our end goal is to have you deploy a full application on the internet.

Spring into K8s: Deploying Spring Application in Kubernetes

Although Java originally promised write once, run anywhere, it failed to fully deliver on that promise. As developers, we can develop, test, and build our applications into WAR or executable JAR files and then toss them over the wall to a Java application server and Java runtime that we have no control over, giving us zero confidence that the application will behave the same as when we tested it.

Containers fulfill the write-once, run anywhere promise that Java wasn't able to, by packaging the runtime and even the operating system along with our application, giving greater control and confidence that the application will function the same anywhere it is run. Additionally, containers afford several other benefits, including easy scaling, efficiency in terms of resource utilization, and security by isolating containers from their host system and from other containers.

While deploying Spring applications in containers has always been possible, Spring Boot makes it easier to containerize our applications and run them in container architectures such as Kubernetes. Spring Boot's support for containerization includes two options: Creating containers based on buildpacks or using layers as a means of modularizing and reducing the size of our application deployments. Moreover, new components in the Spring ecosystem can make your Spring applications Kubernetes-savvy so that they can take advantage of what a containerized architecture has to offer.

Kubernetes Security Deep Dive

It's time to take security seriously.  Recently Colonial Pipeline was attacked with ransomware, and there was no other recourse except to pay the ransom.  There are other nightmare stories that we hear year after year. You have probably been a victim of these attacks as well.  How do we mitigate these attacks and how do we make our Kubernetes cluster more secure.

Certified Kubernetes Application Developer (CKAD) Workshop

Looking to be recognized by passing the [Certified Kubernetes Application Developer (CKAD) test](https://www.cncf.io/certification/ckad/).   This workshop will provide 40% lecture, 60% labs detailing the most challenging parts of the certification.  Whether you are taking the exam or not, this sessions provides details on common tasks necessary to be productive with Kubernetes.

The Kubernetes Sessions: Scheduling Pods

This workshop digs into the details of scheduling pods. Scheduling pods are fine for simple deployments, but what happens if you need an exclusive schedule on a node? What happens if a node fails? This workshop aims to answer these questions.

Helm: Kubernetes Chart Deployment & Development Deep Dive

Helm is excellent stuff. It is the package manager for Kubernetes and a way that you can package your Kubernetes YAML files and templatize them for reuse for either people in your organization or the public at large. Helm makes it super simple to deploy any major system with relative ease: find a repository, add the repository, and install your product.  All Helm charts have a set of default values for everyday use cases, and it would be up to you to override the values you desire for your custom installation. 

Quarkus Basics

Quarkus is a new microservice framework built by RedHat that competes with Pivotal's Spring Boot.  One of the distinct differences that Quarkus it is built with Kubernetes in mind and is the center of its experience. Quarkus has many extensions that make its users happy: Scaffolding, JSON Restful Services, Persistence, Fault Tolerance, Security, and Observability to gauge performance in Kubernetes.  This Quarkus training is our half-day experience, where we will create an application, install extensions, and create a web service. We then discuss some other features that Quarkus has that make developers delighted.

Cloud-native CI/CD in Kubernetes with Tekton

In this ½ day workshop, students will learn about how to use Tekton to construct cloud-ready CI/CD pipelines running in Kubernetes.   Students will use Tekton Pipelines and Tekton Triggers to define and implement a simple CI/CD pipeline that will automatically update a Kubernetes deployment.

Tekton is a newer entry in the CI/CD tooling space that allows you to implement CI/CD pipelines through custom Kubernetes objects.  Because of that, you can utilize the same Kubernetes knowledge you already have without learning another application and take advantage of your existing Kubernetes infrastructure and features such as scaling that are built in.  Join author and trainer and DevOps Director Brent Laster to learn how to easily and quickly get up to speed with Tekton and the supporting pieces around it including its dashboard and CLI.

This workshop will include hands-on labs so you can get immediate experience with Tekton.

(Note: A solid understanding of Kubernetes is needed as a prerequisites for this workshop.)

Spring Boot

The Spring Framework transformed enterprise Java development over 15 years 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. 
While Spring continues to evolve to enterprise Java development easier, Spring Boot has emerged to make Spring itself easier. It achieves this in several ways, including:

Automatic Configuration : Spring Boot can automatically detect what kind of framework level functionality you need and will automatically configure the components to enable that functionality.
Dependency Management : Spring Boot provides a rich set of "starter" dependencies that enable your build, whether it be Maven or Gradle-based, to focus on what your app needs and less on which libraries or versions of libraries it will need.

Runtime Insight and Management : Spring Boot can enable endpoints in your application to give you insight into the internals of a running application, including environment properties available to the application, logging levels at all package levels, application health, cache managers, application metrics, and much more. And, for some cases, you can even alter an application's internal settings without redeploying or restarting your application.

Contain Your Spring

Although Java originally promised to write once, run anywhere, it failed to fully deliver on that promise. As developers, we can develop, test, and build our applications into WAR or executable JAR files and then toss them over the wall to a Java application server and Java runtime that we have no control over, giving us zero confidence that the application will behave the same as when we tested it.

Containers fulfill the write-once, run anywhere promise that Java wasn't able to, by packaging the runtime and even the operating system along with our application, giving greater control and confidence that the application will function the same anywhere it is run. Additionally, containers afford several other benefits, including easy scaling, efficiency in terms of resource utilization, and security by isolating containers from their host system and from other containers.

While deploying Spring applications in containers has always been possible, Spring Boot 2.3 makes it easier to containerize our applications and run them in container architectures such as Kubernetes. Spring Boot 2.3's support for containerization includes two options: Creating containers based on buildpacks or using layers as a means of modularizing and reducing the size of our application deployments. Moreover, new components in the Spring ecosystem can make your Spring applications Kubernetes-savvy so that they can take advantage of what a containerized architecture has to offer.

Event-Driven Spring

At its core, Spring is built on a dependency injection framework that enables (among other things) loose coupling of application components. But dependency injection is not the only way to achieve loose-coupling. Event-driven design, as its name implies, enables components to react to events, not knowing where they came from, process those events, and then publish new events not knowing who (if anybody) will be handling those events.

The Spring MVC Framework

Spring is still the leading open source framework in the Java world for building web apps and web services. This workshop will walk through creating both, with special emphasis on deployable restful web services. In addition to the basic code, the workshop will look at how Spring operates, including the proxy design pattern, interceptors, managing singletons, and more.

Reactive Spring

Use the webflux module in Spring to perform asynchronous requests. This course discusses how Spring implements annotated controllers and functional endpoints to implement reactive services. Topics include the basics of reactive applications and how they appear in the reactive streams specification, how Spring uses Project Reactor to implement services, how the Flux and Mono classes from Reactor provide operators and transformations to solve problems, and more.

Reactive Spring : Modernizing Code & Architecture

Spring has always been defined by its lightweight core. While there has been an overwhelming explosion in the external projects and protocols it integrates seamlessly with, it has also evolved internally to meet the needs of modern development requirements.

What's New in Spring and Spring Boot

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 Graph QL

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.



DEEP DIVE: Spring and Spring Boot

Spring is an incredibly flexible framework that makes programming Java quicker, easier, and safer for everybody. Spring’s focus on speed, simplicity, and productivity has made it the world's most popular Java framework and a _highly_ sought-after developer skill in the market.

Spring Boot transforms how you approach Java programming tasks, radically streamlining your experience. Spring Boot combines necessities such as an application context and an auto-configured, embedded web server to make microservice development a cinch.

In this live, instructor-led, full day deep dive, award-winner author and instructor Ken Kousen takes us on the journey from "hello world" to *Real World*

### Key Takeaways

* Create web apps and restful web services
* Understand Spring's dependency injection and POJO-based model
* Learn how to test all kinds of Spring applications
* Work with Spring's persistence and transactional models for relational databases

**REGISTER NOW** for this comprehensive introduction to a framework that will change the way you write java for the better!

Spinnaker Deep Dive

Back in 2005,  when an unknown program called Hudson came onto the scene, I was pretty excited.  I had used CruiseControl up to that point and was getting pretty comfortable with the notion of Continuous Integration. Hudson had terrific graphics and an intuitive UI, unlike Cruise Control with XML laden directives. I thought the future was here.  Then some cracks started showing, particularly in the delivery aspect of Hudson.  I had used a Tomcat plugin, but trying to get a jar, use various environments, became a juggling act.  Then came Docker, and I loved it because we get to deploy an image! No more SSHing into a box and messing things up. We had immutability.  Now, we have Kubernetes, a system that takes these immutable containers and monitors them, among other great features. Jenkins still has its place but as CI, Continuous Integration. In this class, we use Spinnaker, a system developed by Netflix for CD, Continuous Delivery.  Our goal is to do a complete CI/CD pipeline, from checking in to delivery.  We are going to monitor, rollback, and scale our pods with the ease of just selecting an item on a menu.

Docker and Dockerfiles



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.

GitHub Actions Deep Dive

In this full-day workshop, open-source author, trainer, and DevOps director Brent Laster will provide an extensive introduction to GitHub Actions. You’ll learn about the core parts and pieces that make up an action, as well as the types of functionalities and features they provide.
You’ll also see how to combine them in simple workflows to accomplish basic tasks as well as more advanced workflows to automate typical CI/CD and other tasks. And you’ll learn about
how to create and use your own actions, create and manage artifacts, and how to debug and secure your GitHub Action workflows.




DevSecOps Productivity: Driving Security with Ethical Hacking & OWASP Top 10 for Apps, APIs, LLMs, and Mobile

As a software architect, you're at the forefront of building scalable, secure, and resilient systems that drive innovation while safeguarding critical digital assets. This workshop is designed to equip you with actionable strategies, cutting-edge tools, and deep technical insights into embedding security into every phase of the software development lifecycle.
In this immersive, hands-on session, we will explore how to elevate your DevSecOps practices to meet the challenges of today’s evolving threat landscape while ensuring productivity and operational excellence.

What You'll Learn:
* Integrating Security into CI/CD Pipelines: Discover how to build efficient, secure workflows that empower teams to deliver faster without compromising security. Learn to implement security gates and automate vulnerability detection with tools like SAST, DAST, and dependency scanning.
* Tracking Metrics for Success: Understand key DevSecOps metrics such as lead time, deployment frequency, mean-time-to-recover (MTTR), and change fail rate. Learn how observability tools provide actionable insights to optimize performance and reliability.
* Proactive Security with Ethical Hacking: Dive into penetration testing and simulate real-world attacks to uncover vulnerabilities in your systems before attackers do. Get hands-on with industry-standard tools such as OWASP ZAP.
* OWASP Top 10 for Applications, APIs, LLMs, and Mobile:
    * Applications: Learn to identify and mitigate risks such as injection flaws, broken authentication, and misconfigurations.
    * APIs: Secure APIs with best practices for authorization, schema validation, and rate limiting to combat vulnerabilities like excessive data exposure.
    * LLMs: Explore unique challenges in securing Large Language Models (AI-driven applications), including prompt injection and data leakage.
    * Mobile: Address mobile app vulnerabilities such as insecure storage and transport layer protection, ensuring your applications are robust across platforms.
* Aligning Security with Business Outcomes: Bridge the gap between technical practices and business goals by aligning DevSecOps with operational KPIs. Demonstrate how secure development drives measurable business value, customer satisfaction, and operational excellence.

Why You Should Attend:
* Hands-On Experience: Participate in live demonstrations of vulnerabilities, attacks, and their mitigation across applications, APIs, LLMs, and mobile systems.
* Cutting-Edge Tools and Techniques: Gain exposure to the latest tools and practices in CI/CD, ethical hacking, and observability.
* Business-Driven Approach: Learn how to connect DevSecOps efforts to organizational success, making security an enabler of productivity.
* Collaborate with Experts: Engage with peers and experts to discuss real-world challenges and share actionable solutions.

Who Should Attend:
This workshop is ideal for:
* Software Architects seeking to embed security into every layer of system design.
* Senior Developers striving to deliver secure, high-performing applications.
* Technical Leads responsible for ensuring compliance and operational excellence in development pipelines.

Join us for this transformative session to gain the skills and knowledge necessary to design secure, scalable, and resilient systems that protect your organization and enable innovation.



Fundamentals of Ansible: Deep Dive

In a world where automation is king, when it comes to configuration management, Ansible rules. Ansible, an opensource project from RedHat allows you to automate configuration including installing software, applying security patches, managing networks across the whole spectrum—be that locally, onprem, in the cloud.  

In this exercise driven session, we’ll learn Ansible from the ground up. We’ll see how to declare your inventory, use modules to run arbitrary tasks on hosts, collect related tasks into playbooks, make reusable units of work using roles, and how to use variables. By the end of this session, you will walk away with a comprehensive understanding of how Ansible works, and how you can start to use it to automate away the mundane.


Advanced Git Workshop



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.

Kafka Streams Basics

Now that you know about Kafka, let's talk about Kafka Streams and KSQL. With Kafka Streams and KSQL, we will discuss how to build streaming applications. What do we do when we accumulate state. Then we will take a look at KSQL and persistent and non-persistent SQL queries

Kafka Basics



Kafka is a "must know." It is the data backplane of the modern microservice architecture. It's now being used as the first persistence layer of microservices and for most data aggregation jobs.  As such, Kafka has become an essential product in the microservice and big data world. This workshop is about getting started with Kafka. We will discuss what it is. What are the components, we will discuss the CLI tools, and how to program a Producer and Consumer.

Machine Learning Data Pipelines Deep Dive

An intense workshop designed to operationalize machine learning.  The focus of this full-day workshop is to divide specializations; data engineer and data scientist.  The data engineer ensures that data is delivered, manipulated, and harnessed.  The data engineer does this so that it is useful for the data scientist.  The data engineer is versant in Java and Scala. 

The data scientist uses that data, does their own cleaning, and investigates possible patterns designing a machine learning model that we can use to either find regressions or classifications for our data. The data scientists use Python, Jupyter Notebooks, Tensorflow, and Matplotlib as their tools of choice for constructing a machine learning model to make decisions about the data.

Kafka Deep Dive

Kafka is a "must know." It is the data backplane of the modern microservice architecture. It's now being used as the first persistence layer of microservices and for most data aggregation jobs.  As such, Kafka has become an essential product in the microservice and big data world.  This training is a full day Kafka training.  We will not only discuss what it is. What are the components, we will discuss the CLI tools, and how to program a Producer and Consumer. We then discuss Kafka Streams and using KSQL to query information from Kafka.  We close by discussing some other tools available to integrate with Kafka

Event Driven Architecture

Event-driven architecture (EDA) is a design principle in which the flow of a system’s operations is driven by the occurrence of events instead of direct communication between services or components.  There are many reasons why EDA is a standard architecture for many moderate to large companies. It offers a history of events with the ability to rewind the ability to perform real-time data processing in a scalable and fault-tolerant way.  It provides real-time extract-transform-load (ETL) capabilities to have near-instantaneous processing. EDA can be used with microservice architectures as the communication channel or any other architecture.  

In this workshop, we will discuss the prevalent principles regarding EDA, and you will gain hands-on experience performing and running standard techniques. 

The Java Sessions: Test Driven Development in Java

For this half-day workshop, together we will master Test-Driven Development! We will make this training a little celebratory for the occasion but we will not forgo the basics!

* Process of Testing
* Refactoring
* Benefits
* Setting a Project
* Using IDEs to your absolute advantage
* What role do new Java 8 Lambdas play in testing
* What not to test

Kubernetes Application Testing Techniques

Most developers are aware of unit testing techniques used during the early phases of application development, but testing should happen during all phases of an application lifecycle to better reflect the end user’s experience of a service in distributed cloud clusters, where any number of things can go wrong that weren’t anticipated in preproduction testing.

In this workshop, we'll explore two different types of testing that you may want to add to your cloud deployment strategies: 

- consumer-driven contracts (CDC)
- chaos experimentation,

JUnit Jupiter and AssertJ

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. 
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.

Mocks, Stubs, and Spies with Mockito 5

The Mockito framework is the most popular library for creating mocks, stubs, and spies for your tests. This workshop 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.



Integration Testing with TestContainers

The road has been difficult for anyone who has attempted to do any database testing for the last 20 years. One solution that we tried was installing the test database. Oftentimes, that has been hard to maintain, particularly when that test database is shared. Another solution is to use DBUnit on a local system or, possibly, a shared system to set up the database as needed, test it, and tear it down. That too, was very hard to maintain. For many, it was just deploying your application and running end-to-end tests. If it works, it works, and we move on. With the advent of containerization, we now have something substantially better, test containers! Test containers give us the power to bring up a database that we need to test against and the _exact version_ of the database. 

Deep Learning Workshop

Deep Learning is an approach to automated, data-driven learning that builds on a tradition of machine learning but mixes in more flexible models and, usually, the requisite hardware acceleration to make it work. These approaches represent some of the biggest advancements we have seen in the ML/AI space in the last decade but still don't qualify as AI. Through hands on and working examples, we will help you understand what is possible and how to get started with these exciting algorithms and technologies.

TensorFlow.js : Machine Learning in the Browser and Beyond With JavaScript

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.

Machine Learning Deep Dive

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 not assume a research background, excessive amounts of statistics knowledge, the ability to calculus your way out of a paper bag, or your being a card-carrying members of the Linear Algebra Fan Club.

Micro-Services Day 2 Networking

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.

Kubernetes Introduction for Developers

Kubernetes has become the de-facto operating system for containers and now is the best way to start engaging with portable distributed computing. This workshop is for software application developers who want to understand what Kubernetes is all about, how it works, and what it gives you. It can be a seemingly complex ecosystem full of terms, architectures, and misinformation. Jonathan will break it down so you have a solid understanding of how it works so you can start writing applications that run on this distributed platform.

You’ll be introduced to the terms and benefits while breaking down the architecture to get to the aha moment on how the engine works. Then Jonathan will take you through some hands-on labs that show you how to run and distribute applications on this new paradigm. Once you understand how it works, you'll start thinking like an architect as you are introduced to some application patterns that are readily applied to Kubernetes.

Architecting Cloud-Native Microservices

Seven steps methodology for designing superior Cloud-Native Microservices 

In most of the Monolithic applications business objects and data, model designs are already present. As part of moving to cloud, companies miss out of the use-cases the REST APIs need to support. Implementing cloud solutions on top of existing models may lead to performance issues with APIs and cause scalability issues. Clients need to rewrite code due to a new version of APIs.

DDD and Microservices

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.

Secure Code, For Your Convenience

Learn just enough about secure code to help you write better code, code that's more useful and also safer.

As a developer, I don't want to think about security. I want to create clean abstractions that make my software powerful.
Exploits are all outside the abstraction. They're about everything else that can happen, that shouldn't be possible, but somehow is.

It turns out that thinking about "everything else" can help our abstractions. Secure code is an ally on our quest for cleaner software.

Wireshark For Devs: A Trip From Applications to Packets & Back

We all basically understand what it means to build Internet-aware applications. But somewhere at the intersection of architecture, application development, protocols and networking, things get a little fuzzy. One of the most widely-used tools in the networking world doesn’t see as much use as it could in the software development world.

Enterprise Ethical Hacking and DevSecOps for Cloud

Securing a web application is an enormous task. In this workshop, we will explore how to protect enterprise applications. Can we shift left and do continuous exploitation testing while code is still in development. 

We will explore different kinds of vulnerabilities and hot to secure your applications properly. Security patterns need to be understood by first wearing the hat of a hacker and then putting the hat as a defender. In this workshop, we will explore different security patterns and determine how to prevent attacks.

We will be using OWASP ZAP to exploit applications. In the end, we will see how OpenVas can help in scanning the vulnerabilities in the application.

Deno: Node Done Right

There is a common perception in software development that you need to throw away the first version of something you build. The second version is the right one because you learned all the lessons the first time. What if that thing was Node.js?

Ryan Dahl's brain child is wildly successful, but he has moved on and is focusing on Deno. He is hoping to solve some of the performance and security issues with Node while embracing a bunch of new ideas that have emerged such as TypeScript and WebAssembly.

Web Security

### If you're not terrified, you're not paying attention!


After decades of data breaches, ransomeware attacks, incessant
phishing attacks and nation state-level attacks against national
infrastructure, everyone is pretty convinced that this is something
they need to spend some time on. The question is how much? Too much
may not be as bad as not enough, but it's still a situation we would
like to avoid.

The question is usually where to begin. Who is responsible? How much
is enough? What do my peer organizations do to protect themselves?
What technologies should we use to address our response? When are we
done?

This is an incredibly complicated problem that is, unfortunately,
crucially important to just about every organization in the
world. Particularly now that our work models are changing and becoming
increasingly remote, we need to make sure more people are thinking
like security people.

The good news is that there are all kinds of tools and strategies that
can help you start to tease the details apart. This session will walk
you through the thought processes and activities to begin to execute a
strategy to improve your security posture.

This is framed as a workshop but the problem transcends specific
technologies. We will identify and address several technologies from a
detailed level, but security is not something you get from software,
tools or features. It is a comprehensive approach to identifying
risks, framing responses, measuring compliance and sharpening the way
you think.

Understanding and Using GitHub Security

Security is a fundamental concern and requirement in all aspects of software development today. And GitHub is the industry-leading collaboration platform for software development. So, it’s crucial that anyone working with/in GitHub understands how to use it securely. 

 Join expert technologist, trainer and author Brent Laster to survey and learn to use the controls, policies, and automation that GitHub makes available to work securely in its platform.  Learn about managing access, dealing with vulnerabilities in your code or dependencies, preventing sensitive data from getting into your repositories, automatically creating needed security updates, and more!  This will be a hands-on workshop so you get real experience working with the mechanisms in GitHub.  All you need is a GitHub userid and a browser!





Architectural Design Patterns Focus: Security Deep Dive

The full-day workshop on Security Architectural Patterns will commence with a comprehensive overview of various kinds of attacks and a discussion of notable historical incidents. Participants will delve into defensive architectural patterns such as the Gateway and Ambassador Patterns, followed by the Shift Left approach, which emphasizes integrating security measures early in development. Practical sessions will cover creating small Docker images to minimize vulnerabilities and managing certificates with Public Key Infrastructure (PKI). The workshop will also explore advanced security mechanisms, including the Valet Key pattern, JSON Web Tokens (JWT), and the practices recommended by the Open Web Application Security Project (OWASP).

Gen AI: Understanding AI Agents

In this workshop, we'll do an explanation of what AI agents are, how they work, and a survey of current AI frameworks and how to implement agents in them  including LangChain, CrewAI, and Microsoft’s AutoGen.  We'll also discuss writing custom tools for agents, multiagent implementations, and using datasets with agents for Agentic RAG.



Personal Knowledge Management (PKM) for the Modern Knowledge Worker

Join us for a transformative handson workshop on Personal Knowledge Management (PKM), designed specifically to empower developers, architects, and knowledge workers alike to master information in this information age. Based on Tiago Forte's Building a Second Brain methodology and implemented using the Logseq PKM application, this course aims to equip attendees with the strategies, tools, and insights to streamline their knowledge management, increase productivity, and stimulate creativity. Attendees will learn to construct a personal knowledge graph, effectively annotate and reference digital assets, manage tasks, journal for success, leverage templates, and much more. The ultimate goal is to create a personalized system that enables you to instantly find or recall everything you know and learn.

Spock Workshop - A MUST Have for your Developer Toolbelt

Spock is a groovy based testing framework that leverages all the "best practices" of the last several years taking advantage of many of the development experience of the industry. Combine Junit, BDD, RSpec, Groovy and Vulcans… and you get Spock! Feedback from previous attendees experienced with Spock indicated they learned more than they imagined they would as this deep dive session will explore many less documented cases of Spock and is intended for all experience levels.

This session assumes some understanding of testing and junit and builds on it. We will introduce and dig deep into Spock as a test specification and mocking tool. 
This is a hands-on 50% labs workshop.  Concepts are presented, followed by labs to help re-enforce understanding.

Upgrade to Modern Java: 2025 Deep Dive

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.



API Design Part II : Managing, Testing, Documenting, and Securing APIs

In the second API Design Workshop, we focus on activities surrounding the REST architectural style including the need to manage, protect, document and test it.

API Design I : The REST Architectural Style

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.



The Art of Innovation

Statistically speaking, you are most probably an innovator. Innovators actively seek out new ideas, technologies, and mental models by reading books, interacting with a broader social circle, and *attending conferences.* While you may leave this conference with the seed of an idea that has the potential to transform your teams, products, and organization;  the battle has only begun. While, as a potential changeagent, you are ideally positioned to conceive of the powerful new ideas, you may be powerless to drive the change that leads to adoption. Your success requires the innovation to *diffuse* outward and become adopted. This is the _art_ of Innovation.

10X Productivity for Developers & Architects

Maximize your impact through Communication, Emotional Intelligence, and Influence

Communication and Charisma are 70% of your office and social life success. Productivity is key to success in software architecture and development. We will be exploring different principles so you do not have to work 60 to 80 hours a week. We will discuss proven strategies to make you the most influential Developer and Architect with greater Empathy and Self Regulation. 

This workshop is for you as you can now SLANT your way to being a leader. You will learn how to increase Emotional intelligence in just one month, which amounts to 85 to 95% of your success in the office. You will be able to self-regulate and increase awareness like a pro in just 10 minutes to avoid anger, disappointment, exhaustion, frustration, stress, Worry, Anxiety, and Confusion. You will master the SCAMPER technique to understand a problem and create new opportunities like Ray Cork and Steve Jobs.

12 Factor Apps in Heroku

Ever thought that you write code and promote, the application runs and automatically deploys?

Do you want to deploy free hosting to your apps?

Heroku lets you deploy, run, and manage applications written in open languages and frameworks such as Ruby, Node.js, Java, Python, Clojure, Scala, Go, and PHP. You can quickly deploy your code with a single command using developer tools like git, GitHub, and Docker. We'll build and run your application with our container-based platform, handling compilation, dependencies, assets, and executables so you can focus on creating engaging experiences for your users.

A QUIC Guide to the Past and Future of HTTP : Easy as 1, 2, 3

The Hypertext Transfer Protocol (HTTP) has been in use for decades. Almost as soon as it was released initially, those surrounding its design began extending it to meet the needs of evolving interaction styles. 
HTTP 1.1 was a huge leap forward, but there were still performance issues that were not resolved until HTTP/2.