|
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.
|
Presentations by Neal Ford
10 Ways to Improve Your Code
No one writes perfect code, and every developer eventually falls into a slump where they just crank out the same code day after day. This session illustrates 10 different ways to improve your code, covering sacred cows, good citizens, smells, and more.
Last year, I did a talk called Clean Up Your Code: 10 Coding Tricks, Techniques, and Philosophies. The concept behind that talk was to point out common mistakes and treacherous paths that Java sometimes exhibits. This talk is essentially the sequel to that one, discussing code hygeine from a more
advanced level. This talk discusses a wide swath of topics, including good citizenship, appropriate messaging between objects, canonicality, reflection & code generation, improving your abstractions via domain specific languages, sacred cows, code generation, common code smells, and anti-objects. The goal is to make you think differently about the code you write every day. No one writes perfect code, and every developer eventually falls into a slump where they just crank out the same code day after day. This talk helps identify your pitfalls and how to avoid them.
Session Topics:
- Good citizenship
- Sacred cows
- Methods & messaging
- Canonicality
- Mixins
- Reflection
- Code generation
- Abstraction upgrade via DSLs
- Common code smells
- Anti-objects
Implementing SOA
This talk avoids SOA hype and gets to the meat of the matter: how do you implement a Service-Oriented Architecture, what are the technological pitfalls, how do you test it, and what traps should you avoid. No marketecture: just implementation details.
No subject has been subject to more recent hype than Service-Oriented Architecture (I think it was because of a really good article in an in-flight magazine). For whatever the reason, the CxO has decided that we need one. It's up to you to implement it. This session is all about the technical considerations required to implement a service oriented architecture. It discusses technology choices, what is in (and out) of SOA's scope, how to implement transformations, routing, and other key services, how to version endpoints, and finally testing and debugging SOA. This session is marketecture free: it covers the details you need to implement this style of architecture.
Session Topics:
- What SOA means to those who must implement it
- Technology choices
- Routing
- The WS deathstar
- MOM
- Implementing transformations
- Versioning services
- Testing SOA
- Debugging SOA implementations
Metrics-driven Agile Development
Agile software development is a highly disciplined way to build software, and one of the side effects of this discipline is the ability to gather meaningful metrics. This session describes what makes agility perfectly suited to metrics gathering and what kinds of real-world metrics you can generate.
A lot of managers think that the "Extreme" in Extreme Programming is like the Extreme on ESPN 2, and that Agile software development just means that everyone does whatever they want. Actually, the opposite is true: agile software development is a highly disciplined way to write software. Some of the characteristics of agile software development allow you to gather extremely useful metrics at both the project and code levels. This session is about those metrics, how to gather them, and what they mean. I show results from real projects and describe how you can accurately predict the completion date for a software project. This session is based on real-world experience from lots of ThoughtWorks projects, and shows why agile projects can be highly successful.
Session Topics:
- Why Agile is different
- Useful software development metrics
- The keys to metrics-driven development
- Project metrics
- Burn up/down charts
- Velocity
- Code metrics
- Code coverage
- Cyclomatic Complexity
- What metrics tell you
- What metrics cannot tell you
Building DSLs in Static and Dynamic Languages
This session discusses building Domain Specific Languages and DSL-style code in Java, Groovy, and Ruby. It discusses the different types of DSLs, details on how to implement them in Java, Groovy, and Ruby, and example problem domains where DSLs make sense.
You've heard all the hype for the past couple of years: Domain Specific Languages (DSLs) are going to take over the world. This session demystifies this topic in 2 ways: by providing concrete definitions for styles and applicability of DSLs and showing how to implement these different styles. I build up definitions for the different types of DSLs in static (Java) and dynamic (Groovy and Ruby) languages. Then, I discuss building DSLs as internal (i.e., built on top of an underlying language) and external (built using a preprocessor or grammar), with examples of each. Throughout this session, I discuss the applicability of this style of development and show targeted examples. I discuss fluent interfaces and techniques for building them, including problems. Incidentally, I show some cool language features of both Groovy and Ruby that make building DSLs easier in those languages.
Session Topics:
- Why DSLs
- Abstraction
- Internal vs. External DSLs
- Fluent Interfaces
- Building Blocks
- Internal DSLs
- In Java
- In Groovy
- In Ruby
- The Stopping Problem
- Best Practices and Applications
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.
Like hamburger & fries and turkey & dressing, JRuby allows you to harness the awesome power of Ruby in your Java projects. This session describes the origins, capabilities, and limitations of JRuby, the 100% pure-Java implementation of the Ruby programming language. This session also demonstrates some areas where it makes sense to mixin Ruby and Java code: Rails on Java, testing, and dynamic programming. JRuby is a powerful implementation of Polyglot Programming, and this session shows you how to leverage this cutting-edge concept.
Session Topics:
- JRuby's origins
- Calling Java from Ruby
- Calling Ruby from Java
- Limitations and pitfalls
- Example usage
- Rails on Java
- Testing
- Dynamic programming
- The future
Rails for JRuby
This session explains all the hype surrounding Ruby on Rails, in a context familiar to Java developers. It covers convention over configuration, ActiveRecord, controllers, views, Ajax, scaffolding, testing, and deployment...on the JVM, using JRuby.
Find out why everyone won't shut up already about Ruby on Rails! This web framework for Ruby has appeared from nowhere to become the critics darling: there must be good reasons why. This session shows those reasons, in a context familiar to Java developers. It discusses how configuration works in Rails, persistence through ActiveRecord, scaffolding, controllers, views, and Ajax. It also covers the important topic of testing, and how Rails makes it easy and automatic. Finally, this session discusses deployment on the JVM, using JRuby, and reflects back on the important lessons that Rails teaches Java developers. This session also presents information about the boundary between Rails, Ruby, and JRuby.
Session Topics:
- Why Ruby? Why Rails?
- Getting started
- JRuby and Rails
- Convention over configuration
- Scaffolding
- ActiveRecord: Persistence done right
- ActionPack
- Controllers
- Views
- Ajax for free
- Testing
- Deployment
- Reflection
Power Regular Expressions in Java
Regular expressions should be an integral part of every developer’s toolbox, but most don’t realize how important 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.
This session shows how to fully exploit regular expressions. It begins with the basic premise of how regular expressions work, then shows how to take advantage of the RegEx library built into the Java platform. This session shows how to use wildcards, escape characters, meta-tags, character class operators, look-aheads/look-behinds, and how to use the greedy operators effectively. It covers regular expressions from the beginning through to advanced usage, both in Java and in tools that support regular expressions. This session is packed with real examples of regular expressions (including a game show with no fabulous prizes).
Key Session Points:
- Regular expressions defined
- Examples
- Using the regex classes in Java
- Regular expression techniques
- Patterns
- Groups and subgroups
- RegEx Game Show!
- Back references
- Greedy, reluctant, and possessive qualifiers
- Lookaheads and lookbehinds
- Practical regular expressions
- Best practices
- Common Regex mistakes
Pragmatic Extreme Programming
This session talks about how to actually get XP done in the real world (and what to tell your boss). This session includes artifacts (like project tracking sheets) from real XP projects.
Extreme programming sounds a little too “ESPN2” for most managers, but there is a lot of sound engineering behind its principles. My employer, ThoughtWorks, has been extremely successful using the full XP stack and we have developed lots of experience with it. This session talks about how to do XP in the real world. XP is all about feedback loops, so I discuss how to replace the radical sounding ones with more palatable ones. I talk about the parts of XP that are absolutely vital (unit testing, collective ownership, continuous integration, etc) and the ones that you can introduce a little more slowly (pair programming, only a 40 hour work week). This session focuses on the practicality of XP and how you can adopt it at your organization. I also talk about political battles with managers, other departments, and barriers that pop up anytime you try to introduce change in a large enterprise. Discussion is encouraged (required) in this session.
Key Session Points:
XP and Feedback Loops
A pragmatic look at the XP practices
- The planning game
- Small releases
- Metaphor
- Simple design
- Testing
- Refactoring
- Pair programming
- Collective ownership
- Continuous integration
- 40-hour week
- On-site customer
- Coding standards
Sample Project Tracking Sheets
Code Coverage
Overcoming objections
What to say to your boss and his boss
XP in the real world
