Recorded at SpringOne2GX 2013 in Stana Clara, CA

Speakers: Emad Benjamin and Guillermo Tantachuco

The session will cover various GC tuning techniques, in particular focus on tuning large scale JVM deployments. Come to this session to learn about GC tuning recipe that can give you the best configuration for latency sensitive applications. While predominantly most enterprise class Java workloads can fit into a scaled-out set of JVM instances of less than 4GB JVM heap, there are workloads in the in memory database space that require fairly large JVMs. In this session we take a deep dive into the issues and the optimal tuning configurations for tuning large JVMs in the range of 4GB to 128GB. In this session the GC tuning recipe shared is a refinement from 15 years of GC engagements and an adaptation in recent years for tuning some of the largest JVMs in the industry using plain HotSpot and CMS GC policy. You should be able to walk away with the ability to commence a decent GC tuning exercise on your own. The session does summarize the techniques and the necessary JVM options needed to accomplish this task. Naturally when tuning large scale JVM platforms, the underlying hardware tuning cannot be ignored, hence the session will take detour from the traditional GC tuning talks out there and dive into how you optimally size a platform for enhanced memory consumption. Lastly, the session will also cover vfabric reference architecture where a comprehensive performance study was done. Learn more about

!{iframe width="560" height="315" src="//www.youtube.com/embed/htxkAMiAD58" frameborder="0" allowfullscreen}{/iframe}

Speaker: Gary Russell

The Spring Integration team has been hard at work on the latest release of the popular integration framework. Before version 4.0, it was impractical to define a complete Spring Integration flow without using XML. With this major release, the existing basic annotation support has received an overhaul and those who prefer to use java @Configuration classes can now define their applications without needing to use any XML (of course, XML is still supported as well). In this session we will cover these major changes to the framework, explaining how and when to use them. It will be mainly demonstration and code walk through, and we will build a useful Spring Boot / Integration application from scratch.

Learn more about Spring Integration at http://projects.spring.io/spring-integration

Learn more about Spring Boot at http://projects.spring.io/spring-boot

Learn more about Spring Framework at http://projects.spring.io/spring-framework

