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. You can reach him by email at venkats@agiledeveloper.com or on twitter at @venkat_s.
Presentations
Programming with Kotlin
9:00 AM MDT
Kotlin is one of those few multi-platform languages. You can compile Kotlin to Java bytecode, to Android, to WebAssembly, to run native on different OS, and to JavaScript. The language draws inspiration from many different languages. It is highly fluent and code in Kotlin is concise, elegant, and easy to maintain. This workshop will get you up to speed on using Kotlin for your day-to-day programming.
The workshop will start with the language basics and quickly dive into some of the more advanced features. We will also look at ways to use compile time metaprogramming and create fluent DSLs.
The Evolution of Java: 9, 10, 11, and 12
8:30 AM MDT
Java is a language in evolution. There are a handful of language changes in Java 9 and 10 plus several JDK changes in 9, 10, 11, and 12. Some of these changes are significant in that they allow us to do things more effectively than before. The difference can be anywhere from reducing code to avoiding errors that come from verbosity. In this presentation we will explore the language changes first. Then we will visit the additions to the JDK. Along the way we will also look at a few things that have been removed from Java as well.
.
Continuations and Fibers: The New Frontier for Java
10:30 AM MDT
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.
.
Migrating to Java Modules: Why and How
1:00 PM MDT
Java Modules are the future. However, our enterprise applications have legacy code, a lots of it. How in the world do we migrate from the old to the new? What are some of the challenges. In this presentation we will start with an introduction to modules and learn how to create them. Then we will dive into the differences between unnamed modules, automatic modules, and explicit modules. After that we will discuss some key limitations of modules, things that may surprise your developers if they're not aware of. Finally we will discuss how to migrate current applications to use modules.
.
Type Inference in Java: Dos and Don'ts
2:45 PM MDT
Some developers simply hate type inference. And then there others who love it. Neither one of them is entirely right. In Java we have been making extensive use of type inference for several years without realizing it. The introduction of “var” in Java 10 has stirred up some surprising debate. In this presentation we will step back and review type inference in Java. Then we will dive deep into type inference in Java 10 and 11. We will wrap up the presentation will good recommendations on when to use type inference and when to avoid it.
.
Learning To Code In Functional Style with Java
4:30 PM MDT
Functional style of programming was introduced in Java 8. If you are like the speaker, who spent decades on imperative style, then the transition to functional style can be intimidating. In this presentation, we will learn about the fundamentals of programming in functional style, the set of tools that we can reach into to solve problems as a series of state transformation. We will learn the how but also the benefits along the way as well.
.
Exploring Modern JavaScript
9:00 AM MDT
JavaScript has come a long way. Libraries and frameworks like React, Angular, and Vue use the more recent versions of JavaScript. Getting up to speed will help us get better at programming both front-end and backend JavaScript applications.
The workshop will dive into the features from ES 6 and beyond.
Exploring Modern JavaScript
11:00 AM MDT
JavaScript has come a long way. Libraries and frameworks like React, Angular, and Vue use the more recent versions of JavaScript. Getting up to speed will help us get better at programming both front-end and backend JavaScript applications.
The workshop will dive into the features from ES 6 and beyond.
Creating React Applications
1:30 PM MDT
This workshop will bring you up to speed on the essentials to create React applications.
The workshop will start with a quick introduction to the main problems that React solves, and then walk you through the steps to create components, to mange state, and to do automated testing.
Creating React Applications
3:15 PM MDT
This workshop will bring you up to speed on the essentials to create React applications.
The workshop will start with a quick introduction to the main problems that React solves, and then walk you through the steps to create components, to mange state, and to do automated testing.
Taking Polyglot Programming to the next level with GraalVM
5:00 PM MDT
For those programmers aspiring to be polyglot, there's a virtual machine that's all polyglot. In this presentation you can learn about GraalVM, what it's for, the benefits it offers, and where you may use it.
.
Core Software Design Principles
9:00 AM MDT
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.
Qualities of a Highly Effective Architect
10:45 AM MDT
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.
Applying Design Patterns
1:30 PM MDT
Learning about design patterns is not really hard. Using design patterns is also not that hard. But, using the right design pattern for the right problem is not that easy. If instead of looking for a pattern to use if we decide to look for the design force behind a problem it may lead to better solutions. Furthermore, with most mainstream languages supporting lambda expressions and functional style, the patterns appear in so many more elegant ways as well.
In this workshop we will start with a quick introduction of a few patterns. Then we will work with multiple examples—take a problem, delve into the design, and as we solve it, see what patterns emerge in the design. The objective of this workshop is to get a hands on experience to prudently identify and use patterns that help create extensible code.
Applying Design Patterns
3:15 PM MDT
Learning about design patterns is not really hard. Using design patterns is also not that hard. But, using the right design pattern for the right problem is not that easy. If instead of looking for a pattern to use if we decide to look for the design force behind a problem it may lead to better solutions. Furthermore, with most mainstream languages supporting lambda expressions and functional style, the patterns appear in so many more elegant ways as well.
In this workshop we will start with a quick introduction of a few patterns. Then we will work with multiple examples—take a problem, delve into the design, and as we solve it, see what patterns emerge in the design. The objective of this workshop is to get a hands on experience to prudently identify and use patterns that help create extensible code.
Books
Test-Driving JavaScript Applications: Rapid, Confident, Maintainable Code
by Venkat Subramaniam
Debunk the myth that JavaScript is not easily testable. Whether you use Node.js, Express, MongoDB, jQuery, AngularJS, or directly manipulate the DOM, you can test-drive JavaScript. Learn the craft of writing meaningful, deterministic automated tests with Karma, Mocha, and Chai. Test asynchronous JavaScript, decouple and properly mock out dependencies, measure code coverage, and create lightweight modular designs of both server-side and client-side code. Your investment in writing tests will pay high dividends as you create code that's predictable and cost-effective to change.
Design and code JavaScript applications with automated tests. Writing meaningful tests is a skill that takes learning, some unlearning, and a lot of practice, and with this book, you'll hone that skill. Fire up the editor and get hands-on through practical exercises for effective automated testing and designing maintainable, modular code.
Start by learning when and why to do manual testing vs. automated verification. Focus tests on the important things, like the pre-conditions, the invariants, complex logic, and gnarly edge cases. Then begin to design asynchronous functions using automated tests. Carefully decouple and mock out intricate dependencies such as the DOM, geolocation API, file and database access, and Ajax calls to remote servers.
Step by step, test code that uses Node.js, Express, MongoDB, jQuery, and AngularJS. Know when and how to use tools such as Chai, Istanbul, Karma, Mocha, Protractor, and Sinon. Create tests with minimum effort and run them fast without having to spin up web servers or manually edit HTML pages to run in browsers. Then explore end-to-end testing to ensure all parts are wired and working well together.
Don't just imagine creating testable code, write it.
What You Need:
A computer with a text editor and your favorite browser. The book provides instructions to install the necessary automated testing-related tools.
Pragmatic Scala: Create Expressive, Concise, and Scalable Applications
by Venkat Subramaniam
Our industry is moving toward functional programming, but your object-oriented experience is still valuable. Scala combines the power of OO and functional programming, and Pragmatic Scala shows you how to work effectively with both. Updated to Scala 2.11, with in-depth coverage of new features such as Akka actors, parallel collections, and tail call optimization, this book will show you how to create stellar applications.
This thorough introduction to Scala will get you coding in this powerful language right away. You'll start from the familiar ground of Java and, with easy-to-follow examples, you'll learn how to create highly concise and expressive applications with Scala. You'll find out when and how to mix both imperative and functional style, and how to use parallel collections and Akka actors to create high-performance concurrent applications that effectively use multicore processors.
Scala has evolved since the first edition of this book, and Pragmatic Scala is a significant update. We've revised each chapter, and added three new chapters and six new sections to explore the new features in Scala. You'll learn how to:
Safely manage concurrency with parallel collections and Akka actors
Create expressive readable code with value classes and improved implicit conversions
Create strings from data with no sweat using string interpolation
Create domain-specific languages
* Optimize your recursions with tail call optimization
Whether you're interested in creating concise, robust single-threaded applications or highly expressive, thread-safe concurrent programs, this book has you covered.
What You Need:
The Scala compiler (2.x) and the JDK are required to make use of the concepts and the examples in this book.
Functional Programming in Java: Harnessing the Power Of Java 8 Lambda Expressions
by Venkat Subramaniam
Intermediate level, for programmers fairly familiar with Java, but new to the functional style of programming and lambda expressions.
Get ready to program in a whole new way. Functional Programming in Java will help you quickly get on top of the new, essential Java 8 language features and the functional style that will change and improve your code. This short, targeted book will help you make the paradigm shift from the old imperative way to a less error-prone, more elegant, and concise coding style that's also a breeze to parallelize. You'll explore the syntax and semantics of lambda expressions, method and constructor references, and functional interfaces. You'll design and write applications better using the new standards in Java 8 and the JDK.
Lambda expressions are lightweight, highly concise anonymous methods backed by functional interfaces in Java 8. You can use them to leap forward into a whole new world of programming in Java. With functional programming capabilities, which have been around for decades in other languages, you can now write elegant, concise, less error-prone code using standard Java. This book will guide you though the paradigm change, offer the essential details about the new features, and show you how to transition from your old way of coding to an improved style.
In this book you'll see popular design patterns, such as decorator, builder, and strategy, come to life to solve common design problems, but with little ceremony and effort. With these new capabilities in hand, Functional Programming in Java will help you pick up techniques to implement designs that were beyond easy reach in earlier versions of Java. You'll see how you can reap the benefits of tail call optimization, memoization, and effortless parallelization techniques.
Java 8 will change the way you write applications. If you're eager to take advantage of the new features in the language, this is the book for you.
What you need:
Java 8 with support for lambda expressions and the JDK is required to make use of the concepts and the examples in this book.
Programming Groovy 2: Dynamic Productivity for the Java Developer (Pragmatic Programmers)
by Venkat Subramaniam
Groovy brings you the best of both worlds: a flexible, highly productive, agile, dynamic language that runs on the rich framework of the Java Platform. Groovy preserves the Java semantics and extends the JDK to give you true dynamic language capabilities. Programming Groovy 2 will help you, the experienced Java developer, learn and take advantage of the latest version of this rich dynamic language. You'll go from the basics of Groovy to the latest advances in the language, including options for type checking, tail-call and memoization optimizations, compile time metaprogramming, and fluent interfaces to create DSLs.
You don't have to leave the rich Java Platform to take advantage of Groovy. Groovy preserves Java's semantics and extends the JDK, so programming in Groovy feels like the Java language has been augmented; it's like working with a lighter, more elegant Java. If you're an experienced Java developer who wants to learn how Groovy works, you'll find exactly what you need in this book.
You'll start with the fundamentals of programming in Groovy and how it works with Java, and then you'll explore advanced concepts such as unit testing with mock objects, using Builders, working with databases and XML, and creating DSLs. You'll master Groovy's powerful yet complex run-time and compile-time metaprogramming features.
Much has evolved in the Groovy language since the publication of the first edition of Programming Groovy. Programming Groovy 2 will help you learn and apply Groovy's new features. Creating DSLs is easier now, and Groovy's already-powerful metaprogramming facilities have improved even more. You'll see how to work with closures, including tail call optimization and memoization. The book also covers Groovy's new static compilation feature.
Whether you're learning the basics of the language or interested in getting proficient with the new features, Programming Groovy 2 has you covered.
What You Need
To work on the examples in the book you need Groovy 2.0.5 and Java JDK 5 or higher.
Programming Concurrency on the JVM: Mastering Synchronization, STM, and Actors
by Venkat Subramaniam
More than ever, learning to program concurrency is critical to creating faster, responsive applications. Speedy and affordable multicore hardware is driving the demand for high-performing applications, and you can leverage the Java platform to bring these applications to life.
Concurrency on the Java platform has evolved, from the synchronization model of JDK to software transactional memory (STM) and actor-based concurrency. This book is the first to show you all these concurrency styles so you can compare and choose what works best for your applications. You'll learn the benefits of each of these models, when and how to use them, and what their limitations are.
Through hands-on exercises, you'll learn how to avoid shared mutable state and how to write good, elegant, explicit synchronization-free programs so you can create easy and safe concurrent applications. The techniques you learn in this book will take you from dreading concurrency to mastering and enjoying it. Best of all, you can work with Java or a JVM language of your choice - Clojure, JRuby, Groovy, or Scala - to reap the growing power of multicore hardware.
If you are a Java programmer, you'd need JDK 1.5 or later and the Akka 1.0 library. In addition, if you program in Scala, Clojure, Groovy or JRuby you'd need the latest version of your preferred language. Groovy programmers will also need GPars.
Practices of an Agile Developer: Working in the Real World (Pragmatic Bookshelf)
by Venkat Subramaniam and Andy Hunt
These are the proven, effective agile practices that will make you a better developer. You'll learn pragmatic ways of approaching the development process and your personal coding techniques. You'll learn about your own attitudes, issues with working on a team, and how to best manage your learning, all in an iterative, incremental, agile style. You'll see how to apply each practice, and what benefits you can expect. Bottom line: This book will make you a better developer.
.NET Gotchas
by Venkat Subramaniam
Like most complex tasks, .NET programming is fraught with potential costly, and time-consuming hazards. The millions of Microsoft developers worldwide who create applications for the .NET platform can attest to that. Thankfully there's now a book that shows you how to avoid such costly and time-consuming mistakes. It's called .NET Gotchas.The ultimate guide for efficient, pain-free coding, .NET Gotchas from O'Reilly contains 75 common .NET programming pitfalls--and advice on how to work around them. It will help you steer away from those mistakes that cause application performance problems, or so taint code that it just doesn't work right.The book is organized into nine chapters, each focusing on those features and constructs of the .NET platform that consistently baffle developers. Within each chapter are several "gotchas," with detailed examples, discussions, and guidelines for avoiding them. No doubt about it, when applied, these concise presentations of best practices will help you lead a more productive, stress-free existence.What's more, because code examples are written in both VB.NET and C#, .NET Gotchas is of interest to more than 75 percent of the growing numbers of .NET programmers. So if you're a .NET developer who's mired in the trenches and yearning for a better way, this book is most definitely for you.