Scala runs on the JVM, can use and be used by Java code almost transparently. Scala's speed and focus on concurrency well position it for demanding server side applications.

This session is for those who consider using Scala in their existing Java projects. We’ll discuss how to smoothly integrate Scala into an existing Java build, testing, development and runtime systems.

In this session we will talk about how to deal with the learning curve, IDE integrations and the peopleware aspects of introducing Scala to your organization.

The session will include examples and anecdotes from the kaChing and LinkedIn teams who use Scala in production.

http://eng.kaching.com/search/label/scala

In this session, we will present real life applications of compiler techniques helping kaChing achieve ultra confidence and power its incredible 5 minutes commit-to-production cycle [1]. We'll talk about idempotency analysis [2], dependency detection, on the fly optimisations, automatic memoization [3], type unification [4] and more! This talk is not suitable for the faint-hearted... If you want to dive deep, learn about advanced JVM topics, devoure bytecode and see first hand applications of theoretical computer science, join us.

[1] http://eng.kaching.com/2010/05/deployment-infrastructure-for.html

[2] http://en.wikipedia.org/wiki/Idempotence

[3] http://en.wikipedia.org/wiki/Memoization

[4] http://eng.kaching.com/2009/10/unifying-type-parameters-in-java.html

This demonstration and code walkthrough of a simple Scala/Lift Web application aims to educate about Scala and the Lift Web application framework by example.

This will be an expansion of the shorter talk shown here: http://www.slideshare.net/dcbriccetti/birdshow-a-lift-app-for-showing-flickr-photos-2720594

Some experience with Scala and Java would be helpful, but is not required.

• *laptop with internet connection
• *content for about me page
• *content for contact page
• *content for home page or blog entries

At kaChing (www.kaching.com), we are on a 5-minute commit-to-production cycle. We have adopted continuous deployment as a way of life and as the natural next step to continuous integration.

In this talk, I will present how we achieved the core of our extreme iteration cycles: test-driven development or how to automate quality assurance. We will start at a very high level and look at the two fundamental aspects of software: transformations, which are stateless data operations, and interactions, which deal with state (such as a database, or an e-mail server). With this background we will delve into practical matters and survey kaChing's testing infrastructure by motivating each category of tests with different kind of problems often encountered. Finally, we will look at software patterns that lend themselves to testing and achieving separation of concerns allowing unparalleled software composability.

This talk will focus on Java and the JVM even though the discussion will be largely applicable.

Check out http://eng.kaching.com/search/label/tests for the latest from our company's blog.

A domain-specific language (DSL) is commonly described as a computer language targeted at a particular kind of problem and it is not planned to solve problems outside of its domain. DSLs have been formally studied for many years. Until recently, however, internal DSLs have been written into programs only as a happy accident by programmers simply trying to solve their problems in the most readable and concise way possible. Lately, with the advent of Ruby and other dynamic languages, there has been a growing interest in DSLs amongst programmers. These loosely structured languages offer an approach to DSLs which allow a minimum of grammar and therefore the most direct representation of a particular language. However, discarding the compiler and the ability to use the most powerful modern IDEs such as Eclipse is a definite disadvantage with this approach.

The speakers have successfully compromised between the two approaches, and will argue that is quite possible and helpful to approach API design from the DSL orientation in a structured language such as Java. This session describes how it is possible to write domain-specific languages using the Java language and suggests some patterns for constructing them.

• Why this works
• Simple, verbal techniques to build rapport fast
• Practice on how to build and break rapport (helpful to keep daily standups concise!)

• RDFa in detail
• how you can embed them in semi-structured languages like HTML or XML
• and how it is used in real-world scenarios.

Testing GUIs is essential to making applications safer and more robust. Even the simplest GUI can enclose some complexity. Any complexity needs to be tested: code without tests is a potential source of bugs. A well-tested application has a greater chance of success. GUI development has been slow to include automated testing as a core practice, because writing tests for GUIs is hard. In this session, we'll explore several practices that can simplify testing of Swing and JavaFX GUIs.

Topics that will be covered include:

• What robust GUI tests means
• Creating testable GUIs
• Troubleshooting failing tests
• Finding and fixing threading issues
• Applying test-driven development (TDD) to GUIs
• Available open source tools for GUI testing

• How do I use this interactive technology and incorporate it into my existing web sites that pull content and web applications from several different sources?
• How do I enable this piece of the application to interoperate with the rest of the web page and other Silverlight applications?

Spring Roo combines the power of the Spring framework, magic of annotations, and awesomeness of AspectJ to provide unimaginable productivity for building enterprise applications. This open source project provides Java programmers a real choice in creating applications quickly without compromising on performance, while enjoying goodies that come with statically typed languages--code completion, immediate feedback on errors, and robust refactoring. Spring Roo does all this without the locking-in that you would typically expect from such a productive solution.

In this presentation, we will create an application from scratch. We will pick a domain suggested by attendees and develop JSP- and GWT-based front end, JPA-based persistence, security, automated tests, and so on. We will do all this and still have time left to show how it all works. Come to this presentation as a skeptic and leave as a believer!

• page navigation
• interacting with web services
• local storage on the phone
• media
• application bars
• launchers & choosers

In this 101 session I will demonstrate how to build a simple Silverlight list application on the Windows Phone 7, which will download sessions and bookmark favorites from the OData feed of the Code Camp site.

The application will manage its state using IsolatedStorage, and I will also demonstrate some best practices, like the use of MVVM, and some tips on XML parsing.

You will also be able to download and run the code yourself. This application will be available on the iPhone too at the conference to help you manage your attendance.