Session Descriptions
Brian Goetz - Author of Java Concurrency in Practice
Effective Concurrent Java
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.Garbage-collector-friendly programming
To many developers, garbage collection is black magic. Accordingly, there are is a lot of conflicting advice about what is good or bad for the garbage collector. In this talk, I look at how garbage collection is implemented in the HotSpot VM, and techniques for writing programs that exhibit good garbage collection behavior. Surprisingly, many of these techniques coincide with writing good, clean code.Squashing bugs with FindBugs
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.Structuring concurrent applications in JDK 5.0
JDK 5.0 is a huge step forward in developing concurrent Java classes and applications, providing a rich set of high-level concurrency building blocks.The Java Memory Model
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.Brian Sletten - Forward Leaning Software Consultant
Give it a REST
As developers, we sometimes get to make choices about the technologies we use, sometimes not. We base these decisions on personal experiences, recommendations from others and a general sense of where the industry is going.Web Services have been all the rage for several years now. We have been told time and again that we should be building systems around them; as an industry, we've never been more confused. Perhaps it is time to Give it a REST.
RESTlet for the Weary
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.Prerequisite: Give it a REST (unless you are very comfortable with REST)
Resource-Oriented Computing w/ NetKernel : Software for the 21st Century
Imagine the simplicity of REST married to the power of Unix pipes with the benefits of a loosely-coupled, logically-layered architecture. If that is hard to imagine, it may because the architectures available to you today are convoluted accretions of mismatched technologies, languages, abstractions and data models.NetKernel is a disruptive technology that changes the game. It has been quietly gaining mind share in the past several years; people who are exposed to it don't want to go back to the tired and blue conventions of J2EE and .NET. Not only does it make building the kinds of systems you are building today easier, it does it more efficiently, with less code and a far more scalable runway to allow you to take advantage of the emerging multi-core, multi-CPU hardware that is coming our way.
Come see how this open source / commercial product can change the way you think about building software.
Viva La Javolution!
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.
What's Going On? : Complex Event Processing w/ Esper
How well do you understand the dynamics of your applications? In our systems, we detect when simple things happen. Customers log in, people buy things, a stock is sold at a particular price, inventory shifts locations... all of these events mean little things, but what about the larger picture? Complex events are particular patterns of simpler events that suggest something deeper is happening. Do you know how you'd discover these bigger picture occurrences? Come hear how the Esper open source software represents a new class of complex event processing (CEP) frameworks that can be added to even high volume, high transaction systems.David Bock - Principal Consultant, CodeSherpas Inc.
Estimating vs. Guessing - How Agile Teams Estimate Their Work
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?Intermediate Maven
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.
Maintaining Project Integrity with JDepend, Macker, PMD, Maven, and other open source tools
How many times have you started a new project only to find that several months into it, you have a big ball of code you have to plod through to try to get anything done? How many times have you been the ?new guy? on an established project where it seems like the code grew more like weeds and brambles than a well-tended garden? With a few good structural guidelines and several tools to help analyze the code, we can keep our project from turning into that big ball of mud, and we can salvage a project that is already headed down that path.Surviving Middle Management
Most good developers eventually have the opportunity to be managers. Whether they call you the "project manager", "Technical Lead", "Lead Developer", or some other classic middle-management title, you become the 'goto' guy between management and developers. You're the guy who is expected to keep the project in-line, track a schedule, and occasionally answer the question "How's it going?", and perhaps still contribute at a technical level. So how do you do that?David Geary - Author of Graphic Java and co-author of Core JSF
Facelets
Facelets is a combination of Tiles and Tapestry, and it's the hottest JSF-related open source project on the planet. It's popularity is well deserved, and in fact, much of what is in Facelets today will make its way into the JSF 2.0 spec due out in 2008. So not only can you come to this session and see some really cool demos that you can put to use in the real world, but you'll also be learning JSF 2.0 before it's even been defined! How's that for a ROI?Prerequisite: Some knowledge of JSF is essential. If you're familiar with a templating framework, such as Velocity or Tiles, that's a plus, but not required.
Filthy Rich Clients with the Google Web Toolkit, Part I
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.Filthy Rich Clients with the Google Web Toolkit, Part II
In the second part of this talk, you will learn how to extend the GWT by implementing custom widgets, including a scrolling viewport and a drag and drop framework. After discussing custom widgets, you will see how to integrate database access into your GWT applications, and how to deploy your GWT applications to external servers.Intro to Seam
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.JavaServer Faces: A Whirlwind Tour
In April 2005, annual growth rates for jobs in JavaServer Faces, Struts, and Ruby on Rails were all at about 0%. Today, Struts' growth rate still hovers around 0%, but JSF and Rails have taken off. At the end of 2007, both JSF and Rails were growing at a rate of between 400-500% annually (according to indeed.com).JSF has passed the adoption tipping point, and is now the Java-based framework of choice, as is evidenced by its ecosystem. From vendors such as MyEclipse and RedHat to open source projects such as Seam, Facelets, and Ajax4JSF, JSF is where the action is.
Come see why JSF is so popular. In this code- and demo-intensive session, I'll show you the fundamentals of JSF.
Prerequisite: Some knowledge of Java-based web applications, such as Struts, is a plus, but is not required. If you have a significant experience with JSF, you probably already know most of what's covered in this session.
Using Ajax4jsf
Ajax4jsf makes it very easy to add Ajax to your JSF applications. Come to this presentation to see how.Jared Richardson - Agile coach and co-author of Ship It
10 Tips for Getting Your Project Back on Track
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.Build Teams, Not Products
A great team builds great software, but how do you build a great team?Career 2.0: Take Control of Your Life
Has your career been a random product of your manager's whims or company's needs? Never rely on your company to keep your skills current and marketable. Take control of your own career with a proven strategy.Credit Card Software Development: Recognizing and Repaying Technical Debt
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.Restoring Agility: Getting Your Team Back on Track
An agile team is first and foremost "a team". When that gets lost in the rush to get a product out the door, the people suffer as well as the products. It's bad for the company, but even worse for the team members. We'll learn how to defuse some of the more common problems you'll run into on dysfunctional teams.Techniques 2008
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.Jeff Brown - SpringSource Engineering And Professional Services - Groovy and Grails Developer
A Thorough Introduction To Groovy
Groovy is an agile dynamic language for the Java platform. The language and its libraries bring many things to the table to ease the process of building applications for the Java platform. This session provides a detailed run through Groovy with lots of code samples to drive home the power of the language.Advanced Web Development With Grails
Grails makes web application development both fun and easy. This session dives beyond the basics to cover advanced details of Grails that bring the really exciting features to your applications.Prerequisite: Grails - Agile Web 2.0 The Easy Way
Agile Test Driven Development With Groovy
Dynamic languages bring a lot of interesting elements to the table for teams interested in doing Test Driven Development (TDD). Groovy lends itself very well to TDD and this session demonstrates many features of the language and its libraries that help teams build more testable systems and build better tests.Grails - Agile Web 2.0 The Easy Way
Grails is a full stack MVC framework for building web applications for the Java platform. Grails makes web application development both fun and easy. This session covers all of the fundamentals of building web applications with Grails.Powerful Metaprogramming Techniques With Groovy
Metaprogramming is a key component in building truly dynamic and flexible applications with Groovy. Groovy's metaprogramming capabilities bring great new possibilities to the table that would be very difficult or just plain impossible to write with Java alone. This session will demystify a lot of the magic that seems to be going on inside of a Groovy application.Prerequisite: A Thorough Introduction To Groovy
Mark Richards - SOA and Enterprise Architect, Author of Java Transaction Design Strategies
EJB3 Core Specification (JSR-220)
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.Enterprise Messaging Using JMS (Part 1)
The chances are good that at some point in your career you will need to use messaging to pass information between applications, subsystems, or external systems, particularly with service-oriented architecture on the rise. The Java Messaging Service (JMS) allows Java applications to implement messaging using a standard API, thereby removing the dependency on any particular messaging provider. In Part 1 of this session we will take a look at some of the basics of messaging, including sending and receiving messages, message types, and request/reply messaging. I will begin the session by going over the basics of messaging and the JMS API. Then, through interactive coding using OpenJMS I will demonstrate how to connect to JMS providers, send messages, receive messages, and use message properties. Please note that this is a two part session.Enterprise Messaging With JMS (Part 2)
In Part 1 of the JMS session I covered messaging models, messaging basics, the JMS API, and point-to-point messaging. In this interactive code-intensive session I will cover some additional JMS topics such as browsing queues, load balancing, publishing and subscribing to messages within the pub/sub model, durable and non-durable subscribers, message selectors, and message filtering. I will also discuss and demonstrate message prioritization, persistent and non-persistent messages, and finally message expiration (expiry). Note that this is Part 2 of a two-part JMS session.Prerequisite: Enterprise Messaging With JMS (Part 1) or some knowledge of JMS
Java Persistence: Approaching the Silver Bullet
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.SOA Unplugged
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?Transaction Design Patterns
Most web-based applications rely solely on the database to manage transactions, thereby freeing the developer from having to worry about transaction management. While this works in some circumstances, there are times when the use of transactions is vital to the integrity and operations of an application and its corresponding data. In this session I will demonstrate through real-world coding examples why transactions are such a critical part of the application development process. I will review the basics of both programmatic and declarative transactions, then introduce three transaction design patterns and explain when they should be applied, how to use them, and what problems they solve. By the end of this session you will see that by using transaction design patterns you can build an effective transaction management strategy for your application with very little effort.Neal Ford - Application Architect at ThoughtWorks, Inc.
"Design Patterns" in Dynamic Languages
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.Agile Project Management (With Just a Bit About Mingle)
You can read books about Agile projects, but you must consult real-world experience to really understand the dynamics of agile project management. This session discusses agile management topics including estimation, project tracking, and useful metrics (and how to obtain them). And just a little about Mingle, the agile project tracking tool from ThoughtWorks.Code Metrics & Analysis for Agile Projects
What does code + methodology have to do with one another? Everything! Agile projects focus on delivering working code, and tools exist to allow you to verify some quality metrics for your code. This session is a survey of tools and metrics that allow you to determine the quality of your code and strategies to "wire it" into your agile project.Introduction to JRuby
This session describes JRuby, the 100% pure-Java implementation of the Ruby programming language. It covers the basics of programming with JRuby and examples of how to integrate it into existing Java projects.Meta-programming JRuby for Fun & Profit
Ruby is the revenge of the Smalltalkers. Not since Smalltalk has a language had such powerful meta-programming facilities. While this may seem like a minor feature, it turns out that surgical meta-programming allows solutions to problems that are clearer, more concise, more maintainable, and take orders of magnitudes fewer lines of code.Regular Expressions in Java
Regular expressions should be an integral part of every developer?s toolbox, but most don?t realize what an important topic it is. Regular expressions have existed for decades, but many developers don't understand how to take full advantage of this powerful mechanism, either through command line tools and editors or in their development.Test Driven Design
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.The Productive Programmer: Mechanics
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!Ted Neward - Enterprise, Virtual Machine and Language Wonk
The Busy Java Developer's Guide to Annotations
Want to get the soup-to-nuts story on Java annotations? In this presentation, we'll first talk about what annotations provide to the Java language. After setting ourselves a conceptual basis to operate from, we'll look at the language definition for Java annotations, from how to use them to how to define them. Finally, we'll take a look at the other side of annotations, consuming them at source-level (using "apt", the annotation processing tool), class-level (using a bytecode toolkit such as BCEL), and at runtime (using enhancements to the Reflection API made in Java5).The Busy Java Developer's Guide to ClassLoaders
If you've ever gotten a ClassCastException and just knew the runtime was wrong about it, or found yourself copying .jar files all over your production server just to get your code to run, then you probably find the Java ClassLoader mechanism to be deep, dark, mysterious, and incomprehensible. Take a deep breath, and relax--ClassLoaders aren't as bad as they seem at first, once you understand a few basic rules regarding their operation, and have a bit more tools in your belt to diagnose ClassLoader problems. And once you've got that, and hear about ClassLoaders' ability to run multiple versions of the same code at the same time, and to provide isolation barriers inside your application, or even compile code on the fly from source form, you might just find that you like ClassLoaders after all... maybe.The Busy Java Developer's Guide to Hacking with the JDK
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.The Busy Java Developer's Guide to Java Platform Security
Permissions, policy, SecurityExceptions, oh my! The Java platform is a rich and powerful platform, complete with a rich and powerful security mechanism, but sometimes understanding it and how it works can be daunting and intimidating, and leave developers with the basic impression that it's mysterious and dark and incomprehensible. Nothing could be further from the truth, and in this presentation, we'll take a pragmatic, code-first look at the Java security platform, including Permissions, the SecurityManager and its successor, AccessController, the Policy class and policy file syntax, JAAS, and more.The Busy Java Developer's Guide to Performance and Scalability
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?Venkat Subramaniam - Founder of Agile Developer, Inc.
Caring about your Code Quality
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.
Essence of Agility
Begin agile is more than saying your organization is committed to being agile or your team is agile.FP on JVM
Functional Programming Languages (FPLs) have been around for a long time. A lot of features that we get excited aboutin 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.
Know your Java?
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.
Towards an Evolutionary Design
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.
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.
Pratik Patel
Enterprise Architect
Pratik Patel wrote the first book on 'enterprise Java' in 1996, "Java Database Programming with JDBC." He has also spoken at various conferences such as the Net Database Summit, WWW7 and the Atlanta Java User's Group (AJUG).
Pratik's specialty is in large-scale Java applications for mission-critical use. He has designed and built enterprise applications in the retail, health care, financial services, and telecoms sectors. Pratik holds a master's in Biomedical Engineering from UNC, has worked in places such as New York, London, and Hong Kong, and currently lives in Atlanta, GA.
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).
