PJUG Meeting Information

The objective of this talk is to gain familiarization with Appium - a selenium-based tool for testing mobile applications. Through a series live demos we'll discuss automation techniques for functional and performance testing of Android and iOS apps using Appium's Java API. We will also see a couple of other tools that can be useful for developing and testing mobile apps, including Xamarin Studio and Riverbed SteelCentral.

Defn:"Cobble" - "Put together something from available parts or elements"

We will take a real world problem and architect (aka cobble) an open source KISS solution (using parts from multiple previous PJUG talks!).

The goal is to have cloud based charts and graphs available to the marketing guys when the data sources are not. We will roll up multiple local MySQL databases into a cloud based Mongo database using JSON services and Morphia java objects. We will then create new JAX-RS services to supply DataTables to a GWT implementation of Google Charts.

Voila! Marketing department is now happy
(Well, no they are never happy - just placated)

After 4 years of incubating in my basement, Glowroot is ready to go out into the wild and take on difficult performance issues and sporadic errors with its GUI configurable trace and metric definitions and its core plugin support for servlets and JDBC.

This talk covers using JAX-RS and Jersey to create REST services for embedded system. It covers the basic of JAX-RS and then moves into using Jackson for JSON encoding and using the streaming API to reduce memory footprint for using REST API in embedded systems.

Ever wonder how Amazon and Netflix seem to have an uncanny ability to anticipate what products you might be interested in based on your past selections? This presentation will focus on an actual Recommender System application and will focus on:

Recommender Systems Overview - a quick recap of my January talk on Intro to Recommenders.

• Apache Mahout - A production-grade Machine Learning system. One of Mahout's strong use cases is building recommenders.
• Hadoop - Map/Reduce and other tools such as Hive
• Spring XD - A Spring.io project to simplify the development of big data applications.

Gilt is an online retailer based out of New York City. Gilt's main site, gilt.com, offers luxury apparel and home furnishings. This talk will discuss how Gilt.com supports taxes and payments. We'll discuss Gilt's checkout system and order processing backend.

Clojure is a fascinating new(er) programming language, created by Rich Hickey, that combines the ubiquity and performance of Java with the power and expressiveness of Lisp. Clojure excels at interesting problems, especially those involving concurrency, but can also freely interoperate with standard Java. Clojure developers quickly become passionate about this odd little hybrid: it's easy to learn, yet deeply powerful, and is at the heart of a vibrant and exciting eco-system of tools and libraries.

WildFly 8 (née JBoss Application Server) is Red Hat's open source Java EE 7 compliant application server. It contains robust implementations of WebSocket, Batch, JSON, Concurrency, JMS2, JAX-RS 2, CDI 1.1, and all Java EE 7 technologies. Undertow is the new cutting-edge web server in WildFly 8 and is designed for maximum throughput and scalability, including environments with over a million connections. The number of ports is reduced used by multiplexing protocols over HTTP using HTTP Upgrade.

Role Based Access Control support organizations with separated management responsibilities and restrictions. Roles represent different sets of permissions such as runtime operation execution, configuration areas that can read or written, and the ability to audit changes and manage users. In addition a new restricted audit log can be enabled including the ability to offload to a secure syslog server.

WildFly also provides a "core" distribution that is ideal for framework authors that want to build their own application runtime using the powerful WildFly 8 architecture.

NetBeans, IntelliJ, and Eclipse allow WildFly to be used for development, deployment, and debugging.

Ever wonder how Amazon and Netflix seem to have an uncanny ability to anticipate what products you might be interested in based on your past selections? This presentation will delve into how this accomplished thought the use use of filters - both collaborative and content-based - and also hybrid techniques.

Two practical open source recommender systems will also be presented:

Lenskit framework - An open-source toolkit used primarily for researching and building recommender prototypes.

Apache Mahout - A production-grade Machine Learning system. One of Mahout's strong use cases is in building recommenders.

Throughout its 18-year evolution, the Java language has played an industry-leading role in the tricky business of specifying the behavior of concurrent programs. Java's contribution became particularly evident with the introduction of the Java Memory Model (JMM) in Java 1.5.

