Meeting Archive

Presented by: Morgan Creighton, Stevel Lintz, Prashant Kulkarni, Craig Lupin, and Mark Johnson

Overview:

Let's face it development is fun but configuring environments and infrastructure takes all the fun out of programming.  How often have you spent days trying to figure out which settings for your NoSQL database, new library, source control service only to realize that the solution involved only typing the 5-10 characters in the correct sequence.  You are not alone!

Presented by: Christophe Coenraets

Overview:

HTML has emerged as a powerful alternative to “native” and enables cross-platform mobile application development. 

In this session, you will learn modern strategies to build complex and native-like mobile applications using HTML and JavaScript, and powered by a Java back-end.  You will also learn how to build a RESTful API using JAX-RS and Spring, how to efficiently consume REST services and structure large JavaScript projects using an MVC framework like Backbone.js, and how to use PhoneGap to leverage the capabilities of your device (camera, gps, accelerometer, etc.) in JavaScript, and package your HTML application as a native app for distribution through the different app stores.

Tags: Mobile, HTML, JavaScript, Java, JAX-RS, Spring, REST, Backbone.js, Phonegap

Presented by: Brian Tarbox

Overview:

The best way to learn a new language is to use it, but there is an enormous gap between HelloWorld.scala and a "real" project.  To help with my own learning of Scala I rewrote my Log4JFugue Open Source project which at about 2500 lines of code was big enough to be real yet small enough to be manageable.  We will briefly describe the problem space addressed by Log4JFugue, then summarize the architecture of the Java version.  The majority of the night will be a hands-on, code-on-the-fly recreation of the Scala version from scratch.  You will see the differences between the languages and get a feel for coding in the functional paradigm.  No background in Scala is required.

Presented by: Peter Bell

Overview:

What is MongoDB, why would you use it, how do get started and what are the "gotcha's" to look out for? We'll start with a very brief survey of NoSQL data stores, then we'll dig into why you'd consider using Mongo and how to get started with it.

Presented by: Burt Beckwith

Overview:

This session will include an introduction to the Grails dynamic web application framework and the Groovy language, with highlights from the new features in Grails 2.0 (including agent-based reloading, unit testing mix-ins, and new enhancements to support Servlet 3.0) and Groovy 1.8.

We'll also go beyond the basics and demonstrate real-world usage of Grails while live-coding a working Grails application from scratch using Spring, Hibernate, JMS, and other technologies to demonstrate how quickly you can develop Java EE applications in Grails.

Presented by: Douglas Hawkins

Overview:

In this presentation, Doug Hawkins will discuss how the Dalvik VM is
different from traditional Java VMs and the motivations behind those
differences.  Along the way, you'll learn about Android's service
architecture, Dalvik's byte code format, and the surprising details of
how Android installs, launches, and executes applications.

Presented by: Andrew Lee Rubinger

Overview:

In this session, we'll address the missing link in Enterprise Java development: simple, easy integration testing.

Unit tests and mock objects will only take you so far; the only answer which truly ensures that all components are playing nicely is a comprehensive integration suite. Unfortunately, writing integration tests has historically involved manual setup of a heavy, cumbersome test harness. That's time lost, but it doesn't have to be anymore.

Presented by: Mark Johnson

Overview:

We have all heard use this language or that framework or this product and you can create the perfect enterprise application. After all these years do you still believe that?  The truth is to produce a successful enterprise application we need to have a solid development language, frameworks, lightweight containers, monitoring through the application life cycle and infrastructure stack, plus plans to manage application performance.  In short there is a lot we need to do after passing the first round of unit tests to create a sucessful enterprise application.

This session will go through the entire Application Lifecycle to demonstrate often ignored steps to produce an enterprise application.  The concepts covered in this presentation are applicable with most technologies; but for our purposes we will focus on Spring ROO & Grails, Hyperic for monitoring, Tomcat 7 for the container, Webtest for functional testing, Cobertura for code coverage, plus a few other technologies.

Presented by: Neal Ford

Overview:

Learning the syntax of a new language is easy, but learning to think under a different paradigm is hard.
 
This session helps you transition from a Java writing imperative programmer to a functional programmer, using Java, Clojure and Scala for examples. This session takes common topics from imperative languages and looks at alternative ways of solving those problems in functional languages. As a Java developer, you know how to achieve code-reuse via mechanisms like inheritance and polymorphism. Code reuse is possible in functional langauges as well, using high-order functions, composition, and multi-methods. I take a variety of common practices in OOP languages and show the corresponding mechanisms in functional languages. Expect your mind to be bent, but you'll leave with a much better understanding of both the syntax and semantics of functional languages.
 

Presented by: Various NEJUG Members

Overview:

Some of the best presentations over the past 10 years have come from our very own members.  This very special meeting will feature presentations from our own members.  The scheduled presentations include; Hazelcast, Schema Crawler, The Strangler pattern for incremental application migrations, Open Standards, and BDD.  This meeting promises to be one of our more exciting meetings, so register early!

Presented by: Nermin Serifovic

Overview:

Scala is a JVM programming language that blends object-oriented and functional concepts. We are all well familiar with the object-oriented aspect but lot of us seem to struggle when it comes to functional programming. Unfortunately, a large number of Scala talks and articles present functional programming in a way it just makes your brain hurt. You start believing only math-minded can truly comprehend it. Furthermore, you get an impression Scala is only a good fit for problems which need to be solved in a pure functional style. All of which is, fortunately, far from being true.

The goal of this talk is twofold. It will aim to demistify functional programming as a paradigm through examples in Scala. Furthermore, it will try to show that Scala is not all about functional programming, but has another side which can immensely benefit regular Java developers. As a bonus, it will demonstrate how Scala allows these two programming styles to complement each other

Presented by: Rohit Bhardwaj

Overview:

Android is a mobile operating system running on the Linux kernel. It was initially developed by Android Inc., a firm later purchased by Google, and lately by the Open Handset Alliance. It allows developers to write managed code in the Java language, controlling the device via Google-developed Java libraries.

Presented by: Mark Fisher and Thomas Risberg

Overview:

Applications are increasingly facing demands for horizontal scalability and cross-platform interoperability. NoSQL data stores are gaining momentum as a way to address the scalability challenges. Messaging systems, on the other hand, are by their very nature able to handle widely distributed deployment models, but for Java developers, the cross-platform challenge suggests we should look beyond JMS. Open protocols such as HTTP, SMTP, and AMQP are attractive language-neutral alternatives.

In this session, you will learn how the Spring application platform is evolving to accommodate these trends. We'll explore the Spring Data APIs for working with a variety of NoSQL data stores, and we'll compare and contrast several open protocol options for both synchronous and asynchronous messaging via Spring Integration Gateways and Channel Adapters.

Presented by: Tim Berglund

Overview:

You've read that the relational model is old and busted, and there are newer, faster, web-scale ways to store your application's data. You've heard that NoSQL databases are the future! Well, what is all this NoSQL stuff about? Is it time to ditch Oracle, MySQL, and SQL Server in favor of the new guard? To be able to make that call, there's a lot you'll have to learn.

In this session, we'll take a whirlwind tour of five representative non-relational data stores: Cassandra, MongoDB, Voldemort, Redis, and Neo4J. We'll learn the very different ways they represent data, and we'll see their unique strengths and weaknesses in various kinds of applications. Along the way, we'll learn why new technologies must be introduced to address today's scaling challenges, and what compromises we'll have to make if we want to abandon the databases of our youth. We'll review what ACID means, role-play a two-phase commit, and even talk a little bit about file system semantics. It's an exciting time to be storing and retrieving data, and the opportunity is now before us to learn things we could ignore just a few years ago. Come to this session for a solid introduction to a growing field.

Presented by: Alexander von Zitzewitz

Overview:

Every time a new software project is launched everybody aims for a high-level of technical quality. But more often than not we see the code quality deteriorating over time and it becomes harder and harder to understand and maintain the code. On the other hand a reasonable level of technical quality can be easily achieved in any software project, if it is kept in mind as a goal from the beginning. Of course it is necessary to measure it on a regular base, ideally at least in the nightly build.

Presented by: Douglas Hawkins

Overview:

Doug's presentation will delve into three internal parts of Java…

- Class File Format and Byte Code

- Garbage Collection

- JIT Optimizations

In the Class File Format and Byte Code section, the basic structure of the class file format will be explained with examples of Java files compiled to class files.  Additionally, attendees will be introduced to tools for viewing and writing byte code.

In the Garbage Collection section, attendees will be familiarized with garbage collector terminology and see demonstrations of garbage collection illustrated by monitoring programs with VisualVM.  As a conclusion to this section, we'll talk about the upcoming HotSpot garbage collector: G1.

In the final section on JIT Optimizations, performance optimizations of HotSpot will be discussed by walking through some of the compile time and run time optimizations that occur in a modern Java environment.  To demonstrate these optimizations, performance of programs with and without various hand optimizations will be compared using Java 6 and Java 7.  In the end, this section will illustrate that usually you don't need to sacrifice elegance to achieve performance.

Presented by: Mark Fisher and Tom McCuch

Overview:

Presented by: Rohit Bhardwaj

Overview:

In this session we will take a deep dive at few cloud computing examples and participants will be able to know how to use cloud computing for Google App Engine and Amazon EC2.

 The Google App Engine is a platform for developing and hosting web applications in Google-managed data centers. The Google App Engine is an example of cloud computing technology as it virtualizes applications across multiple servers and data centers. It is, at its heart, a powerful cloud computing platform designed to help you more easily create and manage scalable, JVM-based web applications. If you’re developing a Java application on App Engine you probably already know that you can use JPA and JDO Java persistence APIs to interact with the data store. Now learn how to take full advantage of these powerful APIs. We will explore few examples from Amazon EC2 like how to deploy groovy on grails application. We will also look at development tools to make your life easier while working with Amazon EC2, Amazon S3 and Simple db.

Presented by: Venkat Subramaniam

Overview:

Scala is a static fully object-oriented, functional language on the JVM. While taking advantage of the functional aspects, you can continue to make full use of the powerful JVM and Java libraries. In this presentation we will take a in depth look at what Scala is, its strengths, weaknesses, and why, when, and where you'd use it on your applications.

Presented by: Someone

Overview:More details