FREE Delivery in the UK.
Only 1 left in stock (more on the way).
Dispatched from and sold by Amazon. Gift-wrap available.
Better, Faster, Lighter J... has been added to your Basket
FREE Delivery on orders over £10.
Used: Very Good | Details
Sold by the book house
Condition: Used: Very Good
Comment: This item will be picked, packed and shipped by Amazon and is eligible for free delivery within the UK
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See this image

Better, Faster, Lighter Java Paperback – 7 Jun 2004

5.0 out of 5 stars 1 customer review

See all formats and editions Hide other formats and editions
Amazon Price
New from Used from
Kindle Edition
"Please retry"
Paperback
"Please retry"
£24.99
£9.86 £0.01
Note: This item is eligible for click and collect. Details
Pick up your parcel at a time and place that suits you.
  • Choose from over 13,000 locations across the UK
  • Prime members get unlimited deliveries at no additional cost
How to order to an Amazon Pickup Location?
  1. Find your preferred location and add it to your address book
  2. Dispatch to this address when you check out
Learn more
£24.99 FREE Delivery in the UK. Only 1 left in stock (more on the way). Dispatched from and sold by Amazon. Gift-wrap available.
click to open popover

Special Offers and Product Promotions

Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.

  • Apple
  • Android
  • Windows Phone

To get the free app, enter your mobile phone number.




Product details

  • Paperback: 266 pages
  • Publisher: O'Reilly Media; 1 edition (7 Jun. 2004)
  • Language: English
  • ISBN-10: 0596006764
  • ISBN-13: 978-0596006761
  • Product Dimensions: 17.8 x 1.7 x 23.3 cm
  • Average Customer Review: 5.0 out of 5 stars  See all reviews (1 customer review)
  • Amazon Bestsellers Rank: 1,515,293 in Books (See Top 100 in Books)
  • See Complete Table of Contents

Product Description

About the Author

Bruce Tate is a kayaker, mountain biker, and father of two. In his spare time, he is an independent consultant in Austin,Texas. In 2001, he founded J2Life, LLC, a consulting firm that specializes in Java persistence frameworks and lightweight development methods. His customers have included FedEx, Great West Life, TheServerSide, and BEA. He speaks at conferences and Java user's groups around the nation. Before striking out on his own, Bruce spent thirteen years at IBM working on database technologies, object-oriented infrastructure and Java. He was recruited away from IBM to help start the client services practice in an Austin start up called Pervado Systems. He later served a brief stent as CTO of IronGrid, which built nimble Java performance tools. Bruce is the author of four books, including best-selling Bitter Java.First rule of kayak: When in doubt, paddle like Hell

Working as a professional programmer, instructor, speaker and pundit since 1992, Justin Gehtland has developed real-world applications using VB, COM, .NET, Java, Perl and a slew of obscure technologies since relegated to the trashheap of technical history. His focus has historically been on "connected" applications, which of course has led him down the COM+, ASP/ASP.NET and JSP roads.Justin is the co-author of Effective Visual Basic (Addison Wesley, 2001) and Windows Forms Programming in Visual Basic .NET (Addison Wesley, 2003). He is currently the regular Agility columnist on The Server Side .NET, and worksas a consultant through his company Relevance, LLC in addition to teaching for DevelopMentor.

Excerpt. © Reprinted by permission. All rights reserved.

Chapter 3 Do One Thing, and Do It Well

There’s only one way to eat an elephant: a bite at a time. That’s also the best way to code. Each bite of clear, simple Java code must have a single purpose. The best Java programmers keep a maniacal focus on a single problem at a time and go to extraordinary lengths to maintain that focus. If you want to improve, emulate them.

I’m a whitewater kayaker. For a long time, I walked around every serious rapid that I faced. I could see how to run a one-shot waterfall or drop, but I couldn’t get my head around the linked moves that would take me safely through Humpty-Dumpty on the Little River, or .25-mile Pine Creek on the Arkansas. A light clicked on for me on the Watauga River in Tennessee. I learned that I just couldn’t bomb down continuous Class IV rapids with a preconceived set of moves in my head. Instead, I needed to find the natural break points within the rapids, and run many little ones. I learned to read the river and find the natural resting places within the whole. Then I could conquer one section, set up, and attack the next section. When I approached the problems this way, I received unexpected benefits. Coding, to me, is similar:

