Groovy related talks at JavaOne 2014
Posted on 20 June, 2014 (4 years ago)
Modified on 29 June, 2014 (4 years ago)
Oracle is publishing the agenda of the upcoming JavaOne 2014 conference. And I'd like to highlight the Groovy presentations I've noticed that you might be attending in following if you are in San Francisco:
- Groovy in the Light of Java 8 [CON5839]
With Java 8 out the door, Java developers can at last benefit from the long-awaited lambdas to taste the newly found functional flavor of the language. Streams are there to work more easily and efficiently with heaps of data. Those things are not new to developers acquainted with Groovy. But what is left to Groovy to make it attractive beyond all the aspects in which Java has caught up with Groovy? In this session, a Groovy project lead shows you how Groovy is still relevant in the JVM landscape, how similar or different Java and Groovy can be, how Groovy further improves the developer experience on top of JDK 8, and what Groovy offers beyond Java.
- Groovy in 2014 and Beyond [CON5996]
With three million downloads in a year, Groovy still clearly leads the pack of alternative languages on the JVM, but it’s not resting on its laurels. The latest Groovy release, 2.3, is chock-full of useful new features and performance improvements. In particular, Groovy now supports the concept of “traits” for elegantly composing behaviors. Its JSON support is now the most performant of all the JSON libraries available to date. Groovy 2.3 introduces a new markup-based template engine, new code transformations, and much more. In this session, a Groovy project lead guides you through the latest advancements in the Groovy programming language and tells you what’s cooking for the next releases.
- Exploring Groovy Metaprogramming [CON1768]
One of the key benefits of Groovy is its metaprogramming capability. The built-in features of the language enable you to realize AOP without the need for any heavyweight tools. This presentation takes an in-depth look at the metaprogramming capabilities of Groovy and explains when to use mixins, method injection, and method synthesis.
- Functional Programmning the Groovy Way [CON3538]
In recent years, functional programming has gained ground over object-oriented programming, mainly due to the advancement in computing power. The JVM is no exception. You can find powerful contenders in Clojure and Scala, but Groovy is not that far back in the race. The Groovy programming language contains a wide array of APIs and features that facilitate a functional programming style, such as closure composition, memorization, trampolines, and iterator methods. This session explores all of these features that are sure to spice up your daily experience.
- Rethinking API Design with Groovy Traits [CON2425]
Groovy 2.3 introduces the concept of traits in the language. Traits look like interfaces but enable the developer to add both implementation and state. They introduce multiple inheritance in the language while avoiding the diamond problem. Traits will let you rethink the way you design APIs in Groovy, by favoring composition of behaviors. This session explains what traits are, how they were implemented in Groovy, and what they have to offer to make your code more readable and maintainable.
- Groovy and Grails Puzzlers: As Usual—Traps, Pitfalls, and End Cases [CON1764]
Remember the epic Java puzzlers? Here’s the Groovy version, and there are some neat ones! Even though it is totally a Grails shop, some of these had JFrog people scratching their head for days, trying to figure them out. And there is more! Contributions from the truly Groovy senseis, including @glaforge, @aalmiray, @tim_yates, and @kenkousen, make this session an unforgettable journey to Groovy’s O_O. You’ll get the expected dose of fun and enlightenment while hearing about mistakes and failures, great and small, in hard-core Groovy/Grails development.
- Applying Groovy Closures for Fun and Productivity [CON1769]
You can program higher-order functions in Groovy quite easily by using closures, but the benefits of closures go far beyond that. Groovy has a variety of capabilities hidden in closures. This presentation unlocks that treasure and explores ways in which we can design applications by using Groovy closures to apply different design patterns, to create fluent interfaces, and even to program asynchrony.
- HTML5/AngularJS/Groovy/Java and MongoDB Together: What Could Possibly Go Wrong? [CON1703]
We hear it’s common to create a minimum viable product (MVP) in a language that facilitates rapid prototyping and then migrate to the JVM when the application requires better stability and performance. In this session, the speaker uses Java to create a web application in less than hour. The JVM is a polyglot platform, and you’ll learn how to use the correct tools for this application, including AngularJS, Bootstrap, HTML5, web services, Java, MongoDB, and Groovy—it’s fully buzzword-compliant. The presentation doesn’t go into every technology in depth but demonstrates the role of each tool and how the tools interact. The session will result in a fully working mobile/browser-friendly app without compromise of design or good practice. It’s even going to have tests.
- Plugging Users In: Extend Your Application with Pluggable Groovy DSL [CON1752]
It is often beneficial to enable users to extend your software with their own logic, and with dynamic languages on the JVM, it is also easy to do so. This session shares JFrog’s experience in creating a public, Groovy-authored user plug-in interface. It explains what domain-specific languages (DSLs) are, what their relevance to user plug-ins is, and how they can be implemented in Groovy or Java. It also discusses another very important aspect of pluggability: good public API design. Further, it covers security concerns and how they should be tackled. And finally, it discusses classpath isolation issues you may run into and compares different solutions to this problem.
- Script Bowl 2014: The Battle Rages On [CON2939]
In this contest, languages that run on the JVM, represented by their respective language nerds, battle for bragging rights as the most popular language by showing off their shiny new features. Adding a twist to the format in which the audience members will pick this year’s winner(s): they will also vote on a language that should not return in 2015. Returning from 2013 are language gurus representing Clojure, Groovy, JRuby, and Scala. Attend this fun-filled and technically invigorating session to judge which scripting language best meets your needs. You’ll also be able to compare the respective languages and spark some thought-provoking discussions with the panelists that will be beneficial to the entire Java community.
- Spring 4TW! [CON3693]
Spring 4’s here, and with it comes a bevy of new features designed to support modern web developers as well as enrich the component model and enable even-more-adaptive enterprise applications. Spring 4 also serves as the underpinning of Spring Boot, the entry point into the Spring platform. In this session, a Spring developer advocate discusses Spring 4’s new support for WebSocket (including extra support for STOMP), conditional configuration, dependency injection, Java 8 and Java EE 7 support (JCache support, the Batch JSR, ManagedExecutorService support, and so on), the Groovy language, and more. The presentation also looks at Spring Boot as a productive entry point into the Spring platform.
- Writing Highly Concurrent Polyglot Applications with Vert.x [CON7902]
Update: I only searched sessions with the "groovy" keyword, but other Groovy ecosystem projects are also present, like Griffon, Gradle or Spock! So let me fix that by appending some more Groovy-related sessions to my list!
- Create Elegant Builds at Scale with Gradle [CON8780]
How can medium and large projects use Gradle to scale their build infrastructure? This session looks at organizations such as Netflix and LinkedIn and how they scale with Gradle across hundreds or thousands of developers. It discusses how to solve the challenges of standardization, dependency management, multilanguage builds, and automatic build infrastructure provisioning.
- Gradle: Harder, Better, Stronger, Faster [CON3531]
Are you one of those people who search around the world looking for clues on how to get Maven to do your bidding, or do you just flip a coin and get lucky one more time? Maven works OK, but there’s a new tool in town that goes beyond Maven: Gradle. It’s fresh, almost aerodynamic. Once you get in contact with it, you’ll feel like doin’ it right when building a project. We kid you not, it’s an instant crush for those who have followed the Maven path, as you’ll find out in this session. This is the prime time of your life as a developer. Make the most out of it by leveraging the best tools.
- Build, Test, and Deploy JavaFX Applications with Ease [CON3553]
Why is it that there are so many different options in the JVM space for building web applications but so few when it comes to desktop applications? This presentation addresses this question by showcasing a set of tools that can help you build JavaFX-powered applications without having to battle the build itself. It begins by looking at Gradle for defining the basic structure, then it covers Griffon as the means of putting all the pieces in their right place and TestFX as the testing library of choice, and finally it closes by circling back to Gradle and its deployment options.
- Advanced Java Unit Testing with Spock [CON2276]
The Spock unit testing framework is on the verge of a 1.0 release and has already proven to be the next-generation thinking on how to test Java production code. Using Spock is hands-down the best way for developers to mock and test Java applications. One of Spock’s great features is the ability to write your own custom extensions. This session is a fast-paced (not for beginners), code-centric overview of how to use the advanced features in Spock, including custom extensions and interceptors.
- BDD in Action: Building Software Right and Building the Right Software [CON1579]
A common perception of behavior-driven development (BDD) focuses on test automation with Cucumber-style “Given..When..Then” scenarios. But this is just the tip of the iceberg: in fact BDD ranges from requirements discovery and description through to driving technical design and implementation; helping testers focus their testing efforts more effectively; and even providing reliable, useful, and accurate technical documentation. This session discusses what BDD is about, its benefits, and how it affects development teams and processes. You will see how JVM teams can effectively implement BDD with tools such as JBehave, Cucumber, Thucydides, and Spock. Come learn how much more there is to BDD than just “Given..When..Then.”