We will take a look at building HTML5 web applications in Java using the open source Vaadin framework. Vaadin takes a different approach to web application development by automating many of the most time consuming aspects of traditional web development. Instead of constructing your application from low level DOM elements and manually handling communication and data serialization, Vaadin  takes care of server-client communication and allows you to work with higher level UI elements in Java. The end result is a great looking HTML5 web application that you can use in any browser.

During the presentation, we'll build a Vaadin application from scratch to demonstrate the basic principles and development practices hands-on. We'll take a look at why and when you would want to use Vaadin, and will also investigate how things work under the hood. At the end of the presentation you should have learned enough that you can start building your first Vaadin application. 

ALSO, we have a 15-minute Lightning Talk:

You've come up with a killer idea for an app that you want to dive into, but first you need to bootstrap the project and code in order to get to the point where you can actually work on your idea. Slogging through dependencies, setting up configuration files – none of that is fun.

Frameworks like Ruby on Rails, Grails, and many JavaScript tools are designed to allow you to rapidly generate scaffolding (boilerplate) code to help you get going with both a project and with individual pieces of your application. One of the emerging solutions for Java-based projects is JHipster ("Java hipster"), which enables you to quickly generate a Web application based on Spring Boot that includes AngularJS support and automatically adds a number of excellent libraries for securing, managing, monitoring, and testing to your project.

Kyle Smith is going to walk you through setting up a new project using JHipster and show you some of the features you get out of the box. He'll also look briefly at some of the features that modern applications are expected to include, such as metrics, health checks, and auditing.

We've all heard – and we've even said it ourselves, that “soft skills” make a critical difference in an engineer's career. Oddly, despite this recognition of their importance, the whole cluster of soft skill competencies are rarely given more than lip service. With the April 9 meeting, the NEJUG will make a multi-faceted push to rectify this short fall.

In a series of short presentations, experienced professionals from a range of companies will each focus on one or two specific soft skills, such as Integrity in Work, Listening, Cooperation and Alignment, Technical Writing, Leadership, Public Speaking, and others. Each presenter will give their perspective on the importance of their skill topic, share in detail how it makes a real difference, and – most importantly, provide a specific technique for developing that skill. Where appropriate, a live demonstration of the technique will be made, possibly including a short in situ exercise.

After about 5 of such mini-presentations, we will switch to a panel discussion format. One or two prepared questions will get the ball rolling, after which we will take questions from the floor. As time allows, the panel should have at least 20 – 30 minutes to deepen this very important conversation.

Almost every non-trivial software system suffers from the accumulation of technical debt and structural erosion. With every new release quality metrics and developer productivity go down, while it becomes more and more difficult to change or maintain the system. While agile processes have certainly helped to improve some aspects of software development they do not automatically improve technical quality or encourage software craftsmanship. This session first looks at the technical and social causes of this industry wide problem. From there the focus will shift to possible solutions involving organizational changes,  process improvements and tool-based fully automized control of quality metrics and architecture.

Modularity is coming to the Java platform! Java 9 will introduce the Jigsaw module system. OSGi is here today. But don’t wait to start designing modular software. Contrary to popular belief, you don't need a framework or a new runtime to start building modular software applications. You can start today. Learn how!

In this presentation, we'll examine what it means to develop modular software on the Java platform. We'll examine the goals and benefits of modular software, and explore the patterns of modular architecture that help us develop modular software systems. With just a few easy steps, we'll see how to transform our software from a huge monolith to an extensible system of collaborating software modules. By examining an existing software system, we'll see first hand how we can increase software modularity with minimal disruption. You'll walk away not just with a much deeper understanding of the benefits of modular software, but also a migration roadmap for refactoring existing applications to increase their modularity. In other words, you'll see how to get ready today for the application platform of tomorrow.

When it comes to persisting data, first thing that naturally comes to a software engineer's mind is an SQL database. Even though SQL databases are the most widely used persistence technologies today, they often fail to excel when the data size grows exponentially. "Big Data" gave birth to many NoSQL databases that are designed to address scalability issues. However NoSQL databases introduced other problems, such as lack of transactional support, lack of relationships (joins) etc. This presentation focuses on a technology called Titan which provides the best of both worlds (SQL and NoSQL). 