• It’s usually easier to clearly define a piece of a big problem than the whole. We all tend to get overwhelmed by large problems, but not as much by many smaller ones. Our brains just work that way, whether we’re on a river or behind a keyboard.
• When things go wrong, it’s easier to adjust or adapt if your plan is segmented.Plans change; it’s harder to change a grand, sweeping plan than several smaller ones.
• You can protect yourself from disaster. On the river, I now plan for safety one small section at a time. While coding, we must build test cases that identify problems quickly in each logical section.
• You can better reuse techniques and code. On the river, I learn new moves that I can use elsewhere. Instead of frantically paddling through a section, I use a draw stroke to avoid one rock, an aggressive brace and sweep to punch a hydraulic, and so on. In code, I build collateral and learn techniques to solve smaller, moregeneral problems. Each design pattern that you learn in context is worth any 20 that you read about.

Whether you’re a kayaker running a Class V rapid, a physicist working on a space station, or a programmer dealing on a massive problem, your approach should be the same.

Understand the problem
You must understand a problem to solve it well. Effective programming goes beyond your code editor and debugger. You need to be able to accurately gather requirements, and control the scope and expectations of your customers. There is nothing worse than a solution without a problem; it just generates more problems.

Distill the problem to its essence
It’s often said that programming is more of an art than a science. Nowhere is this axiom more obvious than in the ability to cut through clutter and find the core problem. You’ve got to recognize what belongs in the center of your problemspace and what you can push out to other classes around the perimeter, or out of the project altogether. Most of the time, less is more.

Layer the architecture
If you’re solving a difficult problem and you can only focus on one thing at a time, you must layer your architecture, with each layer handling one task. The broadest, most successful design patterns help you build effective, decoupled layers. Model-view-controller lets you design user interfaces with three layered components. Façades allow you to build clean interfaces between major layers in your application. If you like to study design patterns, pay attention to how often this theme arises.

Periodically refine your approach
Left to its own devices, software loses focus over time. You’ve got to make a concentrated effort to refactor, decoupling your software into autonomous layers. Automated tests will help you refactor with confidence and design decoupled code in the first place. Getting feedback from teammates and clients often helps make sure the approach still solves the right problems.

In this chapter, we explore each of these concepts in detail. You don’t need to go through them all to see a difference in your programming—you can benefit from each technique individually. But combining them multiplies their impact.

Understanding the Problem
Communication is a huge part of programming. Writing better Java won’t do you any good if you’re building the wrong thing: you must understand before you can code. As you advance in your programming career, you’ll find that more and more of your job demands effective communication. It doesn’t really matter where your requirements come from—your team lead, an analyst, or the customer. In each case,your first job is to accurately gather each requirement and focus your customer on what you can reasonably achieve with your resources at hand. Don’t plow your customer under with enormous requirements and arcane design documents. If the customers can’t understand your documents, they can’t focus on the real issues. Like your code, keep your requirements simple and clear.

Customer Reviews

5.0 out of 5 stars
5 star
1
4 star
0
3 star
0
2 star
0
1 star
0
See the customer review
Share your thoughts with other customers

Top Customer Reviews

Format: Paperback
I found this book great. It doesn't overkill you with a lot of complex technical arguments trying to explain something you don't need...
It is more similar to a nice novel, to be read from the begin until the end, and instead to impose one new technology to your mind, Bruce Tate is trying to share his consultant experience with the reader and to give him nice, simple and clear solutions (theory and examples).
With his approach he is helping mass developers (not only gurus) to find good solutions (and maybe better standards than those Sun has prepared for us ;-) to reach their targets:
1. have small and fast development cicles,
2. maintain and adapt the code for changes.
I suggest this book to who is bored of complexity in the java world.
Comment 15 people found this helpful. Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback.
Sorry, we failed to record your vote. Please try again
Report abuse


Feedback