Sessions at Conference On Java 2011
A PaaS offering typically facilitates application deployment without the cost and complexity of managing infrastructure, by providing all of the facilities required to build and deliver services.
Current JavaEE deployment requires the deployer to provision the various dependent services of an application in that container. To support PaaS deployment scenarios, GlassFish is working to provide a simplified application provisioning and deployment interface to users, with the runtime handling the discovery of service dependencies, provisioning services, and associating service references with these services. Some of the metrics (such as CPU, memory, and response times) can be used to monitor system health. These metrics can then be used to determine if the cluster of virtual machines hosting the JavaEE container needs to be dynamically expanded or shrunk to accommodate fluctuations in demand.
This session details how JavaEE containers such as GlassFish can provide such service orchestration and elasticity capabilities. This session will take an existing JavaEE 6 application and walk through the complete life cycle of taking this application from desktop to a PaaS environment. The session will explain the development, testing, and debugging of such an application in the PaaS envinronment.
This talk introduces the JavaEE 7 platform, the latest revision of the Java platform for the enterprise. The focus of JavaEE 7 is on the cloud, and specifically it aims to bring Platform-as-a-Service providers and application developers together so that portable applications can be deployed on any cloud infrastructure and reap all its benefits in terms of scalability, elasticity, multitenancy, etc. The existing specifications in the platform such as JPA, Servlets, EJB, and others will be updated to meet these requirements.
Furthermore, JavaEE 7 continues the ease of development push that characterized prior releases by bringing further simplification to enterprise development. It also adds new, important APIs such as the REST client API in JAX-RS 2.0 and the long awaited Concurrency Utilities for JavaEE API. Expression Language 3.0 and Java Message Service 2.0 will under go extreme makeover to align with the improvements in the Java language. There are plenty of improvements to several other components. Newer web standards like HTML 5 and Web Sockets will be embraced to build modern web applications.
This talk will provide a complete introduction to the JavaEE 7 platform, including different components, and provide a roadmap.
In the Internet era scalability is the most sensitive issue to most hosted applications. However if one follows the right architecture and other considerations from the beginning, you will have not to worry about this aspect later on.
This session aims to cover some scalability and load distribution considerations we followed while developing application which had to scale to a million users.
It will cover the following considerations:
- Restful Architecture: Heart of horizontal scalability and distributed application.
- Stateless UI: No need to do extra configuration if you do follow simple guideline
- MySQL master/slave replication: Use it to maximum
- Separate read and write layer: Divide and Rule.
- Distribution of load: In horizontal scaling how you can distribute load across your nodes/server. This applies specifically to daemon processes running in background to perform some CPU intensive processes (like data mining) or some low priority non-real time processes (like sending some (non-critical) notifications to users) or batch processing.
- DB sharing: Idea is to divide data physically so that each cluster should have its own users data
The talk will discuss learning from a system GSLab built using java/j2ee technologies. This particular product required to have support of 1 million user and processing packets coming from each user after every two hour to show it on users dashboard.
We will also go through the workload distribution technique we have used which is required for batch processing of data using Quartz library.
Continue reading “Scalability Considerations” »
Concurrent Programs in Java are tougher to write than the sequential ones and especially harder to test.This is trivially true, following could be listed as few reasons why
1. Tests for concurrent programs are themselves concurrent programs.
2. The failure modes of concurrent programs are less predictable and repeatable than for sequential programs. A failed sequential program for a given set of input would fail each and every time put through the same test, whereas the concurrent version may not necessarily fail for the same test each time.
In the session I plan to talk about following points:
1. What makes it hard to test and write Multithreaded code.
2. Improving design and structure of Multithreaded code to enhance the testability.
3. Writing Effective Unit tests for concurrent programs.
4. Demo – build a small example application using concurrency and putting test safety net around it.
5. Share some interesting situations faced while developing a Multi-core application and remedies applied.
Continue reading “Testing Concurrent Java Programs” »
Scala is a very powerful OO + FP language which is well suited for building DSL’s and for writing highly concurrent programs – we will explore these areas. Some very powerful, expressive and type safe DSL’s have been written using Scala for e.g. Foursquare uses a type safe expressive DSL called Rogue, the integration open source project Camel has a Scala based DSL. My talk would describe how to build DSL’s using Scala, what features in Scala help make it a great option for building dsl’S AND SOME GREAT OUT THERE examples of DSL’s built in Scala.
Build orchestration and automation has always been a tricky problem, especially once we start crossing application boundaries. Several tools in he Java ecosystem, such as ant and maven, have taken a stab at this problem.
A relatively new entrant to this space is Gradle. Built using Groovy it offers an extremely flexible means of describing builds with only as much text as is absolutely necessary thanks to it’s powerful plugin infrastructure and sensible conventions borrowed from existing tools.
This session will introduce the audience to Gradle, the various DSLs used to describe builds as well as the plugin infrastructure that allows for extending Gradle’s capabilities.
Continue reading “Simplifying builds with Gradle” »
Representational State Transfer (REST) style web services are very popular. They offer simplicity and flexibility of choosing the content in which they can be consumed. This session focuses on the pros and cons of using binary format as a content for the RESTful web services. In this talk, Google Protocol Buffers will be used as an example content for Restful Web Services. We also will compare other options for data serialization systems such as Avro, Java objects in terms of performance, ease of development.
Continue reading “REST Style Web Services with binary content (Google Protocol Buffers)” »
Do you require a search and suggest engine that could scale up catering to millions of records? In this session, I shall render my past project experience of using Solr as a search engine delimiting what could you really expect out of Solr.
This case study shall focus on the following points:
- Why choose Solr as your search engine : What lured us to go for Solr
- Solr offers various configurations and components to build a Google style Suggestions engine – Elicit pros and limiting factors of these components and highlight when to use which component.
- Fuzzy Searching with Solr – I want to search ‘Karan’ but I type ‘Naran’ yet Solr finds it. – Analyse what fuzzy searching can do for you and to what extent should you stretch your engine’s fuzzy search quotient.
- Discuss Solr scaling topology – Point out what factors should you consider while scaling Solr
- Unit testing Solr code
Historically writing correct concurrent, scalable and fault-tolerant applications has been very hard. Akka is an attempt to simplify writing concurrent, scalable and highly available software for the JVM. Akka has an API both for Scala and Java. Akka uses the Actor Model together with Software Transactional Memory (STM) to raise the abstraction level. For fault-tolerance it adopts the “Let it crash” model which help in building self healing always on systems.
The presentation would walk through the Akka features for building a web scale system. We would look at a real world case study in which Inphina developed a web scale framework using Akka which is capable of processing 150 million streaming messages a day. We would discuss the architecture and key design decisions.
Takeaways would include an understanding of Akka, its features which would help in developing a scalable system, potential architecture and pitfalls to be cautious about.
Continue reading “Building Massively Scalable Applications with Akka” »
UnConference is a participant-driven session for short, open discussions on various topics of interest to delegates. A delegate can present a question / make a point in a couple of minutes followed by an open discussion where speakers as well as others from the assembly contribute their views.
The Unconference has been working very well at IndicThreads Conferences, helping delegates crowd source opinions & answers on various topics of intrigue & interest.
The topics for the UnConference are decided via listings on a white board at the venue.
Continue reading “UnConference” »
This talk will focus on the key Java technologies, what’s changing with each and where they are headed. It will also look at buzzing new technologies in Java, their adoption & impact. The talk will look at developments with JavaEE, Java on the Cloud, Java on Mobile devices, JavaFX, OpenJDK & JVM languages.
Dealing with collections is one of the most frequent activities in programming. The talk will focus on the rich collections API offered by Scala and on the myriad capabilities that are built into Scala Collections. The talk will refer briefly to the underlying design of the collections API. Given the API features and scala syntactic capabilities it will help demonstrate how complex computations can be elegantly expressed succinctly using Scala Collections. The talk will cover a number of examples including a few using both using Scala and Java Collections APIs. Finally the talk will refer to how these expressive constructs can help reduce both development and maintenance time.
*Speakers & Sessions are listed only after confirmations. However please note that these are subject to change.