Raju Gandhi

Over the last few years, JavaScript has introduced a slew of new features—fat-arrow functions, maps and sets. But wait! What's a WeakMap? And there's a WeakSet? And what exactly does Proxy do, and why do we need it given JavaScript's dynamic nature? And then there's Proxy's cousin, Reflect. Are these features more the result of feature envy than of any pragmatic value?

In this fast-paced live coding session, Raju Gandhi will demonstrate how you can use these features in combination to create a reactivity system very similar to ones used by modern view libraries like Vue.js. Of course, if you are interested in Vue.js, or already use it, you have even more reason to see how Vue performs some its magic. Win win!

In this session, we will explore the APIs of several new additions to JavaScript, as well as see how they can be used to build something interesting, including:

• Maps
• Sets
• WeakMaps/WeakSets
• Proxy/Reflect
• ESM

If you've heard of these constructs, and want to see how to build something really cool, you really need to attend this session (And as a bonus, you'll see how one of the world's most popular frontend library does some of it's magic).

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

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.

Angular brings together some of the most promising new technologies in the web space like Components, Observables, Window.fetch all the while bundling together a set of “best” practices like dependency injection in one development stack. If you are looking to build powerful single page applications then Angular is your friend. In this workshop we will start from the ground up, and build our way through a simple application that will let us explore the various constructs, and the familiarize ourselves with some of the new terminology in Angular.

This session will focus on Angular 12

In this workshop we will get down and dirty with Angular. In this workshop we will start with the very basics of how to bootstrap our Angular application, and work slowly towards making REST-ful AJAX requests to a backend. List of topics include

• Creating Angular components
• The nuts and bolts of NgModule
• Creating component hierarchies
• Using the Angular style guide for naming and project layout
• Directives like *ngFor
• @Inputs and @Outputs
• Services
• Dependency Injection
• The component lifecycle
• Ajax using Http and Observables
• Smart vs. Dumb components
• Routes, routing, and the router-outlet

Along the way we we prescribe to some established practices like directory structure, naming, and some tricks to make our development life easier.

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 pinia and the vue-router, and tooling like the Vue devtools and vite to get developers productive, without aiming to be too opinionated, or too flexible. If you are curious about Vue, this workshop is for you.

This is a full-day workshop. We will proceed to build a full application using Vue 3.
We will start by discussing how you can start working with Vue including the command-line starter project and IDE support, all the way to seeing what it takes to build an app with Vue, including communicating with the backend, and routing. List of topics include:

• Creating Vue.js components
• Creating component hierarchies
• props and custom events
• Smart vs. Dumb components
• Ajax using axios
• Routes, routing, and the router-view

Containers are everywhere. Of course, a large part of the appeal of containers is the ease with which you can get started. However, productionizing containers is a wholly different beast. From orchestration to scheduling, containers offer significantly different challenges than VMs.

In particular, in terms of security. Securing and hardening VMs is very different than that for containers.

In this two-part session, we will see what securing containers involves.

We'll be covering a wide range of topics, including

• Understanding Cgroups and namespaces
• What it takes to create your own container technology as a basis of understanding how containers really work
• Securing the build and runtime
• Secrets management
• Shifting left with security in mind

Containers are everywhere. Of course, a large part of the appeal of containers is the ease with which you can get started. However, productionizing containers is a wholly different beast. From orchestration to scheduling, containers offer significantly different challenges than VMs.

In particular, in terms of security. Securing and hardening VMs is very different than that for containers.

In this two-part session, we will see what securing containers involves.

We'll be covering a wide range of topics, including

• Understanding Cgroups and namespaces
• What it takes to create your own container technology as a basis of understanding how containers really work
• Securing the build and runtime
• Secrets management
• Shifting left with security in mind

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.

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.

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.

In this session we will discuss the need to document architecture, and see what mechanisms are available to us to document architecture—both present and future.

We've all learned that documenting your code is a good idea. But what about your architecture? What should we be thinking about when we document architecture? What tools and techniques can we reach for as we pursue this endeavor? Can we even make this a sustainable activity, or are we forever doomed to architectural documentation getting outdated before the ink is even dry?

In this session we will discuss a range of techniques that will not only help document your architecture, but even provide a mechanism to think about architecture upfront, and make it more predictable. You'll walk away armed with everything you need to know about documenting your current, and future architectures.

