Session Highlights
Don't miss your chance to attend more than forty education and solutions sessions:
- Seating is Limited
- In-depth Discussions
- Peer Exchange
- Access to Speakers
- Expert Panel Discussions
- Hands-on Code Examples
- Best Practices
- Birds of a Feather Session
- Insight on Cutting-Edge Tools
Featured Sessions
By Brian Goetz
What's the worst thing that can happen when you fail to synchronize in a concurrent Java program? Its probably worse than you think -- modern shared-memory processors can do some pretty weird things when left to their own devices.
By Brian Goetz
Does your program have bugs, despite unit tests, integration tests, and code reviews? You bet. Are you using static analysis as part of your QA process? If not, you're probably missing out on some bugs that can be caught before they bite your customers.
By Brian Goetz
The Java programming language has turned a generation of applications programmers into concurrent programmers through its direct support of multithreading. However, the Java concurrency primitives are just that: primitive. From them you can build many concurrency utilities, but doing so takes great care as concurrent programming poses many traps for the unwary.
By Brian Sletten
If you have started to take a look at REST as way of exposing web services or managing information spaces, you may be frustrated by the support offered by legacy containers. There is no direct support for REST concepts in the J2EE specs (yet). XML-based configurations are so 1990's. Come learn about Restlets, a little API that has caught the attention of many in the RESTafarian community.
By Brian Sletten
You're a good Java programmer. You understand the JDK libraries and how to use them. The problem is that many fundamental APIs don't take the bigger performance picture in mind. Garbage collection can end up killing your app if you aren't careful. Concurrency problems and contention can keep your well-intentioned software from leveraging modern hardware architecture that support multi-core and multi-cpu systems.
Who knew that simply using the standard library code the way it was designed was opening you up for performance problems in your apps?
Don't worry, Javolution has your back.
By David Bock
Maven is a build tool that does a lot, demos well, and leaves the build maintainers managing what seems like unbridled complexity. It doesn't have to be that way - Maven is driven by some strong 'build process methodology', and that complexity can become manageable by wrapping your head around it. Furthermore, you can migrate to Maven 'piecemeal', by mapping your existing ant build to the Maven Lifecycle and calling your existing Ant tasks - you can decide to sip the Maven kool-aid.
Ideally, a build tool should be so simple and approachable that it fades into the project background and allows anyone to maintain it. Unfortunately, Maven's power comes at the expense of this ideal - Maven's philosophy is more like "the build process is so important that the people maintaining it should be steeped in the ways of Maven". This talk will give you the exposure you need without elevating The Maven Way to a religion.
By David Bock
Estimating is regarded as little little more than 'educating guessing', but so much can hang on the quality of those estimates. With good estimates we can set clear expectations for project delivery, but with bad estimates we can run over schedule and over budget, or worse. We often estimate when we know the least about the work that needs to get done - so how can we make the best of what is potentially a bad situation?
By David Geary
Have you ever stopped to think that you need to learn two frameworks to develop a non-trivial, database-backed, web application? Struts and iBatis; JSF and Hibernate; Tapestry and EJB3.0.
By David Geary
The Google Web Toolkit (GWT) is truly a revolutionary framework that lets you develop Ajaxified web applications without knowing anything about Ajax or JavaScript. But the GWT goes way beyond basic Ajax by letting you implement desktop-like applications that run in the ubiquitous browser.
By Jared Richardson
Software projects fail over and over for many of the same reasons. We'll look at some of the more avoidable problems and some solid ways to fix them, or avoid them in the first place.
By Jared Richardson
There are a number of great techniques you can use across technologies and projects. Come hear some of my favorites and contribute a few of your own. We'll discuss topics from DRY to creating a zone defense for your product.
By Jared Richardson
Technical debt has long been recognized in technical circles for years, but convincing your manager to budget time to repay "technical debt" has always been problematic. Let's couch the term technical debt concept in language more familiar to our managers: credit card debt.
By Mark Richards
Awareness about Service Oriented Architecture (SOA) has grown significantly in the past several years. Unfortunately, along with that growth has come a significant amount of confusion about what SOA really is. SOA has become such a ubiquitous buzzword that it now has many faces and means different things to different people. CIO's, managers, vendors, business users, architects, and developers all see SOA differently which creates a sea of confusion about what is and isn't SOA. In this highly interactive and thought provoking session we will look beyond the hype and marketure of SOA and explore SOA from an architecture and development point of view - in other words, SOA as an architecture pattern. During this session we will look at SOA use cases, services, integration, implementation, guiding architecture principles of SOA, and attempt to answer the following question: What is and isn't SOA?
By Mark Richards
EJB3 (JSR-220) offers some great improvements over the prior EJB specs in terms of development simplicity and new features. In this session we will explore in detail some of the new features of the core EJB 3 specification. Included in this session will be a hands-on discussion and demonstration of session beans, dependency injection, interceptors (aop), and Message-Driven Beans (MDB). For the interceptors discussion I will be showing how to define interceptors for enabling a method trace, mocking objects, and sending JMS message notifications to be later picked up by the MDBs I will be creating. During the session I will demonstrate the new features of EJB 3 through interactive coding examples. Note: this session does not cover the new Java Persistence API (JPA) - only the core specification.
By Mark Richards
Java Persistence has come along way since the days of straight JDBC coding and custom framework development. We have at our disposal several outstanding open source frameworks such as Hibernate, Toplink, iBatis, and OpenJPA (just to name a few), and we now have a promising and emerging standards-based solution called Java Persistence API (JPA). However, all to often we find in the Java persistence space that it is a world of one-size-does-not-fit-all. We continually struggle with traditional ORM solutions like Hibernate when it comes to reporting queries, complex queries, complex relationships, and stored procedures, and we also struggle with managing the enormous amount of SQL required for solutions such as iBATIS or JDBC-based frameworks. In this coding-intensive session we will take a detailed look at identifying and overcoming the challenges we face when using frameworks such as Hibernate, iBATIS, and JPA, and how to combine the various persistence frameworks to create an effective Java persistence solution that approaches (but of course does not reach) the silver bullet.
By Neal Ford
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.
By Neal Ford
Most developers think that "TDD" stands for Test-driven Development. But it really should stand for "Test-driven Design". Rigorously using TDD makes your code much better in multiple ways.
By Neal Ford
Developers from the 1980s would be shocked at how inefficiently developers use their computers because of the advent of graphical operating systems. This talk describes how to reclaim productivity afforded by intelligent use of command lines and other ways of accelerating your interaction with the computer and bending computers to do your bidding. Stop working so hard for your computer!
By Ted Neward
Wondering why your enterprise Java app just... sucks? Trying to figure out why you can't get more than 10 concurrent users online at the same time? Looking for ways to try and spot the slowdowns and ways to fix them?
By Ted Neward
Ever since its 1.1 release, the Java Virtual Machine steadily becomes a more and more "hackable" (configurable, pluggable, customizable, choose your own adjective here) platform for Java developers, yet few, if any, Java developers take advantage of it. Time to take the kid gloves off, crack open the platform, and see what's there. Time to play.
By Venkat Subramaniam
A good design is critical for success with agile development.
That does not mean a big up-front design. The design has to
be evolutionary. However, the design you evolve must be
extensible and maintainable. After all, you can't be agile
if your design sucks.
By Venkat Subramaniam
Java has been around for well over a decade now. It started out with the goal of being simple.
Over the years, its picked up quite a bit of features and along comes complexity. In this presentation
we will take a look at some tricky features of Java, those that can trip you over, and also look at some
ways to improve your Java code.
By Venkat Subramaniam
We all have seen our share of bad code. We certainly have come across some good code as well.
What are the characteristics of good code? How can we identify those? What practices can promote
us to write and maintain more of those good quality code. This presentation will focus on this
topic that has a major impact on our ability to be agile and succeed.
By Venkat Subramaniam
Functional Programming Languages (FPLs) have been around for a long time. A lot of features that we get excited about
in dynamic languages are common place in FPLs. FPLs are gaining importance due to various changes in our industry. What's exciting is that you can use them on the JVM. In this presentation we will dig into the details of what makes FPLs so interesting and look at ways to use them on the JVM?in your Java projects.
Featured Speakers
|
Brian Goetz
Author of Java Concurrency in Practice |
|
Brian Sletten
Forward Leaning Software Consultant |
|
David Bock
Principal Consultant, CodeSherpas Inc. |
|
David Geary
Author of Graphic Java and co-author of Core JSF |
|
Jared Richardson
Agile coach and co-author of Ship It |
|
Jeff Brown
SpringSource Engineering And Professional Services - Groovy and Grails Developer |
|
Mark Richards
SOA and Enterprise Architect, Author of Java Transaction Design Strategies |
|
Neal Ford
Application Architect at ThoughtWorks, Inc. |
|
Ted Neward
Enterprise, Virtual Machine and Language Wonk |
|
Venkat Subramaniam
Founder of Agile Developer, Inc. |
Registration is Closed
- 3 Day All Access Pass
- Symposium Binder with handouts from sessions you attend
- CD with all presentational content
- Meals and snacks
- Great NFJS Swag
Stay Informed
Not ready to register yet? Enter your email here to receive update notifications about this event.
RSS Feeds
Brian Goetz
Author of Java Concurrency in Practice
Brian Goetz has been a professional software developer for 20 years. He is the author of over 75 articles on software development, and his book, Java Concurrency In Practice, was published in May 2006 by Addison-Wesley. He serves on the JCP Expert Groups for JSRs 166 (concurrency utilities), 107 (caching), and 305 (annotations for safety analysis). He is a frequent presenter at JavaOne, OOPSLA, JavaPolis, SDWest, and the No Fluff Just Stuff Software Symposium Tour. Brian is a Sr. Staff Engineer at Sun Microsystems.
Brian Sletten
Forward Leaning Software Consultant
Brian Sletten is a liberal arts-educated software engineer with a focus on forward-leaning technologies. He has a background as a system architect, a developer, a mentor and a trainer. His experience has spanned defense, finance and commercial domains with security consulting, network matrix switch controls, 3D simulation/visualization, Grid Computing, P2P and Semantic Web-based systems. He has a B.S. in Computer Science from the College of William and Mary and currently lives in Fairfax, VA. He is the President of Bosatsu Consulting, Inc., a professional services company focused on web architecture, resource-oriented computing, the Semantic Web, scalable systems, security consulting and other technologies of the late 20th and early 21st Centuries.
David Bock
Principal Consultant, CodeSherpas Inc.
David Bock is a Principal Consultant at CodeSherpas, a company he founded in 2007. Mr. Bock is also the President of the Northern Virginia Java Users Group, the Editor of O'Reilly's OnJava.com website, and a frequent speaker on technology in venues such as the No Fluff Just Stuff Software Symposiums.
In January 2006, Mr. Bock was honored by being awarded the title of Java Champion by a panel of esteemed leaders in the Java Community in a program sponsored by Sun. There are approximately 100 active Java Champions worldwide.
David has also served on several JCP panels, including the Specification of the Java 6 Platform and the upcoming Java Module System.
In addition to his public speaking and training activities, Mr. Bock actively consults as a software engineer, project manager, and team mentor for commercial and government clients.
David Geary
Author of Graphic Java and co-author of Core JSF
David Geary is the president of Clarity Training, Inc. (corewebdevelopment.com), where he teaches developers to implement web applications using JavaServer Faces and the Google Web Toolkit.
A prominent author, speaker, and consultant, David holds a unique qualification as a Java expert: He wrote the best-selling books on both Java component frameworks: Swing and JavaServer Faces (JSF). David's Graphic Java Swing was one of the best-selling Java books of all-time and Core JSF, which David wrote with Cay Horstman, is the best-selling book on JavaServer Faces.
David was one of a handful of experts on the JSF 1.0 Expert Group (EG) that actively defined the standard Java-based web application framework, and he's currently helping to define the next version of JSF on the JSF 2.0 EG.
Besides serving on the JSF and JSTL Expert Groups, David has contributed to open-source projects and co-authored Sun's Web Developer Certification Exam. He invented the Struts Template library which was the precursor to Tiles, a popular framework for composing web pages from JSP fragments, was the 2nd Struts committer and contributed to Shale.
A regular on the NFJS tour, David also speaks at other conferences such as TheServerSide Symposium, JavaOne and JavaPolis. David has taught at Java University and was twice voted a JavaOne rock star, for presentations in 2005 and 2007.
Jared Richardson
Agile coach and co-author of Ship It
Jared Richardson, co-author of Ship It! A Practical Guide to Successful
Software Projects, is a speaker, consultant, and mentor with NFJS One. Jared has been in the industry for more than fifteen years as a consultant, developer, tester, and manager.
Jared can be found online at Agile Artisans.
Jeff Brown
SpringSource Engineering And Professional Services - Groovy and Grails Developer
Jeff Brown works with Engineering and Professional Services with SpringSource and is a member of the core Groovy and Grails development teams. For over 10 years Jeff has been involved in designing and building object oriented systems.
Jeff teaches a number of Java and object oriented training courses in addition to doing consulting and mentoring work for industries including Aerospace, Financial and Medical. Areas of expertise include Java, agile web development with Groovy and Grails, distributed computing, object database systems, object oriented analysis and design and agile development.
Mark Richards
SOA and Enterprise Architect, Author of Java Transaction Design Strategies
Mark Richards is a Director and Sr. Solutions Architect at Collaborative Consulting, LLC, a Boston-based Business and Architecture Consulting Firm, where he is involved in the architecture, design, and implementation of Service Oriented Architectures in J2EE and other technologies. He has been involved in the software industry since 1984, and has significant experience and expertise in J2EE architecture and development, Object-oriented design and development, and systems integration. Mark served as the President of the Boston Java User Group in 1997 and 1998, and the President of the New England Java Users Group from 1999 thru 2003. Mark is currently working on the 2nd edition of the "Java Message Service" book from O'Reilly. He is also the author of "Java Transaction Design Strategies", contributing author of "NFJS Anthology Volume 1", contributing author of "NFJS Anthology Volume 2", and contributing author of the upcoming "97 Things Every Software Architect Should Know" book from O'Reilly. Mark has many architect and developer certification, including ones from IBM. Sun, The Open Group, and BEA. He is a regular conference speaker at the No Fluff Just Stuff Symposium Series and speaks at other conferences and user groups around the country. When he is not working Mark can usually be found hiking with his wife and two daughters in the White Mountains or along the Appalachian Trail.
Neal Ford
Application Architect at ThoughtWorks, Inc.
Neal Ford is an Application Architect for ThoughtWorks. He is an architect, designer, and developer of applications, instructional materials, magazine articles, and video/DVD presentations. Neal is also the author of Developing with Delphi: Object-Oriented Techniques (Prentice Hall PTR, 1996), JBuilder 3 Unleashed (SAMS Publishing, 1999), and Art of Java Web Development (Manning, 2003). His language proficiencies include Java, C#/.NET, Ruby, Object Pascal, C++, and C. Neal’s primary consulting focus is the design and construction of large-scale enterprise applications. He is also an internationally acclaimed speaker, having spoken at over 30 developers’ conferences worldwide.
Ted Neward
Enterprise, Virtual Machine and Language Wonk
Ted Neward is a Principal Consultant with ThoughtWorks, an international consulting firm, where he specializes in high-scale enterprise systems, working with clients ranging in size from Fortune 500 corporations to small 20-person shops. He speaks on the conference circuit, including the No Fluff Just Stuff Symposium tour, discussing Java, .NET and XML service technologies, focusing on Java-.NET interoperability, programming languages, and virtual machine technologies. He has written several widely-recognized books in both the Java and .NET space, including the recently-released "Effective Enterprise Java" and "F# in a Nutshell". He lives in the Pacific Northwest.
Venkat Subramaniam
Founder of Agile Developer, Inc.
Dr. Venkat Subramaniam, founder of Agile Developer, Inc., has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia. Venkat helps his clients effectively apply and succeed with agile practices on their software projects, and speaks frequently at international conferences and user groups. He is author of ".NET Gotchas" (O'Reilly), coauthor of 2007 Jolt Productivity Award winning "Practices of an Agile Developer" (Pragmatic Bookshelf), and author of "Programming Groovy: Dynamic Productivity for the Java Developer" (Pragmatic Bookshelf).
