JavaOne

Notes from JavaOne 2012 in San Francisco.

[javaone2012]

Clouds at JavaOne

Clouds Represented at JavaOne

Sorry for the long delay on this post!

Many different vendors were present at JavaOne. These are the PaaS (Platform as a Service) vendors that I noticed.

CloudFoundry

Cloud Foundry was originally founded by Chris Richardson, author of POJOs in Action. It was then bought by Spring, which was bought by VMWare. Cloud Foundry appears to still be in "beta" but supports a lot of languages and frameworks, including Scala, Play, Spring, Grails, node.js, and Rails.

Cloudbees

Cloudbees runs a host of different PaaS services, including a continuous integration (build) service using the Jenkins build manager. They also host SVN or git code repositories and have free accounts (for <= 2GB and <= 3 users).

Jelastic

Jelastic is a winner of the 2012 Duke's Choice award and a favorite of Java-creator James Gosling. It runs your Tomcat, database (Postgres, MySQL, or MongoDB) and only charges you for what you "use" (on average and only in certain increments). However, your free trail only lasts about 14 days, so be prepared to pay after that.

[javaone2012]

Creating a Magical User Experience

Speaker: Danno Ferrin - Griffon founder - Griffon in Action

UX - User Experience: UI = User Illusion

Application Hierarchy

Functional

Reliable

Usable

Efficient

Magical

Success is Fleeting - Netscape, iTunes

Rules of Magic

Never reveal the secret to audience

Never do same trick twice for one audience

Never let audience see preparations

Ethics

protect the audience

tell them this is an illusion

reveal risks (SLA)

don't abuse magic

consider your audience

Consider your Audience

Random User - Muggle

Rock Star - Squib

Genius - Wizard/witch

Alice

for learning programming ideas

for muggles

IDE = Squibs

vim = wizards

Stages for Magic (in Magic Castle)

close-up gallery = Web Application

parlor of prestidigitation = Desktop application

palace of mystery = embedded device

Video Stages

YouTube: close-up

VLC: parlor

ReplayTV (like Tivo): palace of mystery

Choice as Illusion

Limit choices

prepare for every possible choice

taylor choices for audience

e.g. github for windows: no merge

Direction:

work with instinct

motion - subtle & effective

faces - seen first

Simulate/Dissimulate

have to get 100%

skuemorph = imitating something in real life

Context is magical

3 stars

3/5 stars

[javaone2012]

Groovy Ecosystem

Speaker: Andres Almiray - Canoo - Griffon

Grails

Walmart's Music Store

800 plugins

Grails is a platform

Griffon 1.1

Swing UI

create-app: very similar to grails

create-app cool -archetype=jumpstart

Gaelyk 1.1

abstraction over GAE

emerging plugin system

Caelyf

2011, apache 2 licensed

similar to gaelyk

Gradle

Groovy DSL

build.gradle

gradle wrapper: gradlew.sh script

Gant

since 2006,

now in maintenance mode

used by Grails & Griffon

Easyb

BDD - behaviour driven development, like TDD

human readable

Spock

since 2007

DSL framework

strings as method names

expect: block

data tables

@Unroll(String) - like JUnit theories "unrolled"

Codenarc

since 2009

static code analysis for Groovy

plugins for Grails, Griffon

GMetrics

GPars

multi-threading framework

fork/join

actors

STM, and more...

Ratpack: REST, very beta

GContracts: @Requires, @Ensures

[javaone2012]

Java Community Keynote

Speakers: Sharat Chander, Donald Smith, Paul Perrone, James Gosling, others

JavaOne was 40% Oracle, and 60% community speakers

Gar Fist - Tech. Staff AMD

Sumatra: offload code to GPU

Aparapi - openCL - GPU

Java & Innovation

Eucalypits = open-source cloud

Twitter on JVM - netty, hadoop, Scala

Cloudera: Hadoop - ecosystem, growing

Eclipse: RCP, etc.

Perrone Robotics: Java SE, ME, realtime

Georges Saab - VP JAva Development

LJC (london Java) - inspired adopt a jsr

//adoptajsr.org

work on TCK, testing, feedback

Paul Perrone (Perrone Robotics)

AARDBOTS - small bots