In this session we will go further with DDD, considering aspects like aggregates, domain events, factories and repositories, and consider how DDD can be represented in architecture, be that hexagonal, REST or RPC.

If you need a deeper dive into DDD, then this is the session for you.

You've heard of Terraform, maybe even written some scripts using it. You've heard that Terraform is capable of dynamic behavior using blocks, for loops and counters. And you've glanced at the Terraform functions list, but wondered how one would ever go about using those?

We've got you covered.

In this session, we'll build a set of Terraform scripts that can be fed a YAML file, and using Terraform's dynamic capabilities, we'll build infrastructure as specced out in the YAML file.

We'll be covering a host of different topics in this session

• Terraform's dynamic capabilities including dynamic blocks, for and for_each loops
• Terraform's functions and datastructures

If you are interested in a different approach to writing your next micro-service, or are knee deep in the DevOps world with Kubernetes and Docker (both written using Go) you need to know go.

Come join me in a rather quick introduction to the language and it's merits and short-comings.

Micro-services, DevOps, command-line utilities — Go has been the catalyst in a quiet revolution happening right under our noses. Go, from Google, aims to be a language that is simple, with the aim of writing scalable and reliable software. Go brings a unique tilt to many aspects of language design, including enforcing a strict project structure, powerful tooling to support things like code-style enforcement, as well as “goroutines” to allow for concurrency.

In this session we'll take a tour of some features that you might or might not have heard of, but can significantly improve your workflow and day-to-day interaction with Git.

Git continues to see improvements daily. However, work (and life) can take over, and we often miss the changelog. This means we don't know what changed, and consequently fail to see how we can incorporate those in our usage of Git.

In this session we will look at some features you are probably aware of, but haven't used, alongside new features that Git has brought to the table. Examples include:

• Rebase and interactive rebase
• restore/switch and when to use them
• worktrees
• shallow-clones
• Git's filesystem monitor

By the end of this session, you will walk away with a slew of new tools in your arsenal, and a new perspective on how this can help you and your colleagues get the most out of Git.

Go is a fascinating language. While it is simple, it makes some rather interesting decisions on several language features that we take for granted in other languages.

In this session we will take a deeper dive into the language — seeing what it makes it the language of choice for companies like Google, as well as the go to language for large OSS projects like Kubernetes and Docker.

Today, JavaScript is ubiquitous. However, for the longest time, JavaScript for the longest time was deemed quirky and eccentric. Developers had to resort to convoluted programming practices and patterns to avoid the potholes presented by the language.

All that changed in 2015. The central committee that governs the development of the language
announced a slew of changes aiming to propel JavaScript into a new era. Features like let and const aim to deprecate the mischievous var, while fat-arrow functions aim to not only make JavaScript more succinct but also more functional. Developing domains and object hierarchies is also easier using the newly introduced classes. Finally features like promises and async/await make it easier to work with asynchronous operations.

However, there is a ton of legacy code out there that still uses older language constructs, and this code needs to be and should be refactored to use modern JavaScript constructs. This not only makes the code sustainable and evolvable but also clearer, more explicit, and lesser bugs.

In this exercise-driven workshop, you will use a test-driven approach to learn how to safely refactor your legacy JavaScript code using modern constructs.

By the end of this workshop, you will have built a solid foundation of modern JavaScript constructs. You will be ready to take on your next project or refactor an existing one with confidence.

It's not just architecture—it's evolutionary architecture. But to evolve your architecture, you need to measure it. And how does that work exactly? How does one measure something as abstract as architecture?

In this session we'll discuss various strategies for measuring your architecture. We'll see how you know if your software architecture is working for you, and how to know which metrics to keep an eye on. We'll also see the benefits of measuring your architecture.

We'll cover a range of topics in this session, including

• Different kinds of metrics to measure your architecture
• The benefits of measurements
• Improving visibility into architecture metrics

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.

In this session we will discuss what modular monoliths are, what they bring to the table, and how they offer a great middle ground between monoliths and distributed architectures like microservices.

Monoliths get a bad rep. Experienced software developers have seen one too many monoliths devolve into a big ball of mud, leaving everyone frustrated, with an itch to do a “rewrite”. But monoliths have their pros! They are usually simpler, easier to understand, and faster to build and debug.

On the other side of the spectrum you have microservices—that offer scale, both technically and organizationally, as well as having the badge of honor of being “the new cool kid on the block”. But productionizing microservies is HARD.

