Joseph Nusairat

By Joseph Nusairat

JBoss Seam is one of Java's ways of providing agile development to enterprise Java applications. Seam is designed to take away the headache of linking JSF, EJB3, AJAX, and jBPM by using interception directed by user defined annotations. The end result is smooth and easily manageable code without the plumbing usually required for functionality. This session will take you through the process of how Seam works, creating a sample application, and what Seam can buy you for enterprise setup including the pros and cons.

Ever since the J2EE spec was released people have been writing code to cope with the awkwardness of a specification written by tool vendors for tool vendors. Generally this involved implementing patterns, writing wrappers, and writing custom frameworks to handle what should have been part of the specification. Resumes began to be cluttered with items like ?service locator pattern? and ?front controller pattern? experience. As needs grew so did the Java Community and they responded accordingly. Frameworks like Spring and Hibernate grew out of need and necessity to accommodate what was lacking. However, one area has been constantly lacking in enterprise applications is the glue to bring it all together. Seam grew out of this need to seamlessly, no pun intended, tie different components and Java frameworks together. What started out as simple glue for EJB3 ? JSF has grown rapidly and with fanfare. Not only was it used to glue presentation to business tier but many other components as well like mail, rules engines, PDFs and now one can even write Seam beans in Groovy. In this presentation we will go over what Seam is and what Seam can offer a development team. Seam can solve problems that normally required custom frameworks. While custom frameworks are always fun to develop, they take up resource time and can bring in another area of instability to the application. Whether your application is a simple web store or a complex enterprise application Seam can be used to cut development time down, and let your developers focus on the items that count: the business logic, the presentation, and your domain structure.

By Joseph Nusairat

This presentation is designed to give users an introduction to what Grails has to offer. The presentation will show how fast one can get up and running with Grails.

For the last decade we have been trying to get web application development performed faster and faster. Struts was the first Java web application that had wide spread adoption to start to get web application development faster. Of course years later we realized it was still quite slow. Along the way came items like Spring, Hibernate, Ruby on Rails, and finally Groovy. All of these pieces together, and quite a bit of hard work from many people helped to bring together into the framework we know as Grails.

This presentation will show how one can create a web application that meets all your needs much faster and more agile than before with Grails. We will cover the basics of starting from scratch, creating your models, views, and domains to have a fully built application in the end.

By Joseph Nusairat

Groovy's usefulness in Java development keeps going up and up, and with Swing that is no exception. While Swing apps before have been considered boring, ugly and hard to maintain ... much of that can be changed with Groovy. Applying Groovy, SwingXBuilder, and JGoodies we will show how to make old swing apps not only look prettier but be more easy to maintain and actually provide more functionality for.

Most that have used Swing have a love - hate, and some even have a hate - hate relationship with it. Swing development can be tedious and worse ugly. In this presentation we will show how to make creating applications with Swing easier than before. Groovy, with it's closures, make's it a perfect platform for writing embedded applications like Swing. With it tools like SwingBuilder and SwingXBuilder have come out to make this process easier by providing support for normal Swing operations via closures.

We will step through creating a few Swing applications with Groovy, and show the options available to make your Swing applications prettier with Groovy.

Prerequisite: Basic Groovy could be helpful but not mandatory.

By Joseph Nusairat

Vital to any development is the ability to test that application. Most frameworks have their very own testing suites, EJB3 is no exception and their are a variety of testing apparatuses. We will examine testing with JBoss Embedded, EJB3Unit and mocking with Easy Mock and JMocks.

Testing with EJB3 produces new issues that most developers have not seen locally. For one thing, their are generally no DAO's when dealing with Java Persistence API. Because of this it makes whats normally called integration or container testing more valuable even at the unit level, since no other piece of the application will be testing them directly. In this session we discuss two of the major ways to perform integration testing. The first is through a light container called EJB3Unit. This is an easy to set up testing framework that uses HSQL as the underlying database. However, EJB3Unit is more of a cross between unit and integration testing, for full on Integration testing we will use JBoss Embedded to get a richer feel. In addition, when using the integration frameworks is not as necessary, or when you need to add some mock testing to your EJB3Unit tests we will discuss two mock frameworks. The first are EasyMocks, the second is a newer framework that allows a bit more versatility called JMockIt. By the end of this you should be ready to go and test your EJBs thoroughly.

Prerequisite: Knowledge of EJB3.

By Joseph Nusairat

JBoss Seam, now in it's 2.0+ version, is more than just a glue between the JSF & EJB3 world. Seam provides shortcuts and functionality that even experienced Seam users may not be fully aware of. In this presentation we will cover basic Seam conversations but also cover annotations and tags you may not knew existed.

Many people use JBoss Seam just to have a short cut between JSF and EJB3, however there are sooo many features in Seam that can be used that you may have not seen. In this presentation we are going to go through a variety of technologies and tags to create advance functionality that goes from front end to back. We will cover items like the conversation context, internationalization, themes, asynchronous calls, event/observer patterns, and many more ... this will assume you know the basics of Seam since we won't be covering that in any great length.