for hobby, research, etc.

James Gosling:

Liquid Robotics

surf-board size robot - 1 actuator

Iridium network - $1/kilobyte

robot is self-installing weather buoy, pollution monitor, mammal-noise monitor, global warming tester

Gosling created his own NoSQL-ish solution: spanning data-centers - GoGrid, Jelastic, Entic

showed off a Swing GUI using NasaWhirlwind/Google-earth that tracks where all surf-board robots are right now and have been.

Talk finished up. Gave a link to nighthackingtour.com

[javaone2012]

Groovy 2.0

Speaker: Guilliame Laforge

Groovy 1.8

Command Chains - pull request on github => pull(request).on(github)

GPars is bundled for parallel and concurrent paradigms

closure annotation parameters @Invariant({number >= 0})

closure memoization {...}.memoize()

Built-in JSON support - consuming, producing, pretty-printing

New AST Transformations: @Log @Field, @AutoClone, @AutoExternalizable, ...

Groovy 2.0

more modular - multiple jars - create your own module (Extension modules)

@Static Compile

Java 7 alignments - project Coin & invoke dynamic

Java 7 - catch (Exception1 | Exception2 e) {}

Static Type Checking 

@TypeChecked

infers Lowest Upper Bound (LUB)

gotcha's: runtime metaprogramming won't work!

explicit type needed in closure: a.collect { String it -> it.toUpperCase()}

@StaticCompile:

type-checking: no one else can change byte-code

binary identical to Java compiled (almost)

[javaone2012]

UI Design Patterns (Using JavaFX)

Speaker: Peter Pilgrim - consultant

UI Design Patterns

concrete

show relationships

customizable

Data Tip

show # on rollover

use for: rich data in graphics, geo-formatted data

why? chunking (mental process), save screen realestate.

Data Spot Light

shows popup & fades out other data

use when graph obscures data

Alternative Views

let user choose different views of data

e.g. Heatmap/Graph

Movable Panel

freely movable boxes

open/close boxes

why? user power, customizable

Broadcast Media Player

play/pause/stop audio & video

title & duration

scrubbing

use Media, MediaView, MediaPlayer, Slider

Preferred SDK methods:

Region - layoutInArea()

layoutInRegion()

Event Handlers

Event Filters - intercept JavaFX events

DragNodes through Translation

www.xenonique.co.uk/blog/

[javaone2012]

Developing Polyglot Persistence Applications

Speaker: Chris Richardson @crichardson @VMWare - Author of POJOs in Action, founder of the original cloud foundry

Limitations of Relational DB's

scalability

schema-updates

geo-distribution

O/R impedance mismatch

not good for semi-structured data

Solution: Use NoSQL:

Drawbacks: querying, consistency, atomic?

Redis:

key-value store

very fast (in memory)

optional persistence

also does queries DB can't: most recent added, random

Drawbacks: limited query lang., limited transactions

Various NoSQL Solutions Strong-points:

Decentralized: Cassandra

Documents: MongoDB

Caching: Redis

Spring 3.1 cache abstractions

annotations specify methods to cache: @Cacheable @CacheEvict

CacheManager - pluggable backend cache

SpringData for Redis

simplifies

RedisTemplate

RedisCacheManager

Option #1: Query caching

issue: long tail queries (there are too many different queries)

issue: update(restaurant) flushes cache

Option #2: Master/slave

Replication: scale writes

efficient

Option #3: Redis materialized view

denormalize

simplify query

concat fields together

use Redis sortedset as index

Synchronizing DB & Redis: 2 phase commit not option

Add CRUD event to DB

update Redis & mark event as done

Tracking changes to entities:

Explicit code

Hibernate event listener

Service-layer aspect AOP

CQRS/Event-sourcing

Conclusions: It takes a lot of work, but scaling up is hard work.

Using a modular async. arch. - improves fault tolerance.

Monolithic: obstacle to freq. deployments, overloads IDE & developer, obstacle to scaling, tech. lock-in.

//slideshare.net/chris.e.richardson/

[javaone2012]

Enterprise Application Integration Patterns

Speakers:

Alex Heusingfeld

Stefan Reuter

EAI - Enterprise Application Integration = Linking 'info silos' via mediation