This is an area in which a down-to-the-metal understanding can help developers strike the right balance between safety and performance, so we'll start by motivating the discussion with counterintuitive low-level examples. Then we'll work "up from the weeds" to describe the JMM as a basis for more familiar programming patterns. We'll touch on how C, C++, and C# deal with the same issues and give a nod to functional languages and Java 8.

This material can help most developers become more insightful about concurrency issues in their code. Be there or be unsynchronized!

This year at JavaOne, JDK 8 was one of the hottest topics. All of the good stuff has been summarized into this presentation. Come and see what's coming next March! (Hint - think "lambdas"). Also included are other subjects were of interest. Want to see how to run Java on your iOS device? There are already apps in the Apple App Store written in Java - come see how!

Will give a high level overview of what Elasticsearch is, a bit about why it was created, how it works under the covers and how to use it with your Java/Groovy applications. I will then show a demo of indexing data into Elasticsearch and then visualizing and searching on it using Kibana.

We all know that the most challenging programming problems we're likely to face involve threading. Lots and lots of threads, coordinating and communicating in complex and non-deterministic ways. Clojure by itself gets us part of the way there with immutable data-structures and threading primitives (such as atoms and agents), but coordinating many threads in the ways demanded by real applications increases complexity and reduces performance.

core.async is a new library for Clojure that rationalizes and simplifies coordination of large numbers of threads using communicating sequential processes; the end result is manageable code that looks and feels synchronous ... easy to read, easy to maintain. As is often the case in Clojure, a few simple primitives work together to open up a rich world of possibilities.

Come and learn how Jama is using Selenium WebDriver to test their massive single-page web application. We'll look at strategies and common pitfalls, as well as how it is been integrated into our processes.

Providing scalability by maximizing throughput of mixed resource tasks in a multi-core environment.

Ravi Luthra - A transplant from the Bay Area, CA, who is passionate about software development and specifically Java and everything on the JVM. Pastimes are playing pool and camping when time permits.

One of the more interesting additions in HTML5 are WebSockets. With bandwidth capable of streaming video and audio, it presents a completely new world for building real time push web pages like multi-user forms and HTML control panels.

We will review the browser client side of WebSockets and then the server side communication with a backend Java Servlet via JSON, creating a multi-user browser web page.

Java gets used everywhere and for everything, a reality that can be explained by its efficiency, its portability, the productivity it offers developers, and the platform it provides for application frameworks and non-Java languages. But all is not perfect; developers struggle against Java's greatest strength: its memory management.

We'll talk about where Java needs help, the challenges it presents developers who need to provide reliable performance, the reasons those challenges exist, and how developers work around them. And we'll take a little time to talk about Azul Systems, its history of tackling Java scale issues and how it addresses the mismatch between Java and big data.

What's new with Grails 2? An in-depth look at core Grails features and some tips and tricks to working with or migrating to Grails 2. We will start the discussion with a through over view of Grails and why a developer might want to use it to aid in developing enterprise quality software faster. After our introduction we'll dive into some of the more advanced features of using Grails including making a RESTful application and look at testing the application using GMock.

"The major problems of our work are not so much technological as sociological in nature". - Peopleware

Building good software products is a tricky business and though we often focus technical risks, it's the social issues that frequently derail projects.

Peopleware discusses a broad swath of the challenges that arise in our industry: office environments, staffing, overtime, team chemistry, software processes, etc. And it does so with a sense of humor and anecdotes while still treating the subject seriously with references to case studies and research that underlie much of the material.

Peopleware easily stands out as my favorite software book, a great read for anyone in the industry and a must read for anyone in management.

Apache Drill is new Apache incubator project. It's goal is to provide a distributed system for interactive analysis of large-scale datasets. Inspired by Google's Dremel technology, it aims to process trillions of records in seconds. We will cover the goals of Apache Drill, its use cases and how it relates to Hadoop, MongoDB and other large-scale distributed systems. We'll also talk about details of the architecture, points of extensibility, data flow and our first query languages (DrQL and SQL).

Java bytecode just works. It works so well that the JVM has over 250 languages that compile to bytecode. It works so well that we can usually ignore it.

