Raju Gandhi

Founder, DefMacro Software

Raju Gandhi is a Java/Ruby/Clojure developer and a programming language geek. He has been writing software for well over a decade in several industries including education, finance, construction, manufacturing and retail sectors. Raju has a graduate degree in Industrial Engineering from Ohio University. In his spare time you will find Raju reading, or watching movies, or playing with yet another programming language. He is affectionately known as looselytyped on Twitter.

 

Talks on Wurreka:

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

Docker compose has been a part of the docker ecosystem since the beginning. It allows us to “stitch” together our services so that we can deploy all our services and related infrastructure using the “one” button. Furthermore, we can now use docker-compose to target Kubernetes, exemplifying the role that docker compose has to play in our day to day interaction with Docker.

If you are new to docker-compose then this is the session for you. Lets take a look at the capabilities of docker-compose, see what it takes to use it for local development and testing, and finally see how we can target Kubernetes so we can mimic our production deployment on our laptops.

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.

Java 9 modules present a radical shift away from how we thing about modularizing our applications. However, as we have found, migrating to modules is not as straight-forward as one might imagine. What are modules, what do they have to offer, and do they present any stumbling blocks? We will also see how modules and DDD can work hand-in-hand, and are not an either/or proposition.

In this session we will start from the ground up, starting with the basics and working our way to understanding what it means to be using modules in our applications.

JavaScript will celebrate it's 24th birthday in 2020. For a language that has been around for such a while it has seen very few, if any changes to the language itself. Well all that is about to change with ECMAScript.next (or ECMAScript 6). ECMAScript 6 modernizes JavaScript syntax, while bringing in features such as modules for better namespacing, class as a first class construct, and a variety of additional operators thus ensuring that JavaScript is ready for the next era of large scale modern web applications. ES 7, 8, 9 and now 10 all use the features introduced by ES6 to further the language.

In this two-part session, we will take a look at some of the features that ECMAScript 6 / 7 / 8 / 9 and 10 bring to the table. We will take an exploratory approach, and by the end of 3 hours, you will be well versed with ALL of the new features in JavaScript.

JavaScript will celebrate it's 24th birthday in 2020. For a language that has been around for such a while it has seen very few, if any changes to the language itself. Well all that is about to change with ECMAScript.next (or ECMAScript 6). ECMAScript 6 modernizes JavaScript syntax, while bringing in features such as modules for better namespacing, class as a first class construct, and a variety of additional operators thus ensuring that JavaScript is ready for the next era of large scale modern web applications. ES 7, 8, 9 and now 10 all use the features introduced by ES6 to further the language.

In this two-part session, we will take a look at some of the features that ECMAScript 6 / 7 / 8 / 9 and 10 bring to the table. We will take an exploratory approach, and by the end of 3 hours, you will be well versed with ALL of the new features in JavaScript.

Vue.js—the new kid on the JavaScript framework block—has taken the world by storm and recently surpassed React's star count on GitHub. Much like React, Vue aims to be a superfast view rendering library and provides just enough support to get developers productive. However, Vue goes further than React by offering an idiomatic approach to state management (via Vuex), and routing using Vue Router as add-on libraries.

In this three-hour hands-on training course, expert Raju Gandhi walks you through building a full application using Vue. You'll start with the basics before moving on to writing custom components, using Vuex for state management, and using the Vue router to enable routing within your application. You'll leave with the experience you need to get quickly started on your next project in Vue or dive into an existing code base.

What you'll learn-and how you can apply it

By the end of this live online course, you’ll understand:

  • How Vue works
  • How to get started quickly on your next project using Vue
  • How to compose your applications using components and have them communicate with each other using Vue’s unidirectional data-flow
  • How to use Vuex for state management and the Vue Router to set up routes for single-page applications

And you’ll be able to:

  • Assess if Vue is a good fit for your existing or new projects
  • Get started and get productive with Vue quickly
  • Understand the Vue ecosystem

This training course is for you because...

  • You’re a developer looking to use Vue in an existing or new project, whether in just one part of your application or a full-blown single-page application (SPA).
  • You're a technical lead attempting to assess if Vue is the right framework for your team.
  • You work with other frameworks like React and Angular and want to learn how Vue is different and what it offers.

Prerequisites

  • Comfort working with HTML, CSS, and JavaScript ES6+ in the code editor of your choice
  • The ability to clone a Git repository locally and run a local web server
  • A basic understanding of how single-page applications work

Recommended preparation:

  • Course GitHub Repository

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.

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 a long time, JavaScript was deemed quirky and eccentric. Developers had to resort to convoluted programming practices and patterns to avoid the potholes presented by the language.

All of 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 make JavaScript more succinct and 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 now in need of refactoring. By updating your code to use modern JavaScript constructs, you’ll make your code more clear, maintainable, and explicit, with fewer hidden bugs. This workshop will help you take your first steps toward modernizing your JavaScript code.

This workshop has some set up required prior to us getting started, so please follow the instructions in the README file of this repository prior to attending this workshop: https://github.com/looselytyped/refactoring-to-modern-javascript

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.

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

See Highlights of
Wurreka

Hear What Attendees Say

“Once again Wurreka has knocked it out of the park with interesting speakers, engaging content and challenging ideas. No jetlag fog at all, which counts for how interesting the whole thing was."

Cybersecurity Lead, PwC

“Very much looking forward to next year. I will be keeping my eye out for the date so I can make sure I lock it in my calendar"

Software Engineering Specialist, Intuit

“Best conference I have ever been to with lots of insights and information on next generation technologies and those that are the need of the hour."

Software Architect, GroupOn

Hear What Speakers & Sponsors Say

“Happy to meet everyone who came from near and far. Glad to know you've discovered some great lessons here, and glad you joined us for all the discoveries great and small."

Scott Davis, Web Architect & Principal Engineer, ThoughtWorks

“What a buzz! The events have been instrumental in bringing the whole software community together. There has been something for everyone from developers to architects to business to vendors. Thanks everyone!"

Voltaire Yap, Global Events Manager, Oracle Corp.

“Wonderful set of conferences, well organized, fantastic speakers, and an amazingly interactive set of audience. Thanks for having me at the events!"

Dr. Venkat Subramaniam, Founder - Agile Developer Inc.