Why can't we have our cake and eat it too? Turns out, we can. In this session we will explore the modular monolith—all the upsides of a monolith with none of the downsides of distributed architectures. We'll see what it means to build a modular monolith, and how that differs from a traditional layered architecture. We will discuss how we can build architectural governance to ensure our modules remain decoupled. Finally we'll see how our modules can communicate with one another without violating modularity.

By the end of this session you'll walk away with a greater appreciation for the monolith, and see how you can leverage this within your system architecture.

Confused about Kubernetes? Don't know what it does? This is the session that will bring clarity for all things Kubernetes.

The orchestration wars are over, and we have a winner, namely Kubernetes. However, it's not easy to wrap your head around all the abstractions that Kubernetes uses.

In this two-part session we'll wade into the water, but quickly navigate to the deep end of Kubernetes. We'll use a demo-driven approach along with analogies and diagrams to bring clarity to understanding this massively complex, yet powerful, ubiquitous tool.

We'll cover the following:

• What is Kubernetes and why do we need such a tool?
• Kubernetes cluster architecture
• Pods, InitContainers and Sidecar containers
• ReplicaSets
• Deployments
• Volumes and PersistentVolumes
• ConfigMaps, Secrets and the Downward API
• Services
• Ingress
• StatefulSets

We'll also look into the tradeoffs of using tools like Kubernetes, and when it's appropriate, and if there are any alternatives.

Confused about Kubernetes? Don't know what it does? This is the session that will bring clarity for all things Kubernetes.

The orchestration wars are over, and we have a winner, namely Kubernetes. However, it's not easy to wrap your head around all the abstractions that Kubernetes uses.

In this two-part session we'll wade into the water, but quickly navigate to the deep end of Kubernetes. We'll use a demo-driven approach along with analogies and diagrams to bring clarity to understanding this massively complex, yet powerful, ubiquitous tool.

We'll cover the following:

• What is Kubernetes and why do we need such a tool?
• Kubernetes cluster architecture
• Pods, InitContainers and Sidecar containers
• ReplicaSets
• Deployments
• Volumes and PersistentVolumes
• ConfigMaps, Secrets and the Downward API
• Services
• Ingress
• StatefulSets

We'll also look into the tradeoffs of using tools like Kubernetes, and when it's appropriate, and if there are any alternatives.

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.

Jamie Zawinski once said “Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.“. Many consider regular expressions to be indecipherable, but the truth is that every programmer should consider regular expressions an integral part of their toolkit. From the command line to your favorite text editor, from parsing user input to scraping HTML pages - once you know regular expressions you will find a use for them in almost every programming context.

In this session we will attempt to unriddle the mystery that regular expressions pose. We will start at the basics and work our way towards more complex expressions.

In se session we will discuss HashiCorp vault. We'll see what it is, what it's capable of, and how you can integrate it into your stack

Secrets management is a development concern regardless of your technology stack, deployment model or industry. HashiCorp's Vault stands as one of best offerings in this space.

In this session we'll deep dive into HashiCorp Vault. We'll see how to get started, use it within our applications and how it can leveraged for production workloads.

Albert Einstein once said — “We cannot solve our problems with the same thinking we used when we created them.”

As developers, architects, managers, tech-leads, our job entails solving big problems. However, our systems are composed of parts, and it is the interaction of those parts that ensure the system works, and tells us where to go looking when things fail. What does it mean to think in systems? What are the benefits, and what are tools are available to us? If any of this intrigues you (and it should) come join me as we explore a new way of thinking about problems, both big and small.

In this session we will take a page from Donella H. Meadows fantastic book “Thinking in Systems” and attempt to get an understanding of what makes up a system, how we can tease apart the moving parts of the system, and get into the mindset of a “systems thinker”.

A large part of embracing DevOps involves embracing automation. Over the last decade we have seen the emergence of “as Code” — Build-as-Code, Configuration-as-Code and Infrastructure-as-Code. The benefits to utilizing such tools are huge! We can codify the state of the world around our applications, giving us the ability to treat everything that our code needs like we treat the code itself. Version control, release management, tagging, even rolling backs are now possible. Terraform, an open-source tool from HashiCorp allows us to build, control and modify our infrastructure. Terraform exposes a Domain-specific language (DSL) that we can use to express what our infrastructure should look like. Terraform can work with all the major cloud providers, including Amazon AWS, Google GCP and Microsoft Azure. If you are curious about what this tool has to offer, this session is for you. Come on in, and let's learn how to terraform your cloud.