Async messaging is best (e.g. mailboxes)

decoupling

heterogenous platforms

variable timing and throttling

reliable communication

Multiple approaches:

DIY using JEE6 api's

framework: Apache Camel, Spring Integration

Sample EAI patterns:

Adapters - inbound/outbound adapters

Pipes & filters - decouples processing into simple steps

Router - message router decides where each message goes.

Transformer - transforms data from one form to another (eg. XML to JSON)

Splitter - Splits data into chunks

Aggregator - Combines results back into one chunk

EAI in the Cloud 

limited # of I/O gateways

mostly JMS, AMQP, or HTTP

github.com/aheusingfeld/javaone2012

Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions the book.

[javaone2012]

JAX-RS 2.0

Speakers:

Marek Potocrar

Santiago Pericas-Geertsen

Public review of draft: see jcp.org/en/jsr/detail?id=339

Client API

ClientFactory -> Client -> WebTarget's "atm/{cardId}/balance"

Features

-e.g. JsonFeature

Async. Processing

Server API support

-offload I/O container threads

-suspendable client connection

-leverage Servlet 3.x async support (if available)

Client API Support: request().async().get( callback )

Filters & Interceptors

for cross-cutting features: logging, security, compression, ...

non-wrapping filter-chain

Intercept entity - ReaderInterceptor, WriterInterceptor (wrapping)

@NameBinding - static scoped binding

@PreMatching - static global binding

@BindingPriority(int) 

Hypermedia

REST principles

Id's & Links

HATEOS (RFC-5988 Web Linking) - Link types: Structural, Transitional

Use @Produces to define what is returned:

@GET

@Produces("text/plain", "text/html")

public Widget getWidget()

[javaone2012]

Design Patterns in Groovy

Speaker: Venkat Subramaniam

Patterns are easier to do and require less code in dynamic languages compared to static languages like Java.

Problem with Patterns: It's a great communication tool, but don't force them into code.

Strategy Pattern

Instead of three different methods: totalPrices(prices, selector) where selector is a closure. In groovy you can put the closure outside of method parameters in a method call if it is the last parameter, for example:

totalPrices(prices) { it < 35 }

Iterators

collect - iterator that builds a collection

find - finds the first element that matches a closure

findAll - finds all elements that match a closure.

DSL's

def static send(block) { 

 Mailer m = new Mailer(); 

 m with block; 

 m.sendIt();

}

With this you can do things like:

Mailer.send {

 from: '[email protected]'

 to: '[email protected]'

 body: 'body of email'

}

Meta-programming

String.metaClass.shout = { -> toUpperCase() }

or for a single instance:

str.metaClass.shout = { -> toUpperCase() }

Command pattern (in Groovy you can intercept missing methods):

def methodMissing(String name, args)

intercept, cache & invoke (GORM uses this)

impl = { /* your code */ }

getMetaClass()."$name" = impl

Delegation - add/remove methods difficult in Java

@Delegate in Groovy - it's like compile-time meta-programming. It adds the methods of the delegate class to the current class.

[javaone2012]

Distributed Caching in Data Grids

Speaker: Cameron Purdy, VP Development, Oracle

Data Grids: Where are they now?

App Server Clustering

Clustered Caching

Replication

Partitioning (Sharding)

Data Management

Parallel Processing

WAN Clustering

Some "Products"

gemfire

ehcache

extreme-scale (IBM)

gigaspaces

memcached

Core Concepts

Push as close to user as possible - CDN/edge-caching

Parition & load-balance

Horizontal scalability, design for elasticity

only "buy" what you need

Cost money: State consistency, ordering, durability guarantees

Scalability

In order of slowness: CPU+RAM, SSD, HDD, LAN async, LAN partition, WAN

S+HA = Scalability & High availability

Scale-out is redundancy

load balancing is failover

Geo-distribution is S+HA

Stateless, Cached, Replicated

Performance is a red herring - "Scalable performance" is what matters

Data Grid Systems

Data Grid

Build, Deploy, Manage, Monitor

Integration

Engineered Systems (HW/SW)

The EcoSystem

JCACHE (jsr-107)

NoSQL

Data Grids for Java Platform (jsr-347)