Titan is a highly scalable distributed graph computing framework with a pluggable architecture for backend data stores. This plugin feature supports several NoSQL data stores like Cassandra, HBase, BerkeleyDB, Hazelcast, etc. with just a configuration change.Titan is proven to support hundreds of billions of vertices and edges in the graph and thousands of concurrent graph updates and retrievals. This presentation will start with basic concepts of GraphDBs and jump into different concepts of Titan with a range of examples. Also, there will be a section about achieving transactions and joins using Titan/Cassandra.

NEJUG is finishing up the 2014 season with an Advanced Topics Double Feature. First up will we'll have Concurrent Programming in Java 8, followed after the break with our second presentation on Application Level Metrics.

Concurrent Programming in Java 8, by Morgan Creighton

Concurrent Programming is notoriously hard.  But is it difficult because humans aren't very smart, or because we often use the wrong abstractions to program concurrent systems?  Java 8 brings greater expressiveness to the language, and allows concurrent programs to be more readable and reasonable.  This talk introduces a few concurrent programming paradigms, and offers a deep dive into Deterministic Dataflow, which allows sequential algorithms to be systematically parallelized.  We'll learn how choosing the right abstraction in a functional language allows us to pare away extrinsic complexity, and make concurrent programming pleasant.

Application Level Metrics, by Seckin Tozlu

This presentation will introduce the concept of "Measure Anything, Measure Everything" and the technology that can be leveraged for its implementation in Java using statsD and its Java library, Graphite and Grafana. Following Etsy’s Measure Anything, Measure Everything mantra, we’ll show how to diagnose issues before they have a major negative impact on customers, encouraging developers to take ownership of their code by making trivial code changes to add application-level instrumentation. Application metrics are usually the hardest, yet most important, of the three metrics categories (which also include network & machines). They’re very specific to your business, and they change as your applications change. Their value is immense and we will show how they can be implemented easily and leveraged by all. We’ll discuss the impact of application-level metrics, the software used, custom implementations, their current shortcomings and the future of monitoring & alerting.

This month we're having a double-team from Stratus Technologies, with a distinct 45-minute talk in each half of the meeting.  First, Keith Meyer will present Stratus Openstack Cloud Product Architecture, focusing on the technical underpinnings, and some of the ways Stratus is making Cloud Technology both easier to manage and more highly available.  After the break, we'll look more closely at Cloud Workload Availability with Aaron Smith presenting Fault Tolerant KVM in the Cloud.

This talk explores building modern JavaScript web applications with the Ember.js framework. It starts with a brief discussion on JavaScript's evolving role in web applications, then introduces the Ember framework at a high level, and concludes with some live coding examples.

Daniel will be presenting a NEJUG-formatted presentation of the same material he is planning for the upcoming New England Software Symposium (NFJS). From the session description:

Didn't you hear the news? TDD is dead. Yet many developers rely on it for quality code. Come join the zombie apocalypse and learn and understand TDD, what sets it apart from unit testing after the fact, what to do when you need to update code, effective mocking, automatically generating test data and lots of it, leaving code alone and respecting your work, and more!

This presentation will cover:

• What is TDD?
• Benefits of TDD
• How to TDD
• Mocking
• The Great TDD Debate
• Opinions of TDD from Industry Leaders
• JVM Testing Tools
• JVM Testing Languages
• Testing Static Calls
• Updating Code

The Apache Solr framework is an open source search platform written in Java.  This software stack is capable of quickly finding relevant information from your enterprise content sources (e.g. web sites, file shares, RDBMS repositories, email and social media) using simple keywords and filter queries.

As Java developers, we are in an excellent position to harness the power of Apache Solr and build useful search-based applications.  This presentation will be divided into two parts.  The first part will introduce you to its most popular features including: full-text search, relevancy matching, hit highlighting, faceting, spell checking, rich document (e.g. MS Office, PDF) processing, and geospatial search. In addition, we will discuss the importance of a good extract, transform and load (ETL) process to the index population phase and review some best practices around the development of search-based applications.  The second part of the presentation will drill down into several of the features and provide a more in-depth discussion of how to properly implement them in order to enhance the search experience of your users.