Venkat Subramaniam

Founder, Agile Developer, Inc

Dr. Venkat Subramaniam is an award-winning author, founder of Agile Developer, Inc., creator of agilelearner.com, and an instructional professor at the University of Houston

He has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia, and is a regularly-invited speaker at several international conferences. Venkat helps his clients effectively apply and succeed with sustainable agile practices on their software projects.

Venkat is a (co)author of multiple technical books, including the 2007 Jolt Productivity award winning book Practices of an Agile Developer. You can find a list of his books at agiledeveloper.com. Find him on twitter at @venkat_s.

 

Talks on Wurreka:

Many developers aspire to become architects. Some of us serve currently as architects while the rest of us may hope to become one some day. We all have worked with architects, some good, and some that could be better. What are the traits of a good architect? What are the skills and qualities we should pick to become a very good one? Come to this presentation to learn about things that can make that journey to be a successful architect a pleasant one.

Creating code is easy, creating good code takes a lot of time, effort, discipline, and commitment. The code we create are truly the manifestations of our designs. Creating a lightweight design can help make the code more extensible and reusable. In this presentation we will take an example oriented approach to look at some core design principles that can help us create better design and more maintainable code.

Big up front design is discouraged in agile development. However, we know that architecture plays a significant part in software systems. Evolving architecture during the development of an application seems to be a risky business. In this presentation we will discuss the reasons to evolve the architecture, some of the core principles that can help us develop in such a manner, and the ways to minimize the risk and succeed in creating a practical and useful architecture.

MicroServices, that is the new rage. Many companies want to split their monoliths into microservices. With every single technology, the adoption goes through cycles: we learn about it, do it wrong, learn from the mistakes (hopefully from others more than our own), and get better at using it. In this presentation we will learn about some dos and donts for microservices. We will focus on principles that we should follow to effectively build microservices, things that will give us better results, and avoid issues in development and maintenance.

Transitioning from a monolith to a microservices based architecture is a non-trivial endeavor. It is mired with many practices that may lead to a disastrous implementation if we're not careful. In this presentation we will discuss some core practices and principles that are critical to follow to effectively transition from a monolith to a microservices based architecture.

A number of developers and organizations are beginning to make use of Functional Programming in Java. With anything that's new, we often learn it the hard way. By stepping back and taking a look at programming style as idioms, we can quickly gravitate towards better coding style and also avoid some common traps that we often get drawn towards.

We will program with Java quite differently in the future than we do today. The reason is that Java is embracing asynchronous programming like never before. This will have a huge impact on how we create services and web applications. In this presentations we will look at what asynchronous programming is, what continuations are, how they get implemented under the hood, and how we can benefit from them.

One of the most intriguing classes in the JDK is the Collectors utility class, with a collection of some highly powerful functions that are useful during the reduce operation of streams. The functions that are in this class have so much to offer and yet, due to their complex nature, often are not used as much as they should be. Using well defined live coded examples, we will take up several common programming problems. Discuss them quickly and drive the implementation of these using the Collectors' methods. By the end of this presentation you will know more throughly the power of Collectors and how to apply the methods in there.

Reactive Programming is receiving quite a bit of attention and for good reasons. It's a nice logic next step from functional programming. It takes the concept of function composition and lazy evaluations to the next level. It streamlines handling of many critical issues that are architectural in nature: resilience, scale, responsiveness, and messaging. In this workshop, we will start with a quick introduction to reactive programming. We will then dive into code examples and learn how to create reactive applications. We will learn to implement observables, to deal with errors in a graceful manner, learn both synchronous and asynchronous solutions, hot vs. cold observables, and dealing with backpressures.

Modern JavaScript has come a long way. It is elegant, fluent, and does several things right. To program React applications, you'll use many of the features from the new generation of JavaScript. This presentation will help you hone in on the features of JavaScript that you will rely heavily to create applications using this powerful language.

Rich web applications have to be interactive but must also be usable on mobile devices. In this presentation we will see how to create interactive applications, with client side state, server side interaction, and that can scale properly for both desktop browsers and browsers on mobile devices.

There are good reasons to use Angular and there are separate good reasons to use React. But, are there reasons to mix them? If so, why and in what way would we want to mix them. This presentation will discuss the does and don'ts for using React with Angular and, using examples, illustrate how to carry out that task of using them together.

Very many good books on OO design have advised us to choose delegation over inheritance. Yet, most developers using OO languages like Java use inheritance predominantly compared to delegation. Part of the reason is the lack of support for delegation when compared to inheritance. In this presentation we will see how Kotlin has first class support for delegation. We will look at how delegation helps us better model relationships and take a look at some usecases of applying delegates in Kotlin.

In this presentation we explore the types in Kotlin, how Kotlin promotes a much better compile time type safety and how we can leverage that during development.

Languages offer a lot more than syntax and compilers. They often have supporting libraries and special facilities that set them apart from other languages. Some languages offer special compiler support for a particular construct, like tail call optimization, for example. Others provide interesting library support or capabilities. In this presentation we will dive into 12 cool things we can do with different languages on the JVM, things that are either impossible or hard to do in Java, but are quite easy and useful to realize in other popular languages on the JVM. If mixing these languages is an option on your projects, you'll have dozen more reasons after this presentation. Languages used: Java, Scala, Groovy, Kotlin.

As leaders we want our teams to pursue great ideas and change directions to realize the goals. However, often we find it hard to implement changes. At times there seems to be resistance or at least reluctance to change. Why can't the team see the benefits of where we're headed and move fast to realize the goals?

Let's step back to look at the challenges of effecting change and how we can lead teams towards successful transition.

Executing a software project has many challenges. For a team to function smoothly and deliver working solution we have to constantly look for impediments and find ways to resolve them.

In this presentation we will discuss how to proactively engage the team in identifying impediments, recognize what's going well, and understand what needs improvement. Then discuss ways to implement and measure the progress the team makes.

As a software development manager or a technical leader you are eager to remove impediments so your team can produce continuous results. Instilling a few technical practices can have significant impact on your teams ability to deliver continuous results. In this presentation we will cover the what, why, and how of essential technical practices that take time and effort but they result in saving significant cost and time in the long run.

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.