Venkat Subramaniam

By Venkat Subramaniam
In this presentation we will take a look at what BDD is and look at tools
to create them in Java and Groovy.

What's BDD?
Benefits of BDD
Tools for BDD
Creating BDD in Java
Creating BDD in Groovy

By Venkat Subramaniam
Functional Programming Languages (FPLs) have been around for a long time. A lot of features that we get excited about
in dynamic languages are common place in FPLs. FPLs are gaining importance due to various changes in our industry. What's exciting is that you can use them on the JVM. In this presentation we will dig into the details of what makes FPLs so interesting and look at ways to use them on the JVM?in your Java projects.

What's Functional Programming?
Why is Functional Programming suddenly important?
Features of Functional Programming
Functional Programming Languages
JVM and FPLs
Examples of Functional Programming features
Examples of mixing Java and FPLs

By Venkat Subramaniam
In this presentation we will take a look at Google's dependency injection framework,
discuss its features, capabilities, strengths, and weakness. We will then discuss where it
stands in comparison to Spring.

What's Guice?
Features of Guice
Using Guice
Comparison to Spring

By Venkat Subramaniam
Groovy's dynamic capabilities makes it an attractive language for Meta Programming.
There are several facilities to intercept method calls to do AOP kind of operations.
You can also inject methods dynamically. You can also easily perform method synthesis as well.
In this presentation we will take a look at techniques that make Groovy pretty Hip for MOP.

Exploring MOP
Understanding Groovy's method handling mechanism
Accessing methods and properties dynamically
Method interception
Method injection
Method synthesis
Method delegation
Applying MOP to real world projects

By Venkat Subramaniam
You're most likely familiar with the Gang-of-four design patterns and how to implement them in Java. However, you wouldn't want to implement those patterns in a similar way in Groovy. Furthermore, there are a number of other useful patterns that you can apply in Java and Groovy. In this presentation we'll look at two things: How to use patterns in Groovy and beyond Gang-of-four patterns in Groovy and Java.

Patterns overview
Implementing common patterns in Groovy
Beyond Gang-of-four patterns in Java and Groovy
Lots of examples

By Venkat Subramaniam
You have worked on software projects with varying degree of success. What were the reasons for the success of your last project? What were the reasons for those that failed? A number of issues contribute to project success - some non-technical in nature. In this presentation the speakers will share with you practices in a number of areas including coding, developer attitude, debugging, and feedback. The discussions are based on the 2007 Jolt productivity award winning book with the same title as the talk.



In this session you will learn about practices beyond what well know methodologies prescribe. While we reemphasize some popular practices, we will also discuss other often overlooked, but important practices - practices that contribute to success of projects.

By Venkat Subramaniam
A good design is critical for success with agile development.
That does not mean a big up-front design. The design has to
be evolutionary. However, the design you evolve must be
extensible and maintainable. After all, you can't be agile
if your design sucks.

In this presentation, we will address
what evolutionary design is, and will delve into principles
and practices that can help realize an effective evolutionary design.

By Venkat Subramaniam
Unit Testing is easy if the object you're testing has no dependencies. In reality, however, objects have dependencies,
often making it difficult, if not impossible, to automate tests. Mock objects can help deal with these dependencies
and allow you to automate your tests.

In this presentation you'll learn what mocks are, the difference between mocks
and stubs, how to hand toss mock objects, how to approach testing with deeper dependencies, and also how to use tools and framework that can help you with mocking.

By Venkat Subramaniam
Begin agile is more than saying your organization is committed to being agile or your team is agile.

In this presentation we will delve into the details of what "Being Agile" really means, why you should
be agile, what are some of the fundamental practices?at team and organizational level?you need to consider
to be successful with agility.

By Venkat Subramaniam
The first item in the Agile Manifesto reads that we must prefer "people and interaction over process and tools."
Given a choice between average people with superior tools and superior people with average tools, you are likely
to achieve greater success with the latter. However, it is important to be continuous and not be episodic?so you
want to get continuous feedback about the state, health, and quality of your code and application. Tools can
help us a great deal to realize this and make us productive.

In this presentation we will take a look at
tools (and their relevance and value) that can help smoothly execute your projects.

By Venkat Subramaniam
Projects often start out simple, but soon become complex and turn into a lose cannon.
Organizations are struggling to maintain and evolve software. Poor code quality is a
significant part of that problem. Improving the quality of code is critical to success
of enterprise projects.

In this presentation we will discuss ways to identify code smell. We will discuss several
code smells and how to clean it up. We will also discuss proactive ways to avoid that smell
in the first place.

By Venkat Subramaniam
Groovy brings the dynamic productivity to the Java platform. One of the strengths of Groovy is the seamless integration with Java–it preserves the Java semantics. However, Groovy does have some differences that can surprise you if you're not expecting.

In this Jeopardy style presentation, you will pick topics you'd like to discuss and we will understand the strengths and differences Groovy brings in those areas.

By Venkat Subramaniam
Domain Specific Languages (DSLs) are languages targeted at a particular problem and domain. They have context and are fluent. They help users of applications at various levels to easily communicate with your application. Developing DSLs, however, are not easy. You could easily get dragged into using parsers and tools with steep learning curve.

In this presentation, we will look at various options to create DSLs on the Java platform. We will focus on external DSLs–these give you the absolute flexibility to chose syntax, but involve the most work as well. We will look at various tools and techniques that can ease this development effort.

By Venkat Subramaniam
Scala is a static fully object-oriented, functional language on the JVM. While taking advantage of the functional aspects, you can continue to make full use of the powerful JVM and Java libraries.

In this presentation we will take a in depth look at what Scala is, its strengths, weaknesses, and why, when, and where you'd use it on your applications.

By Venkat Subramaniam
Java is a well established language, that has been around for more than a decade. Yet, programming on it has its challenges. There are concepts and features that are tricky. When you run into those, the compiler is not there to help you.

In this presentation we will look at various concepts that you will use in general programming with Java. We will discuss the issues with those and how you can improve your code. We will look at concepts you can do better and those you should outright avoid.

By Venkat Subramaniam
Testing is a key ingredient to the success of a project. However, testing becomes awfully hard when your application deals with dependencies and that is often the reality.

In this presentation we will discuss how to approach testing when the code has dependencies. We will discuss tools, techniques, languages, and principles that can help decouple, mock, and help us effectively test your application code.

By Venkat Subramaniam
How is testing done on agile projects? Do we need testers when programmers can write tests? When do we do test? If the requirements are evolving, should we postpone testing until they stabilize?

This presentation will address how you can approach testing in agile projects. We will discuss the role of programmers and testers in testing, the tools and techniques they can use. We will discuss when testing can start and how it can proceed. This session is intended for both programmers and testers who are actively involved in agile projects.