Prerequisite: Intro to Seam or any Seam experience.

By Joseph Nusairat

One of the tasks that can be the most difficult for developers is batch processing. Spring has added batch processing to its repertoire of frameworks now available. Available as a separate download this presentation will show what spring batch processing is and how to use it.

One of the most difficult operations to run effectively in an enterprise environment is batch processing. Often times you are dealing with huge amounts of data that must be run concurrently, in multiple steps, and worse yet we need a way to manage them in case they fail or abruptly shut down. Often times we rely on home grown solutions that generally require some cron job, mixed with sending items to a JMS queue for processing, with an MDB picking it up for processing. While many of these options "work", they are often filled with kluge and poor error handling. Spring Batch Processing is Spring's way of bringing some order and logic to batch processing. This presentation will step through how to use spring bath processing to create batched programs, complete with retry and error logic. By using Spring the hard part of creating reliable, reusable code is done for you; freeing up the developer to focus efforts solely on the business logic. And what's best, the actual business logic does not have to be Spring beans, they can be anything you want from POJOs to EJBs.

By Joseph Nusairat

This presentation will go over how to use JBoss Business Process Management (jBPM) to create work flows that help streamline workflow business logic in a more manageable system. These systems can be ran from a purely batch point of view or via human interaction.

In addition we will also go over using the page flow with jBPM. Both sets of topics will make use of the Seam annotations to help drive there code, but they are not 100% necessary either.

Many large systems use multiple reusable components. Often what differentiates these systems is the flow of data through the components. It can be cumbersome and messy to define this flow logic in Java code by itself. Not only is it much more difficult to alter it or to create multiple control paths that are related, but it is also difficult to visualize these flows. To help with this problem JBoss has JBoss Business Process Management (jBPM). This system allows for a graphical interactive tool to create flows complete with starting points, tasks, decision nodes, etc. This way you can graphically create the flow of data, assign what services belong at each area and have the application run. This presentation will go over how to set up that very concept in your next Java project.

In addition we will also discuss how to control web page flow in a project. This can be very useful when dealing with workflow in an application. Something like checking out of an online store or anything that requires specific steps to continue.

Prerequisite: Some understanding of Seam will be helpful.

By Joseph Nusairat

This presentation will go over how to set up your continuous integration environment with Hudson, including having it create your various type of Java and Grails projects from multiple sources.

Continuous integration has been around for a while and most are familiar with cruise control. While cruise control can be a very powerful tool setting it up can sometimes be a headache. Hudson offers a much easier route to setup and manage. In addition its extensive easy to use plug-in architecture allows one to add functionality for different items like twitter notifications, pulling data from different repositories, and running different types of code metrics. This presentation will show how we set up Hudson to build for various environments.

By Joseph Nusairat

This presentation will show how to create behavior driven testing for your Java or Groovy code with easyb.

One of the latest trends in testing lately is to create behavior driven testing. This allows one to structure tests in a more readable manner and instead of testing methods allows you to test behaviors. For example when given certain conditions and a certain action ran what is the outcome you expect? This kind of testing is not only more readable but allows you to test a variety of different conditions much faster. In this presentation we will discuss how to use easyb to test our Java code more effectively.

By Joseph Nusairat

This presentation will go over how to use Spring Web Flow in Grails to make easy to use page flow based applications. This allows to create pages that can alter flow without any hard coding inside of the pages themselves.

One of the hottest new features coming out of the spring team is Spring Web Flow. With the 2.0 released recently, it will start to gain even more support. What is Spring Web Flow you ask? Simply it is a way one can easily construct the flow of the website without having to make the services aware of what page the service should forward to next. However, this is not just about controlling the flow, with Spring Web Flow one is able to keep state of the objects for the duration of the flow, one is able to stop someone from entering in the middle of the flow, and most importantly one can create alternate paths inside the flow. All of these features give your application added functionality that it didn't have before and with less code than would take for one to implement by themselves. So what's the downside to Spring Web Flow? It's written and defined in XML. However, with the Spring Web Flow integration with Grails that will not be the case. We are able to design flows with Groovy for a truly readable representation. Using the groovy builder syntax to define the flow, this presentation will show how one uses Spring Web Flow and how easy it is to integrate it inside our Grails applications.

Prerequisite: Any beginning Grails presentations.

By Joseph Nusairat

There is virtually no way to get around mock testing in Java these days. When testing services its intricately important to test JUST that one service. In this presentation we will go over 3 popular frameworks EasyMock, JMock, and JMockit to show how to use mock testing.

When testing a service it is important to only test THAT service (at least for unit testing) You want to essentially test your service against various scenarios and outcomes. More often than not these scenarios occur due to different data being sent and returned from outside services and how your service interacts with that data. This can be hard to test for normally, however with mocks we can essentially mock out the calls to these services. We define in our test case what we expect that outside service to receive (parameter wise) and what data to pass back. This allows us to test that our service is performing with that data as expected.

We will look at three different popular mock frameworks out there: EasyMock, JMock, and JMockit to perform our testing with. We will see how each of these handle mocking different and which you may prefer for your needs.