But given Java bytecode's success and ubiquity, shouldn't we crack the hood and see how it works? Once you do, you may discover that bytecode manipulation is not only fun, it can be used to solve interesting problems.

In this session, we will take a look at how bytecode is represented and how to use the ASM library to view and manipulate it. We'll use the Java Instrumentation API to modify classes as they're loaded and change their behavior.

With multicore processors in cell phones and changes in scale in Enterprise computing, functional programming has risen from the grave to shuffle and moan in even the hallowed halls of Java.

Should we stockpile food and bullets and barracade ourselves in a mall, or should we let this zombie from academia munch our brains? (alt. title - ed.)

This evening we'll discuss some principles and advantages of functional programming, and how the Java programmer can take advantage of FP techniques... even in a largely imperative code base. We'll end the discussion briefly talking about functional programming extensions to Java and JVM-based functional languages, e.g. Clojure and Scala.

Apache CloudStack is an open source private cloud server. In other words, IaaS (Infrastructure as a Service). In this talk we will take a look at CloudStack system architecture and how to configure and deploy your own private cloud with CloudStack. We will also look at some CloudStack Java code and see how it uses Java APIs to control the XenServer hypervisor.

JavaFX 2 is the future of RIA development. It takes the power of a modern scene graph, adds rich animation and multimedia capabilities, and extends to the web and beyond with seamless portability. At the same time, it leverages the power and breadth of the Java language and platform, allowing full access to existing Java libraries and integration with Java client technologies like Swing.

This session will introduce you to the JavaFX 2 platform from the perspective of a seasoned Java developer. The breadth of JavaFX APIs will be explained through several examples that we will build out during the course of the session. In addition, we will showcase SceneBuilder, the new JavaFX-based GUI building tool for rapid application development.If you have heard about JavaFX before, but were not sure about taking the plunge, now is the time to see what you have been missing out on.

This talk will provide a theory of operations, systems description and possibly a demo of a live system. All code will be made available on Github.

This talk will show how latencies of less than 5 seconds can be achieved for a sample metrics application while still retaining years of data with high availability and durability. This is done using a hybrid system consisting of Storm plus Hadoop that cooperate to do something neither can do alone.

This talk will provide a theory of operations, systems description and possibly a demo of a live system. All code will be made available on Github.

Dropwizard is a Java framework for developing ops-friendly, high-performance, RESTful web services. The library was developed at Yammer and has been adopted by Simple (formerly BankSimple) and the Gilt Groupe. We will discuss how Gilt is using Dropwizard and why we adopted the library.

Software estimation is always difficult to do well. Estimation is rarely taught in school and gets little attention in professional training. This presentation, built heavily on material from Steve McConnell, delves into the topic with the goal of improving estimation with a few simple rules of thumb as well as improving the understanding of the culture and politics surrounding estimates that often cause conflicts.

SBLIM is an open source toolkit to simplify CIM/XML development. The presentation covers the basics of CIM and how to use SBLIM to do various common tasks a CIM client would need to do against a CIM Server.

Mobile phone texting (txting) is now ubiquitous - a comfortable UI to everybody that has a cell phone. With most age groups, the time spent texting far exceeds time making voice calls. Logically, Java developers should be considering txt interfaces to their applications.

We will look at adding mobile txt interfaces to three applications:

• a mobile web healthcare application with group push txt notification to other caregivers of an event
• an iPad POS web application for ordering from your car via txt from your mobile phone
• an installed Swing application to display group txting for public display

In November 2011, Gilt Groupe announced the availability of International Shipping on gilt.com. This feature was jointly developed by Gilt's New York and Portland engineering teams. Key pieces of this project were written in Java and Scala. Join us for a discussion about the production rollout strategy for this feature.

Heroku is a Polyglot Cloud Application Platform that supports Java, Scala. This session will teach you how to deploy apps using a "git push". The session will also address the importance of the share-nothing architecture for cloud scalability and alternatives to sticky sessions and session replication.

We will be discussing 2 open source portlets for Liferay that I recently created which integrates Twilio and PubNub. Twilio provides infrastructure APIs for businesses to build scalable, reliable voice and text messaging apps. PubNub provides real-time push notification PLUS unique device to device mass broadcasting. We'll look at easy of use of these 2 APIs and the Spring MVC portlets that wrap them.

