Venkat Subramaniam

Founder of Agile Developer, Inc.

Venkat Subramaniam
 

Dr. Venkat Subramaniam is an award-winning author, founder of Agile Developer, Inc., 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 agile practices on their software projects.

Venkat is a (co)author of multiple books, including the 2007 Jolt Productivity award winning book Practices of an Agile Developer. His latest book is Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions. You can reach him by email at [email protected] or on twitter at @venkat_s.

Presentations

Programming with JavaScript – Method to Madness

Tue 9:00 AM

JavaScript is a powerful language with many capabilities. Yet, this is one of the most misused, feared, and often poorly utilized languages. In this hands-on workshop, we will demystify JavaScript. We will start with some of the fundamental dos and don’ts of this language, explore its dynamic capabilities, and learn to make use of its powerful prototypal inheritance.

Come prepared with your laptops to crank out some code and work along exercises.

Pragmatics of TDD to Evolve Design

Wed 8:30 AM

Test Driven Design, we hear is a great way to create lightweight design that is easier to maintain and evolve. Unfortunately, just writing test cases mechanically do not lead to good design. In fact, it may really not lead us anywhere we want to really go!

In this presentation we will discuss some of the challenges with using test driven development, look at practical and pragmatic solutions that will help us make a good use of this wonderful design tool.

Designing Reactive Systems: Creating Highly Responsive and Resilient Applications

Wed 10:30 AM

Organizations have moved from making their employees available to having their applications available directly to the users. This changes the magnitude of scale
of interactions the applications have to support. Furthermore, with devices and bots accessing the systems, we’re looking at a complete different rate of response than we once had to aim for.

In this presentation we will discuss the fundamentals of reactive systems, the key design goals, and the technologies that facilitate building such systems.

JavaScript Programming Idioms – Creating Elegant Code

Wed 1:30 PM

JavaScript code really does not have to suck. We can write some of the most elegant, concise, and expressive code in JavaScript. Use functional style, create
code that’s easier to understand and maintain.

Come to this presentation to pick up some idiomatic styles and better ways to write JavaScript.

Patterns for Programming in JavaScript

Wed 3:15 PM

The arguably most pervasive and ubiquitous language is the most misunderstood as well. If you’ve struggled with and eager to write better JavaScript, come to this presentation to learn about good styles and patterns that can make your next JavaScript code shine. We will start by looking at some ways to make code reusable and reduce errors.

Then we will take a look at some common design patterns, using some concrete examples.

Programming with Elm—A Functional Reactive UI Language

Wed 5:00 PM

Elm is special. It’s a pretty unique language in many ways. In this presentation we will learn about the key capabilities of this language and how to create highly responsive and reactive UI code that runs right in your browser.

Features like immutability and type inference help you write code that is short, fast, and maintainable. Elm makes them easy to learn too.

The Future of JavaScript—What’s Brewing

Wed 8:00 PM

For a language of such extreme popularity, JavaScript has way too many flaws. It’s time for the language to finally mature, to learn from good styles of programming that has gained prevalence in other languages.

In this presentation we will learn about what’s brewing, how JavaScript is changing, how that matters to programmers who heavily rely on this language.

A Practical Introduction to AngularJS

Thu 9:00 AM

What’s a better way to learn about a library than actually building an application with it? In this all live-coding, zero powerpoint presentation, we will take up an application and build it using AngularJS. Along the way, we will learn about various aspects of this wonderful library, it’s capabilities, strengths, and good practices.

At the end of this session you will learned how to be hands on and create your own applications with Angular.

Automated Testing AngularJS from the ground up

Thu 11:00 AM

When it comes to automated testing, there are haves and have-nots. That is those who have the discipline and those who don’t-to perform automated testing. Many have given uncountable excuses as to why JavaScript related projects can’t be automated tested. But, those are just that excuses. In this presentation, we will take a step-by-step approach to creating an application fully test driven. Instead of taking theory, we will quickly get into the nitty gritty details of automated testing through a practical example, get into a bit of complexity, and resolve our way with effective and practical testing techniques.

After this session, you will be able to automated your projects and also help convince those out there who still need convincing.

Caring about your JavaScript Code Quality

Thu 1:30 PM

JavaScript is one of the most widely used languages. Substantial code in enterprise applications now reside in JavaScript. Unfortunately, JavaScript code is also synonymous to poor quality code. That’s a big risk. Thankfully, it’s not really that hard to create better quality JavaScript, if we pay just a little bit of attention. In this presentation we will take examples of code that represents both good quality and bad quality, discuss the benefits or the issues, as the case may be.

We will also look at coding practices and tools that can help us create better quality JavaScript.

JavaScript—The Fun and Useful Parts

Thu 8:00 PM

JavaScript is one of the most powerful and arguably the most widely used languages. Yes it has gained a poor reputation, something it really does not deserve. Once we take the time to learn the really fun and useful parts of this language, we gain a greater respect for the language and a genuine desire to make better use of it.

In this presentation we will focus on the parts of JavaScript that are often underutilized and even unheard of, but offer quite some benefit to those who take time to explore.

