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

In a world where automation is king, when it comes to configuration management, Ansible rules. Ansible, an open-source project from RedHat allows you to automate configuration including installing software, applying security patches, managing networks across the whole spectrum—be that locally, on-prem, 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.

Detailed agenda:

• Why Ansible?
• How does Ansible work?
• Ansible characteristics
• Run ansible for the first time
• Run an ansible module with args
• Escalating privileges
• Keeping track of your inventory
• Groups of groups (of groups?)
• Variables, specifically inventory variables
• Extracting group and host variables into group/host variable files
• Plays and playbooks
• Our first play
• Environment specific variables
• Making a useful playbook
• Jinja2 string interpolation
• Roles
• Using ansible.builtin.copy and ansible.builtin.template in roles
• Using handlers
• Using Ansible facts and filters
• Using Ansible data-structures
• Using tags
• Encrypting passwords using ansible-vault
• Checking your scripts
• Benefits of Ansible
• Trade-offs

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.

Detailed agenda:
Why Ansible?
How does Ansible work?
Ansible characteristics
Run ansible for the first time
Run an ansible module with args
Escalating privileges
Keeping track of your inventory
Groups of groups (of groups?)
Variables, specifically inventory variables
Extracting group and host variables into group/host variable files
Plays and playbooks
Our first play
Environment specific variables
Making a useful playbook
Jinja2 string interpolation
Roles
Using ansible.builtin.copy and ansible.builtin.template in roles
Using handlers
Using Ansible facts and filters
Using Ansible datastructures
Using tags
Encrypting passwords using ansiblevault
Checking your scripts
Benefits of Ansible
Tradeoffs

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.

Git revolutionized the way we think about version control. Kubernetes' on the other hand gave us a programmatic mechanism to declaratively specify the desired state of a cluster, and with the magic of Kubernetes reconciliation loop automatically see the cluster reflect that ask.

Combine the two, and we get GitOps. In this session we will take a look at FluxCD, a CNCF project that allows you to commit your changes to a repository, and have your changes automatically applied to your Kubernetes cluster.

Join me to see what it takes to adopt FluxCD in your workflow, the benefits it provides, and how you can modernize, simplify and automate your deployment process.

In this session, we will take a look at GitOps, using FluxCD to simplify and automate your deployment process.

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

Microservices have fundamentally changed the way we develop and deploy applications. Everything from team topologies, to DevOps to observability—everything changed, and for the better.

However, it's not all rainbows and unicorns. Operationalizing microservices is hard. Microservices encourage WET (write everything twice) to ensure that services are as decoupled from each other as possible. But how does that work when we have to deal with cross-cutting concerns that we need for every service?

Enter the service mesh. Service meshes like Istio allow us to “slot” in cross-cutting architectural concerns within a kubernetes cluster, letting our services focus on solving actual business concerns.

In this fast-paced session, we will blitz through what Istio is, how it works, and what facilities it offers to DRY out your microservices. Come see how Istio can make your cluster programmable and application-aware.

We live in a world of microservices. Yet, what is a microservice? What defines the boundaries of a microservice? How do we define the relationships between microservices? Thankfully domaindriven design gives us the concepts and practices to better design and decompose our services.

In this session we will consider many of the concepts of DDD — How bounded contexts use Ubiquitous language to model the domain, how context maps can be used to establish the interconnections between services as well aggregates and domains events, all of which will service us well as we go about creating our microservices.

In this session we will 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 microservices 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.

Platform engineering is the latest buzzword, in a industry that already has it's fair share. But what is platform engineering? How does it fit in with DevOps and Developer Experience (DevEx)? And is this something your organization even needs?

In this session we will aim to to dive deep into the world of platform engineering. We will see what platform engineering entails, how it is the logical succession to a successful DevOps implementation, and how it aims to improve the developer experience. We will also uncover the keys to building robust, sustainable platforms for the future

Platform engineering is the latest buzzword, in a industry that already has it's fair share. But what is platform engineering? How does it fit in with DevOps and Developer Experience (DevEx)? And is this something your organization even needs?

In this session we will aim to to dive deep into the world of platform engineering. We will see what platform engineering entails, how it is the logical succession to a successful DevOps implementation, and how it aims to improve the developer experience. We will also uncover the keys to building robust, sustainable platforms for the future

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.

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

You are ready to level up your skills. Or, you've already been playing accidental architect, and need to have a structured plan to be designated as one. Well, your wait is over.

From the author of O'Reilly's best-selling “Head First Software Architecture” comes a full-day workshop that covers all that you need to start thinking architecturally. Everything from the difference between design and architecture, and modern description of architecture, to the skills you'll need to develop to become a successful architect, this workshop will be your one stop shop.

We'll cover several topics:

• What is architecture, what is design, and the spectrum between them
• The modern description of architecture
• Understanding architectural characteristics
• A brief coverage of some architectural styles
• Other skills you need to have to become a successful architect

This is an exercise heavy workshop—so be prepared to put on your architect hat!

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.