• PubNub - Cloud Service Java API
• Twilio - Cloud Service Java API
• Wrapping the services with Spring MVC Portlets
• Deploying them with Liferay

More information on the portlets and the projects can be found at http://puresrc.com/web/guest/knowledge

This is a discussion about being agile with continuous integration (CI) in a Java enterprise. Topics covered will include:

• Continuous integration tools
• To branch or not to branch?
• When to commit
• When to build
• Self-testing builds
• Build storage

This is a discussion on how Nike replaced a legacy JavaScript data grid with a grid written in GWT.

Topics covered will include:

• Why GWT?
• Architectural design considerations
• Packaging and deployment
• Deploying GWT into a JDK 1.4 container
• Browser compatibility issues
• Performance, performance, performance - how we made it as fast as possible
• Useful tools, libraries, and technologies
• Lessons learned

Apache CXF offers the most flexible support for both REST and SOAP of any Java web services stack, including support for different XML data bindings and JSON output for REST web services. In this presentation you'll see how to implement and deploy CXF web services, using both Java standards including JAX-RS and JAX-WS and custom CXF extensions. You'll also learn about the different configuration options supported by CXF, including Spring-based, annotation-based, and direct configuration in code, and get an idea of how easily web services projects can be implemented using CXF. Finally, you'll see how CXF fits into the Apache open source SOA infrastructure.

JSON has become the de-facto data interchange format for Internet web services. We'll examine open source libraries that make it easy for a Java developer to serialize objects to JSON. This presentation will include a discussion of three popular Java libraries ( json.org, Jackson, and GSON ) as well as a popular Scala library (lift-json).

This talk will provide a overview of Urban Airship's core data warehouse architecture - a system designed to handle capture, intake and analysis of data for 100s of millions of mobile devices with near real time precision. The talk will touch on Urban Airship's use of HBase, Hadoop Core, ZooKeeper, Kafka as well as home-grown services. Time permitting, the talk will also cover how Urban Airship takes a lean approach to working with volumes of data including the use of ad-hoc tools such as Pig and Cascading as well as how the company leverages the data architecture for fast customer discovery and innovations.

Are you interested in learning what a Java Virtual Machine (JVM) is and what it does for your Java applications? This presentation will provide insight into the inner workings of a Java Virtual Machine and some drill down on what compilers and garbage collectors do, so that you don't have to worry about it while programming your Java application.

In particular, you will learn about common optimizations, well established garbage collection algorithms, and what the current biggest challenge with Java scalability is today.

For the Java coder, GWT is currently as close as it gets to a multi-platform solution for web apps. After a quick GWT review, we will code about in the world of web apps you can run on your desktop and mobile phone, written in Java. This will be a superview presentation touching on GWT, GWT mobile libs and HTML5.

Google unveiled Android 3.0 in February 2011. This release provides a new UI and other features that are suited for mobile tablet devices. In this presentation, we'll discuss Android's new platform API's and highlight changes in the developer SDK.

The NoSQL movement has given developers many more data storage options, each with their own design considerations and trade-offs. One of the quieter options, semantic data stores (also called triple stores or quad stores), provide an interesting hybrid of key-value and graph database features, while offering a data model based on a W3C recommendation (RDF) and a standardized query language (SPARQL) that will feel familiar to anyone experienced with unfashionable SQL.

This talk will cover the basics of data modeling with RDF and how to use the open source Jena Semantic Web Framework to add a semantic datastore to a Java-based Web application.

Hi, I'm Merlyn, a Portland-based programmer with strong ties to both Agile PDX and Groovy. I'm also a member of an Agile team at YesMail, and I blog under the handle "curious attempt bunny".

Come to the session if you want to participate in learning more about Gradle. Gradle is a powerful layer of Groovy built on top of a number of established tools and libraries. Smart guys have borrowed from the pioneering work of Ant, Maven, Gant, Buildr and come up with an expressive, concise, and convention-rich build tool for the Java family.