Measuring Quality of design (1/2 day workshop)

Fri 9:00 AM

Before spending substantial effort in refactoring or altering design, it would be prudent to evaluate the current quality of design. This can help us decide if we should proceed with refactoring effort or a particular alteration of design. Furthermore, after evolving a design, using some design metrics would help us to evaluate if we have improved on the design front.

In this workshop we will learn about some critical qualities of design and how to measure those. We will learn about these by working through some example code, refactoring it, and evaluating the design again at each stage of refactoring.

Measuring Quality of design (1/2 day workshop)

Fri 10:45 AM

Before spending substantial effort in refactoring or altering design, it would be prudent to evaluate the current quality of design. This can help us decide if we should proceed with refactoring effort or a particular alteration of design. Furthermore, after evolving a design, using some design metrics would help us to evaluate if we have improved on the design front.

In this workshop we will learn about some critical qualities of design and how to measure those. We will learn about these by working through some example code, refactoring it, and evaluating the design again at each stage of refactoring.

Towards an Evolutionary Architecture

Fri 1:30 PM

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.

Core Software Design Principles

Fri 3:15 PM

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.

Books

Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine (Pragmatic Programmers)

by Venkat Subramaniam

Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine (Pragmatic Programmers) Buy from Amazon
List Price: $34.95
Price: $29.61
You Save: $5.34 (15%)
  • Scala is an exciting, modern, multi-paradigm language for the JVM. You can use it to write traditional, imperative, object-oriented code. But you can also leverage its higher level of abstraction to take full advantage of modern, multicore systems. Programming Scala will show you how to use this powerful functional programming language to create highly scalable, highly concurrent applications on the Java Platform.

    The increasing popularity and availability of multicore processors is creating a whole new set of challenges–although you can enjoy true concurrency, you’re now faced with higher contention and synchronization issues. Deploying an existing application on a multicore processor may bring out previously hidden concurrency issues. Java’s multi-threading facility by itself isn’t enough—it’s a very low level abstraction. Instead, you need a paradigm that provides a higher level of abstraction to deal with concurrency. It’s time to embrace Functional Programming.

    Scala is a hybrid Object-Oriented/Functional Programming language on the JVM. Using Scala, you can create traditional imperative programs, intermix them with Java code, and at the same time take advantage of higher levels of abstraction. You can use features that lead to concise, highly expressive code that remove the pain of dealing with concurrency.

    Programming Scala will show you the fundamentals of functional programming using Scala. Very quickly, you’ll learn how this statically typed language can give you dynamic capabilities to create concise, scalable, highly capable concurrent code.

    Pragmatic programmers always use the right tool for the job. For concurrent programming on the Java VM, Scala is the tool, and Programming Scala by award-winning author Venkat Subramaniam is your guide.


Programming Groovy: Dynamic Productivity for the Java Developer (Pragmatic Programmers)

by Venkat Subramaniam

Programming Groovy: Dynamic Productivity for the Java Developer (Pragmatic Programmers) Buy from Amazon
Price: $34.95
  • The strength of Java is no longer in the language itself; it’s in the Java Platform (the JVM, JDK, and rich frameworks and libraries). But recently, the industry has turned to dynamic languages for increased productivity and speed to market.

    Groovy is one of a new breed of dynamic languages that run on the Java platform. You can use these new languages on the JVM and intermix them with your existing Java code. You can leverage your Java investments while benefiting from advanced features including true Closures, Meta Programming, the ability to create internal DSLs, and a higher level of abstraction.

    If you’re an experienced Java developer, Programming Groovy will help you learn the necessary fundamentals of programming in Groovy. You’ll see how to use Groovy to do advanced programming including using Meta Programming, Builders, Unit Testing with Mock objects, processing XML, working with Databases and creating your own Domain-Specific Languages (DSLs).


Practices of an Agile Developer: Working in the Real World (Pragmatic Bookshelf)

by Venkat Subramaniam and Andy Hunt

Practices of an Agile Developer: Working in the Real World (Pragmatic Bookshelf) Buy from Amazon
List Price: $29.95
Price: $22.73
You Save: $7.22 (24%)
  • Want to be a better developer? This books collects the personal habits, ideas, and approaches of successful agile software developers and presents them in a series of short, easy-to-digest tips. This isn’t academic fluff; follow these ideas and you’ll show yourself, your teammates, and your managers real results. These are the proven and effective agile practices that will make you a better developer.

    This book will help you improve five areas of your career:

    • The Development Process
    • What to Do While Coding
    • Developer Attitudes
    • Project and Team Management
    • Iterative and Incremental Learning


    These practices provide guidelines that will help you succeed in delivering and meeting your user’s expectations, even if the domain is unfamiliar. You’ll be able to keep normal project pressure from turning into disastrous stress while writing code, and see how to effectively coordinate mentors, team leads, and developers in harmony.

    You can learn all this stuff the hard way, but this book can save you time and pain. Read it, and you’ll be a better developer.


.NET Gotchas

by Venkat Subramaniam

.NET Gotchas Buy from Amazon
Price: $39.95
  • 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.