Big Data

Cloud

Elastic Fabric: so that cloud automatically grows/shrinks/restarts.

[javaone2012]

What's New in Grails 2.0?

Speaker: Graeme Rocher - Senior Staff Engineer, VMware

grails docs - better

error page - shows code

database console at <app>/db - H2 database

Grails 2.2 will have Groovy 2

Runtime reloading for typed services, domain classes, src/groovy and src/java

Run any command with -reloading to dynamically reload it

binary plugins - jars

better scaffolding - HTML 5 compliant

PageRenderer and LinkGenerator API for services

Servlet 3.0 async API supported - events plugin - platform core

Resources plugin integrated into core

Plugins for gzip, cache, bundling

New tags: img, external, javascript

Install plugin cached-resources, zipped-resources

GORM API (grails-data-mapping)

Supports: MongoDB, riak, Cassandra, neo4j, redis, Amazon SimpleDB

New, compile-time checked query DSL

-aggregate functions supported: avg, sum, ...

-subqueries, .size(), etc.

Multiple scoped data sources

database-migration plugin - for updating production DB's

Testing

Better unit testing - mixin approach

@TestFor(X) @Mock(Y) - Domain -> In-memory GORM = ConcurrentHashMap

Tests for Tag libraries, command objects, URL-Mappings, XML & JSON, etc.

Maven plugin 2.1

Cache plugin

@Cacheable on Service or Controller methods

cache tags = cache:block, cache:render

cache-ehcache, -redis, -gemfire

cache config. DSL

Grails wrapper

$grails wrapper - produces grailsw.sh or grailsw.bat

Grails is supported by CloudBees, CloudFoundry, Amazon, Heroku

[javaone2012]

Concurrency without Pain in Pure Java

Speaker: Venkat Subramaniam @venkat_s agiledeveloper.com

State of Concurrent Programming

Java doesn't have great support for concurrency built-in. Other languages, like Scala and Clojure, have been built from the ground-up with concurrency in mind. However, we can use the concurrency models from Scala and Clojure straight in Java.

Prominent Models for Concurrency

Synchronize and suffer (using synchronize keyword in Java)

software transactional memory (STM) (Clojure)

Actor based model (akka)

Synchronize in Java

Runtime behavior is unpredictable and very difficult to test.

No warnings or errors are given at compile-time.

It's too low level to use.

STM in Clojure

Separation of State and Identity.

For example, the stock price at a given time is immutable

Use a "Transaction" to modify anything. Transaction = cone of silence (only effects one thing)

We can include the Clojure jars and use them within in Java.

import clojure.lang.*

Ref referenceToAmount;

LockingTransaction.runInTransaction(new Callable()...)

Now you will get an error if you try to modify the Ref outside of a transaction.

Actor based solution

Scala-based framework akka can be used from Java.

import akka.actor.*

ActorSystem.create()

XActor extends UntypedActor

An actor runs in a dedicated Thread, so it can only do one thing at a time.

This makes concurrency much easier to implement.

Akka is used by the play framework.

[javaone2012]

Why there's no Future in Java Futures

Speakers:

Mark Falco - Consulting Member Technical Staff, Oracle;

Brian Oliver - Senior Solutions Architect, Oracle.

This talk goes into speculation on what will replace the java.util.concurrent.Future interface at some point (they do not specify when this will happen).

When using Java's Future, we tend to loop on isDone(), which ties up the thread, or call .get() which blocks the thread completely.

ExecututorService#submit(x) used the most

Generally when "going asychronous" we don't care about the result, or we want to do something with the result (thus we want something like a continuation)

Need a callback: Removes the need for polling (isDone) and blocking

async methods should always return void

So we will have an ObservableFuture - with onSuccess and onFailure methods

Collector - (allows map reduce)

add(Result) - partial result

flush() - when done

Result<T> get() throw ExecutionException?

Future.cancel() is optional?

Interruptable interface -~Callable ~Runnable (~ = Interruptable)

Should there be a timeout? (they were very unsure about this)

Possibly Replace Runnable/Callable with a Task interface?

[javaone2012]

My Notes from java community keynote.

[javaone2012]

Gosling.

[javaone2012]

before Java community keynote.