For this session, there won't be any slides. I'm also not going to stand up and talk at you. Instead, I'm going to rely heavily on your involvement. I'll start with an introduction to Gradle, and then very quickly go into using it in practice. After a few minutes of that I'll open it up to go wherever we're most interested in. I'm not a Gradle expert, yet I believe that my Groovy background in conjunction with a few days of earnest usage have taught me a lot. This session will rely heavily on an internet connection, and we'll be googling for answers together if need be.

Do this ahead of time:

What is your intention for the session? Spend some time deliberately focusing on what it is you want out of the session. Bring that will you and share it with us. It will help us all focus on what's important and go some way to helping you get the most out of the session. Also, go have a quick read about Gradle on their website. That will save us all some time, help us get to the interesting details sooner, and be a good source of informed questions for you.

I'll also be building in some time at the end of the session to gather feedback that will help me learn to become a better facilitator.

There have been a number of recent significant high profile developments in the Java world. Taking these into account what does the future of Java hold? Bring your opinions and bias in what promises to be a lively, interesting discussion on an important topic.

This discussion will loosely work around the following areas and other topics that arise. We will hit the ones with the most interest first and work through them as time permits.

• Java the language (syntax) - improvements, changes for the worse. What about future versions of Java? What does the turnover in Oracle and the community mean?
• Java the API including the Enterprise and Mobile Java - What will happen with these?
• Oracle vs Google - what does it mean for Java?
• Future of the Java community - future of the JCP/JSR process
• What do Oracle's lawsuits mean for Java? Are they good or bad?
• Java FX - Is it being presented to the right audience?
• Future of other languages with Java ties - Scala, Groovy, Jython, etc.
• Java as open source/specification - Apache Harmony, etc. What will happen? Will Java cease to be FOSS or anything close? What will happen to the specification? What about other open source technologies within Oracle?
• Effect on career strategies. Does this make other options/technologies more attractive for people new to Java? What about experienced people?

Doug will present his notes from this years JavaOne (And Oracle Dev) Conference. Come listen and share!

Almost every transaction executed on a JEE Application Server winds up distributed over multiple resources such as JMS destinations and JDBC datasources. Standard OTLP systems employ the XA-2PC protocol, a presumed-abort variant of the Two-Phase Commit protocol to make sure that either all resources commit successfully or all resources abort the transaction if at least one resource fails. As any distributed consensus protocol, XA-2PC is expensive. In this talk, we present Logging Last Resource (LLR) optimization of XA (actually, its JEE "translation" in form of the JTA spec) in Oracle WebLogic Server. LLR's effectiveness has been validated in world record results achieved by the Oracle stack in the SPECjAppServer2004 benchmark and by high-profile customers in mission-critical applications.

Smartphones and other alternative computing devices are the future, but there's so many platforms and specs to develop for? How can a developer build apps and websites for all of these different devices without breaking the budget or schedule? Answer: the Mobile Web. Modern HTML, JavaScript, and CSS form the foundation of apps and websites that can be deployed to lots of devices, creating a good experience for both your users and the developers.

In this session Josh will give you an introduction to the Mobile Web, provide some real world examples, then dive into the technologies available to help you get your stuff onto mobile devices. This talk is not Palm webOS specific, but will cover webOS phones as well as other mobile devices.

Bring your opinions, experience and personal bias and join in a lively discussion on a highly pertinent topic.

Topical questions include but are not limited to:

• Applications written using HTML, CSS and Java Script (DHTML) have some advantages but what requirements, if any, would sway a project towards -Flash, Applets or Java F/X?
• Is there significant differences between consumer versus business based applications that would cause cause a particular technology to be used?
• Are they days of Flash numbered or is the current trend towards pure DHTML doomed because of fragmentation in the browser market?

Ant build scripts are an integral part of building and deploying many Java technology-based applications, but they're often custom-built for each project and vary across the enterprise. This presentation shows how Nike, Inc., reduced its Ant build scripts to almost nothing while preserving the functionality needed to do highly customized builds for everything from small standalone batch jobs to large enterprise projects.

This topic will be of interest to developers who develop and maintain Ant build scripts for multiple applications and need ways to minimize the amount of time and new scripts they need to write.

The session covers:

• How to write Ant scripts in an object-oriented paradigm, including inheritance, extending, and overriding
• How to make most application build scripts 10 lines or fewer
• How to unit-test build scripts
• How to version build scripts

WebSockets is an exciting new technology that enables bidirectional communication between web applications and server-side processes. Google's Chrome browser already provides WebSockets and developers can expect to see the technology in other browsers in 2010. This presentation will cover the WebSocket protocol and JavaScript API. We'll also discuss Jetty's WebSocketServlet API and demonstrate how to use WebSockets in a GWT application.

Why is it that the percentage of women graduating with computer science degrees around 50% in countries like Sweden, China and India, but less than 20% in America? As a "Geekdad" with a daughter, I found this unacceptable, and decided to do something about it... I went back to school... elementary school that is, to teach programming to the kids. My goal was to find an environment and a style that would encourage girls with curiosity to enjoy being controlling computers in creative ways, and in the process, encourage and involve every kid.

My talk discusses the journey of coming up with a girl-friendly curriculum for teaching programming that boys wouldn't notice anything different. I then show off some of the new crop of "Integrated Learning Environments", i.e. Alice, E-Toys and Scratch. I finally give an overview of my "Computer Club" and how others can use what I've done to teach others.

In the push to make use of tagging and other forms user-driven information architectures, developers have overlooked the value of adding semantics, or contextual meaning, directly to the data that powers web sites and applications. The addition of Microformats to a Web site's markup can further the exchange of semantic information such as contact information for people and events. For the most part, however, web sites and applications are still populated by largely non-semantic prose organized in large blocks of HTML or generated from the walled gardens of relational databases and data warehouses.

While everyone agrees that HTML isn't going away anytime soon, several Web Standards have arisen over the last few years to help application developers store, serve, and distribute information with ever-increasing levels of semantics and meaning. The current pinnacle of the Semantic Web Standards pyramid is OWL - the W3C's Web Ontology Language. In this talk I will describe the roots and basics of OWL and how it can be used to power the next generation of smart, data-enabled Web applications.

The Spring Insight console, part of tc Server Developer Edition, is a dashboard view of real-time Spring application performance metrics. Without changing their code, developers can use Spring Insight to detect, analyze and diagnose application performance issues right from their desktops.

• A graphical look at application performance: Within Spring Insight, application performance is graphically displayed via response time charts and histograms, providing developers an easily digestible view into where processing time is spent.
• Easy navigation to identify the root causes of concerns: Expandable call trees enable developers to drill down into application requests and controller actions.
• Integration with SpringSource Tool Suite to fix problems: By integrating SpringSource tc Server Developer Edition with SpringSource Tool Suite, developers gain a deeper understanding of how the application is functioning and performing by isolating a transaction trace and quickly jumping to the portion of code that is causing a problem.

Google Web Toolkit (GWT) is a development toolkit for building and optimizing complex browser-based applications. This talk will highlight new features in GWT 2.0. We'll discuss GWT 2.0 development mode, declarative UI, layout panels, and the new Google Plugin for Eclipse. Here's a link to the "podcast by phone" application. The app's GWT code is viewable here.

Josh will catch us up on the latest JavaFX release, 1.2, which includes lots of improvements to make JavaFX better for real world apps (speed, more controls, charts and graphs). Josh will also give us a sneak preview of features coming in future versions of JavaFX, along with some great demo apps.

Java Enterprise Performance Tuning typically is viewed as someone else's job.

QA will do it.
Operations will figure it out.
Isn't the Dev guys supposed to find these things?
But in fact it can and should be done across the lifecycle.

We will explore this new concept and other topics such as:

• GC diagnosis while under load
• Is my Framework doing what I want?
• Hello? Is this thing (caching) on?
• Who's your daddy? (How do services really interact)

GPC4J is a computing paradigm that breaks a partitionable problem into GridPackets, which are routed, processed and re-assembled into the solution to the original problem. This presentation will cover the use of the system and design of the project's web application. The application is built using REST (Jersey), Maven, Hibernate, JPA, MySQL and GlassFish. Project website is http://71.193.199.218

