Venkat Subramaniam
Founder of Agile Developer, Inc.
Dr. Venkat Subramaniam, founder of Agile Developer, Inc., has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia. Venkat helps his clients effectively apply and succeed with agile practices on their software projects, and speaks frequently at international conferences and user groups. Venkat is also an adjunct faculty and teaches CS courses remotely at the University of Houston. He is author of ".NET Gotchas," coauthor of 2007 Jolt Productivity Award winning "Practices of an Agile Developer," author of "Programming Groovy: Dynamic Productivity for the Java Developer" and "Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine" (Pragmatic Bookshelf).
Video
Blog
ASP.NET MVC In Action
Posted Saturday, September 19, 2009
I often get asked "Which web development framework should I use?" The answer generally depends on when I'm asked that question. Over the years I have played with, offered courses more »Speaking at SpringOne 2GX 2009
Posted Tuesday, September 15, 2009
I'm excited about the 2GX conference coming up in New Orleans October 19th to 22nd. If you're interested in attending, the early bird registration ends Friday September 18thmore »Chat with Scott Davis on Scala and Groovy
Posted Tuesday, August 18, 2009
I recently had the pleasure of chatting with Scott Davis during an NFJS stop in Phoenix. At the start of the interview, Scott surprised me with the question "Does Groovy know that more »How to convince your fellow developer to write short methods?
Posted Monday, May 18, 2009
I'm sure you've seen your share of long methods—methods that run several hundred lines. Some of us may have even written them, probably in those days before we gained our wisdom to write bettmore »Programming Scala Beta Release
Posted Saturday, April 4, 2009
I'm delighted to announce the Beta Release of the Programming Scala book. The topics covered in the book are: more »NFJS 2009 Tour Starts Next Week!
Posted Thursday, February 19, 2009
I am delighted that the NFJS 2009 Tour starts next week! I will be in Milwaukee next weekend and several other cities though the year. I can't wait to interact with the smart developmore »Presentations
Using Groovy AST Transformations
The ability to navigate and even alter the abstract syntax tree of your code is very powerful and yet under utilized. Quite a few tools have exploited this capability in Groovy. These techniques can be useful to create fluent syntax and validate DSLs.more »
Programming Clojure
Clojure is an exciting language on the JVM for several reasons. It brings the power of functional programming and the characteristics of dynamic typing into a single fold. It is a language that has done quite a few things right.more »GPars deep dive
Programming concurrency can be a pain or a pleasure depending on how you approach it. GPars is an elegant fluent library written with Java performance and Groovy conciseness and expressiveness in mind. more »Design Patterns in Groovy
When I got into Java I had a "Wow, look how easy it is to implement these patterns." When I got into Groovy, I had the same reaction, but only better. The dynamic nature of Groovy makes it easier to implement some common patterns.more »Scala for the Intrigued
Scala is a statically typed, fully OO, hybrid functional language that provides highly expressive syntax on the JVM. It is great for pattern matching, concurrency, and simply writing concise code for everyday tasks. If you're a Java programmer intrigued bmore »Rediscovering JavaScript
JavaScript is one of those very powerful languages that is often misunderstood and underutilized. It's quite popular, yet there's so much more we can do with it. more »CoffeeScript for recovering JavaScript programmers
Saying JavaScript is powerful is an understatement. The problem is it is way too powerful and dangerously flexible. Programmers often have trouble reaping its benefits due to its uncontrolled flexibility and, to a certain extent, lack of structure.more »Paradigms of Programming—Developing a taste for the language flavors
Programmers mostly familiar with one language and one paradigm of programming are at a significant disadvantage. They're forced to think within the confines of a single way of doing things. More than learning different languages, it is important to learn more »Programming with HTML 5
Developing a rich user interface for web applications is both exciting and challenging. HTML 5 has closed the gaps and once again brought new vibe into programming the web tier. Come to this session to learn how you can make use of HTML 5 to create stellamore »Programming Concurrency with Akka
I call the JDK concurrency API as the synchronize and suffer model. Fortunately, you don't have to endure that today. You have some nice options, brought to prominence on the JVM by Scala and Clojure.more »Tail call optimization and Memoization Techniques
Recursion is a highly expressive technique that's common in divide and conquer strategy and also in dynamic programming. Modern JVM languages like Clojure, Scala, and Groovy offer techniques to optimize recursion and also to facilitate dynamic programmingmore »Using Traits and Mixins in JVM Languages
Java eliminated quite a bit of complexity by eliminating multiple inheritance (MI). But that also meant we lost some design capabilities. The primary problem with MI was method collisions.more »Understanding the "NO" in NoSQL
Relational databases have ruled the world since the dawn of time (or so it appears). They power our enterprises and for many in the corporate world, it may be hard to imagine life without them. Each decade a novel idea would challenge the status quo and mmore »Picking a JVM Language, which one is right for you?
Over the past few years a few JVM languages have gained adoption. Suppose on your next project, you're asked to use an alternate language. Which one would you pick?more »Java 8 Language Capabilities - What's in it for you?
There is a good amount of excitement about the new version of Java. The big evolution of course is the lambda expressions. In this presentation we will dive into the language features in Java 8, take a look at some of their nuances, and look at ways to pumore »10 Commandments of Technical Presentations
We all have to do that at some point, giving presentations, to a group of audience, in public or at work. You've seen presentations and most likely have given some. You've prepared well on the technical topic, yet you're nervous presenting it.more »HTML 5 Animations - building true richness on the web
User experience and rich interaction is top in the list of things that influence the success and adoption of applications. Such richness and interactions were owned by desktop and native applications in the past. Over the recent years the web has become imore »Developing Offline Applications with HTML 5
Mobile devices are gaining popularity but the diversity of these devices poses a challenge for development. HTML 5 promises to bring a consistent API to program the client side for both desktop and diverse mobile devices. One additional challenge with mobmore »Asynchronous programming with JavaScript
Part of creating rich applications is making them highly responsive. No one wants to wait for a full page to load and display or watch the spinning beach-ball. A few seconds delay is equivalent to eternity in user experience.more »Sever-side programming with JavaScript
JavaScript is the dark horse of programming languages. It's one of the most misunderstood languages and yet most pervasive in client-side web development. This adolescent language is gaining recognition once again, but surprisingly in server side programmmore »Programming with Lambda Expressions
Now that Java is supporting lambda expressions, it's time to hone our skills to make use of them. Lambda expressions can help create concise code, however, it takes more than learning the syntax to put them to good use. more »Demystifying invokedynamic
Invoke dynamic is a Java 7 feature that had the most impact at the bytecode level and also in terms of performance. First perceived as a feature to help dynamically typed languages on the JVM, it turned into a powerful feature that has been exploited quitmore »A dozen cool things we can do with popular JVM Languages
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 optimizatimore »The Art of Simplicity
We've been told to keep things simple. It turns out, that's easily said than done. Creating something simple is, well, not really that simple.more »Applying Groovy Closures for fun and productivity
You can program higher order functions in Groovy quite easily using closures. But the benefits of closures go far beyond that. Groovy has a variety of capabilities hidden in closures.more »Concurrency without Pain in Pure Java
Programming concurrency has turned into a herculean task. I call the traditional approach as the synchronized and suffer model. Fortunately, there are other approaches to concurrency and you can reach out to those directly from your Java code.more »Venkat's NFJS Schedule
Books
Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine (Pragmatic Programmers)
by Venkat Subramaniam
Price: $13.49
You Save: $21.46 (61%)
-
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
Price: $21.66
You Save: $13.29 (38%)
-
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
Price: $19.87
You Save: $10.08 (34%)
-
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
Price: $27.04
You Save: $12.91 (32%)
-
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.