!{iframe width="420" height="315" src="//www.youtube.com/embed/g3DgdSqEgzI" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2013 in Santa Clara, CA.

Speaker: Rob Winch Spring Security is a framework that focuses on providing both authentication and authorization to Java applications. Like all Spring projects, the real power of Spring Security is found in how easily it can be extended to meet custom requirements. In this presentation Rob will incrementally apply the new features found in Spring Security 3.2 to an existing application to demonstrate how it can meet your authentication and authorization needs.

Learn more about Spring Security 3.2 at http://projects.spring.io/spring-security/

Learn more about using Spring at: http://www.spring.io

!{iframe width="560" height="315" src="//www.youtube.com/embed/1zu8COg80q4" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2013 in Santa Clara, CA.

Join Chris Beams as he dives into http://spring.io - the new spring website. It's chock full of amazing new resources that you can share with your co-workers who might be new to Spring, or simply helping to introduce Spring to those who might not be familiar with it - people coding in other languages, frameworks, or platforms. You've asked us to help make it easier to win the comparisons, and we've listened. Attend this session to get the ammo you need to win that internal bake off, and learn the details about how the site was built and deployed. now and open source project!

Learn more about the open source spring.io website at our blog:

http://spring.io/blog/2014/03/27/project-sagan-open-sourcing-spring-io

http://spring.io/blog/2014/04/04/project-sagan-zero-downtime-deployments

http://spring.io/blog/2014/04/28/project-sagan-client-side-architecture

http://spring.io/blog/2014/04/18/project-sagan-upgrading-to-jdk-8

Learn more about Spring Framework 4.0 http://projects.spring.io/spring-framework

Learn more about Spring Boot http://projects.spring.io/spring-boot

Learn more about using CloudFoundry at: http://cloudfoundry.org/

!{iframe width="560" height="315" src="//www.youtube.com/embed/pA1oGmd1R5w" frameborder="0" allowfullscreen}{/iframe}

Speakers: Ashley Puls, New Relic Josh Long, Pivotal

There is more and more usage of JavaScript on the client side today. Many are starting down the difficult path of full blown application development in JS on the client side, going beyond having a simple rollover menu logic or presentation component. But tracking and tracing effectively means looking at the whole application, not just the front end. New Relic can be used either in development or production to diagnose hybrid JavaScript/Java applications. In this session, Josh Long (Pivotal) and Ashley Puls (New Relic) will show how you can track and trace your way through today's hybrid JavaScript+Java web apps - resolving slow page loads, blocked threads, slow queries, etc.

Learn more about using New Relic at: http://www.newrelic.com

Learn more about using Spring at: http://www.spring.io

!{iframe width="420" height="315" src="//www.youtube.com/embed/ixnlDL6wli4" frameborder="0" allowfullscreen}{/iframe}

Building Spring Applications on Cloud Foundry

Recorded at SpringOne2GX 2013 in Santa Clara, CA.

Speaker: Josh Long and Andy Piper

Let's face it, the cloud is here to stay. The cloud's potential can seem sometimes overwhelming, but it doesn't have to if you use Spring. Spring - and the various Spring projects - already embrace the architecture characteristics that make for great, cloud-centric applications in any environment. While Spring works well on any cloud platform, it enjoys a special place in the sun on Cloud Foundry, the open source PaaS from Pivotal. In this talk, join Andy Piper as he introduces how to build Spring applications that work well in the cloud and on Cloud Foundry in particular. We'll cover how to consume services with Spring on Cloud Foundry, how to scale out using RabbitMQ and Spring Integration, how to use standalone processes and RabbitMQ for better batch processing, and discuss strategies for exposing and consuming services in a RESTful service-based cloud architecture. Learn more about spring and Cloud Foundy at http://docs.cloudfoundry.com/docs/using/deploying-apps/jvm/index.html

!{iframe width="560" height="315" src="//www.youtube.com/embed/W69nmjyDNls" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2013 in Santa Clara, CA.

Speakers: Cornelia Davis, Scott Frederick

As you find it in the open-source codebase, Cloud Foundry includes a set of prepackaged services (Postgres, MySQL, Redis, MongoDB and RabbitMQ) and a number of application runtimes (Java, Ruby and Node.js). In addition, CloudFoundry.com integrates with a number of external service providers through a services gateway. When you are deploying your own Cloud Foundry you can extend the existing open-source features by adding additional services and runtime support. In fact, you can bring your own runtime to any Cloud Foundry (including CloudFoundry.com) via buildpacks. In this session we will show you how to build and deploy, or broker custom services. We will also introduce you to buildpacks, show you how to create your own, and how to get your apps to use them.

Learn more about using CloudFoundry at: http://www.cloudfoundry.com/use

!{iframe width="560" height="315" src="//www.youtube.com/embed/sOvQE8BrX-E" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2013 in Santa Clara, CA

Speaker: Chris Richardson

A modular, polyglot architecture has many advantages but it also adds complexity since each incoming request typically fans out to multiple distributed services. For example, in an online store application the information on a product details page - description, price, recommendations, etc - comes from numerous services. To minimize response time and improve scalability, these services must be invoked concurrently. However, traditional concurrency mechanisms are low-level, painful to use and error-prone. In this talk you will learn about some powerful yet easy to use abstractions for consuming web services asynchronously. We will compare the various implementations of futures that are available in Java, Scala and JavaScript. You will learn how to use reactive observables, which are asynchronous data streams, to access web services from both Java and JavaScript. We will describe how these mechanisms let you write asynchronous code in a very straightforward, declarative fashion.

!{iframe width="560" height="315" src="//www.youtube.com/embed/aZkwIA4k2xU" frameborder="0" allowfullscreen}{/iframe}

Recorded at SpringOne2GX 2013 in Santa Clara, CA

Speaker: Mark Secrist

Many developers who are learning the Spring Framework think of it as simply another mechanism for centralized dependency injection. While the framework does handle that responsibility quite well, the framework is so much more. In this session, we'll explore some of the building blocks and patterns used by the core framework as well as many of the other Spring projects. The result is that attendees will gain a better understanding of how to use the Spring Framework and learn how to build their own components that can leverage these same patterns. Topics we'll explore:

• What is the benefit of centralized lifecycle management
• Programming to interfaces
• Leveraging the power of proxies
• Using annotations
• Understanding the template pattern

Dependency injection is one very important part of what the Spring Framework does. However, it is also a collection of very key patterns that we'll explore.

• Centralized lifecycle management
• Examining the BeanFactoryPostProcessor
• Examining the BeanPostProcessor
• How to write your own BeanPostProcessor
• Programming to interfaces
• Benefits of programming to interfaces
• Loose coupling
• Examples of how Spring leverages this mechanism
• How to leverage in your own Spring applications
• Leveraging the power of proxies
• How proxies work in Spring
• How Spring uses them
• Writing your own proxy-based solution
• Using annotations
• Examples of how Spring uses annotations
• Using your own annotations
• Understanding the template pattern
• Purpose of template pattern
• How Spring uses templates
• Creating your own template

Learn more about Spring Framework at http://projects.spring.io/spring-framework

!{iframe width="560" height="315" src="//www.youtube.com/embed/JfgP566BHW0" frameborder="0" allowfullscreen}{/iframe}