Google App Engine lets you run your web applications in Google's datacenters. This presentation will focus on App Engine's Java runtime. We'll cover developer tools, the datastore, and core platform services. In addition, we'll discuss how to call third party web services from within the App Engine environment.

We will discuss building a Java Swing application (installed or web start) that saves it's data POJO's (Plain Old Java Objects) into SQL databases across the net (mySQL) or to a local embedded database (Derby) by using the JPA (Java Persistance API) and ORM (Object Relational Mapping) via Toplink or Eclipselink. You will see that REAL applications get to benefit from technology that typically lives in the world of Hibernate and Web Apps. You gotta love portable SQL database data persistance without building any tables or writing any SQL!

Project Bonneville is Chris Cowell-Shah's evenings-and-weekends open source project for measuring the performance of certain core Java SE features. Chris will review the results of these benchmarks with an eye to addressing the following questions:

• How does performance vary across JVM vendors?
• How does performance vary across JVM versions?
• How does performance vary across operating systems?
• How does the performance of 1.4 features differ from their 1.5+ replacements?
• How true are commonly held assumptions about Java performance?
• Can we generate simple rules of thumb for high-performance Java SE programming?

Scala is a new language for the Java Platform that blends object-oriented and functional programming concepts. This talk will focus on the design choices of Scala, and what they mean for developer productivity. The talk will highlight what it means to program in a functional style, and show you how Scala facilitates a hybrid of functional and imperative programming styles. The talk will also explore how Scala compares to dynamic languages such as Ruby and Python. And you'll see examples of real, production Scala code that will illustrate what it feels like to program in Scala.

• RIA as the next generation of Software
• Back to the Client-Server Model
• Adobe's RIA Software Development Platform

• What is Flex?
• Open Source SDK
• ActionScript & MXML Languages
• Components
• How do you use Flex?
• Compiler
• Debugging

• Installing BlazeDS into a Web App (WAR File)
• Remoting (RPC style object invocations over HTTP)
• Pub/Sub Messaging
• Spring Integration

Join us for a conversation about web service programming. We'll discuss OAuth, an open protocol for secure API authorization, and Restlet, a REST web service framework. Additionally, we'll look at the OAuth Java API and demonstrate how to use OAuth in an Android application.

Functional programming is (again) a hot topic among developers. Languages such as Scala and Clojure have functional concepts at the core of the langauge, and even more solidly object-oriented languages such as Groovy and C# 3.0 include functional concepts. This talk will cover whether langauge really matters, some functional techiques that enhance the power of a languge, how to implement some of these using existing Java syntax and semantics, and the future of functional additions to the Java langauge.

Talk about strange bedfellows: what happens when you mix one part Lisp (one of the oldest computer languages), one part Java (so young, yet so well adopted), a healthy serving of functional programming, and a state-of-the-art concurrency layer on top? That's Clojure, which "feels like a general-purpose language beamed back from the near future." Clojure embraces functional programming with immutable data types and first class functions. It is fully interoperable with Java. Clojure's approach to concurrency includes asynchonous Agents, and Software Transactional Memory. Clojure is fast, elegant, dynamic, and scalable: a language for the future, today.

Patrick will present his work on a new open source initiative named Able. Able is a combination of a library and quickstart template that aims to tightly integrate several modern Java frameworks: Hibernate (persistence), Stripes (web framework), Guice (core container), and DWR (AJAX). By taking advantage of libraries that embrace annotations and generics, Able simplifies Java web development and provides integration at several levels, including validation, transaction handling, and object lifecycle management.

If you want to do some reading in advance, here are some relevant links:

• Able: http://code.google.com/p/able
• Hibernate: http://hibernate.org
• Stripes: http://www.stripesframework.org
• Guice: http://code.google.com/p/google-guice
• DWR: http://directwebremoting.org

As you know, Groovy is a slick scripting... er, dynamic language that integrates very well with the Java platform and Java technologies. This presentation will go over a way to introduce Groovy into your organization and programming environment via unit testing. After a brief introduction to the language, we'll go over why Groovy can make unit testing easier.

GWT is Google's Web Toolkit, a framework for building rich web applications entirely in Java. While a lot of people have heard of GWT, most haven't had a look to see just how easy it really is.

