Venkat Subramaniam

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.

Scala Koans - A new and fun way to learn a Scala programming language (Bring a Laptop)

Have you looked into Scala? Scala is a new object-functional JVM language. It is statically typed and type inferred. It is multi-paradigm and supports both object oriented and functional programming. And it happens to be my favorite programming language.

If you are interested in Scala, how you are planning to learn Scala? You probably are going to pick up a book or two and follow through some examples. And hopefully some point down the line you will learn the language, its syntax and if you get excited enough maybe build large applications using it. But what if I tell you that there is a better path to enlightenment in order to learn Scala?

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

Automated testing tools and techniques for JavaScript

Programmers often complain that it is hard to automate unit and acceptance tests for JavaScript. Testability is a design issue and with some discipline and careful design we can realize good
automated tests.

Taming Shared Mutability with Software Transactional Memory

Mutability is something we're quite used to in Java. Sharing is a good thing. However, shared mutability is pure devil's work. If we remove shared mutability, all the problems of concurrent go away. In practice, however, it's hard to completely get rid of shared mutability. This is where STM comes in with managed shared mutable variables. In this presentation we will take an example driven approach to dive deep into STM, look at what it has to offer, explore different implementations, and how we can design concurrent applications without any explicit locks.

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.

Grails beyond the Hello World

Grails is a powerful web development framework. You've heard and seen those demos that show how simple it is to create applications with it. But, you're not convinced. Your realities are not that simple, you have existing database to integrate with, you have existing applications to run side-by-side, and you're worried how flexible Grails is to meet those needs.

Integrating Groovy and JVM Languages

Java - Groovy integration just works, for most part. Calling into Java code from Groovy is pretty straight forward. Calling into Groovy from Java is easier than you may think (and that's the hard part!). There are a
few rough edges you will run into when you try to call from Groovy into other languages.

Creating DSLs in Groovy

Domain Specific Languages have two main characteristics, fluency and context. Creating external DSLs has the advantage of good validation. However, we have to struggle with parsers. Internal DSLs offer the benefit of using the language as the host and its compiler as the parser. For a language to be a host, it needs two important characteristics: low-ceremony and metaprogramming.

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. What if methods can collaborate rather than collide. Traits and mixins, in languages like Scala and Groovy, offer us some real nice design choices. These can be used to implement more elegantly some common design patterns.