This session will focus on Terraform. We will look in to how this tool works, explore its capabilities, and see how it can play a pivotal role in our Infrastructure-as-Code (IaC) strategy. With lots of code and demos, this session will certainly give you enough fodder for thought, and provide a baseline so you can decide if Terraform is right for you.

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

• The place for, and benefits of “Everything as Code” alongside GitOps
• Terraform's architecture
• Terraform 101
• Introduction to HCL
• What are providers?
• Initializing terraform and providers
• Dive right in! Creating your first resource in AWS using Terraform
• Understanding references, dependencies
• apply-ing terraform
• Variables and the HCL type-system
• Using data and output in your terraform scripts
• Understanding how Terraform manages state
• Using S3 as a backend
• DRY with Terraform modules
• Collaboration using Terraform
• Terraform ecosystem, testing, and GitOps
• Closing arguments, final Q/A, discussion

Instructions

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 :)

Git is the most used version control system in the world. In response to it's popularity, the open-source Git project continues to add features to accommodate all kinds of workflows. Of course as developers it behooves us to keep track of interesting new features in Git, and see if they help in our usage of Git.

But who has the time?!

Worry not—in this session, I will get you all caught up. Covering a range of topics in Git, you'll get a great picture of new features that landed in Git, as well a dash of features that you didn't even know existed.

Join me, won't you?

We'll be covering new additions that landed in Git.

Gradle changed the build landscape. With an imperative approach to build, using a powerful DSL, Gradle allows for building projects across the spectrum of complexity—from the simplest of Java applications to highly customized builds requiring dozens of plugins and custom logic. Gradle continues to grow and add features—and as developers, it behooves us to know what's new in recent releases of Gradle.

But who has the time?!

Worry not—in this session, I will get you all caught up. Covering a range of topics in Gradle, you'll get a great picture of new features that landed in Gradle, as well a dash of features that you didn't even know existed.

Join me, won't you?

We'll be covering a range of topics in Gradle.

Vue.js, the new kid on the JavaScript framework block is taking the world by storm. Vue has bypassed React in their count of Github stars, alluding to how popular this framework is starting to become. Vue attempts to provide just enough support with libraries like Vuex and the Vue Router, and tooling like the Vue CLI to get developers productive, without aiming to be too opinionated, and too flexible.
If you are curious about Vue, this workshop is for you.

In this workshop we will build a full application using Vue.js. We will start by discussing how you can start working with Vue, all the way to seeing what it takes to build an app with Vue, including communicating with the backend, and routing. List of topics include:

• Creating Vue.js components
• Creating component hierarchies
• props and custom events
• Smart vs. Dumb components
• Ajax using axios
• Routes, routing, and the router-view
• Forms using Vue.js
• Using the best practices for naming and project layout
• Understanding the role of the Vue CLI, and development tools like the Vue Developer Tools for Chrome

If time permits, we will also look into:

• Unit/integration/e2e testing
• The Composition API introduced in Vue 3

Instructions

Please visit https://github.com/looselytyped/web-apps-with-vue for detailed installation instructions

Jamie Zawinski once said “Some people, when confronted with a problem, think “I know, I'll use regular expressions.” Now they have two problems.“. Many consider regular expressions to be indecipherable, but the truth is that every programmer should consider regular expressions an integral part of their toolkit. From the command line to your favorite text editor, from parsing user input to scraping HTML pages - once you know regular expressions you will find a use for them in almost every programming context.

In this highly interactive workshop we will decipher the cryptic construct that is a Regular Expression. Starting with the basics, we will work our way towards advanced usage, including anchors, modifiers, groups, and look arounds.

This is a HIGHLY interactive workshop — Not only will we have a lot of exercises, we will use a playground that will allow us to experiment to our heart's content! Feel free to come in with issues you may have seen at work!

Agenda:

• The basics and how to read regular expressions
• Character Classes
• Negation
• Ranges
• Shortcuts
• Alternations
• Repetitions
• Word Boundaries
• Capture Groups
• Anchors
• Modifiers

Let's once and for all make sense of this powerful tool.

I hope to see you all there.