GWT allows you to collapse your technology stack. Without GWT, getting a web application to look and behave just right requires knowledge of HTML, JSP, JavaScript, CSS, JSTL, Java, the web framework of your choice, etc. Wouldn't it be nice if you could do everything you needed in Java and just used CSS for display formatting? GWT lets you do that. GWT lets you impress your friends with your JavaScript wizardry without having to be a JavaScript wizard. This talk will be an introduction to GWT, showing how to write a whole app in it, or else augment your existing web apps with GWT widgets. Advanced topics, such as integration with Seam, interoperability with legacy JavaScript and third-party JavaScript libraries, and code reusability will also be covered.

Finally, a live demonstration of coding in GWT will be shown, demonstrating how fast it is to develop web apps using this framework.

Poker bots! The term conjures images of programmers hacking away late at night, trying to make a fast buck. But how interesting is the subject really? Well, as it turns out, very interesting. The game of poker poses the dual problems of nondeterminism and limited information, making computer poker implementations a deeper conceptual challenge than deterministic open-information games like chess. Better, there now exists a body of academic literature dedicated to analyzing the subtleties of the problem. But best of all, the de facto standard environment for development of poker AI software is 100% pure Java.

This talk will begin with a bit of historical context, delve into the problem space, and then offer a demonstration and source-level view of working "bots". The bots run in an offline, not-for-money, but highly competitive game environment.

Basic knowledge of the rules to Hold'em Poker (both limit and no-limit tournament varieties) is helpful to understand the presentation. This is a legitimate AI presentation aimed at professional software developers and students. No license agreements or U.S. laws were violated during its creation - and if your goal is to "cheat" at online poker, this presentation won't help you very much.

Part 1 Hibernate the Traditional Way

• Issues in object-relational mapping (ORM)
• Overall goals of Hibernate
• Hibernate architecture
• Map a simple class to a database using a Hibernate XML mapping file
• Retrieving, inserting, updating, deleting Hibernate persistent objects
• Querying with Hibernate Query Language (HQL)

Part 2 Hibernate with the Java Persistence API (JPA)

• JPA Overview
• Map a simple class to a database using JPA annotations
• Retrieving, inserting, updating, deleting JPA persistent objects
• Querying with JPA Query Language (JPQL)
• Comparing Hibernate-traditional with JPA Hibernate-JPA

Android is a software stack for mobile devices that includes an operating system, middleware and key applications. In this talk, we will discuss Android's platform API's and developer tools. We'll look at code for GPS location services and learn how to call Trimet's XML web service from an Android application.

The Gang of Four book should have been entitled "Palliatives for Statically Typed Languages", because the recipes it provides are cumbersome solutions to the problems it poses. Using powerful languages makes the solutions in the GoF book look hopelessly complicated. This session shows how to solve the same problems concisely, elegantly, and with far fewer lines of code using the facilities of dynamic languages.

WebDAV is a set of extensions to HTTP that enable clients to manage files on a remote server. In this talk, we will examine the WebDAV specification and learn how a WebDAV client communicates with a WebDAV server. Also, we will discuss how to use the Apache Jackrabbit WebDAV API to program a WebDAV client and a WebDAV server.

Dynamic languages on the JVM, an overview of up and coming new languages for the JVM and what advantages they have over pure Java; including Groovy, JRuby, JavaFX, and Scala. Also covers what improvements will be coming in the JVM to better support dynamic languages

Do you use Ant for your project builds? This talk will show you ways to improve your build scripts, expose common pitfalls, and should change the way you think about your build scripts. Included is a discussion on what Nike is doing to unify its build process. Our goal - a build script in 10 lines or less.

Think you're a Java expert? I did, too, until I read "Java Puzzlers" by Josh Bloch and Neal Gafter, which uses code examples to illuminate some of the more interesting characteristics of Java. This talk will present puzzles that are different from those in the book to show some of the sharp edges and corner cases of the language and API. While the immediate lessons taught by the puzzles are themselves instructive, the more important takeaway is being able to recognizing what sorts of things you need to watch out for, particularly when editing and debugging other people's code. The solutions will attempt to no only solve the puzzles, but also attempt to prevent mistakes and be elegant and beautiful.