Objects First With Java: A Practical Introduction Using BlueJ (3rd Edition)

Book Description

/* 0-13-044929-6, 4492J-5, Barnes, Kolling, OBJECTS FIRST WITH JAVA */ BlueJ is a Java development environment that runs on top of the Sun Microsystems Java Development Kit making use of the standard compiler and virtual machine. It allows readers to create objects of any class and interact with their methods. For the first time, the traditionally difficult concepts of objects and classes are brought alive in an easily manipulable visual form. This truly “objects first” approach within the customized BlueJ environment will revolutionize the way programming is learned. The book includes a copy of BlueJ. Takes a project driven approach to problem solving—the book is structured along the lines of fundamental development tasks—providing readers with clear coverage of the principles of object-oriented programming. Programmers and non-programmers who want to learn Java with a state of the art approach and user-friendly programming environment.

Customer Reviews:

excellent service and care.......2007-09-17

i received the book on time. the condition of the book was brand new as stated. thank you for providing such great service!

NOT GOOD for Beginners..........2007-08-11

I bought this book because it was required for a course. Out of all of the exercise books I have used, this is by far the hardest to follow. There are not enough examples to actually teach you the information. There are no answers, so you never know if what you're doing is correct. Overall, the book is vague in its descriptions and has not given me any kind of useful Java skills. I'm sure it would be good for someone who already knows a little about Java or that has a teacher standing right by them to explain everything. Even the exercises were not very clear and hard to understand. I would recommend searching for a different book.

Nice intro book.......2007-05-09

most intro to programming books expect/assume you to know about programming before you can begin. This book actually teaches you the very basic and doesnt assume that you know anything. :-) Its probably the best one for beginners.

not worth the money.......2007-03-19

I purchased this for use in a Java class. The instructor swore by this book. In the end, it just wasn't worth the money. All the information I needed were already available online at through Sun and other Java resources.

Different form the rest! Objects first, objects alive - what OOP is about. .......2007-01-25

Most other books on Java are practically carbon copies of each other. They'll take you through the same boring sequence of learning. When you get to objects, you're just overwhelmed with (what seems to be) information of little practical relevance - or at least, no fun. One hardly gets the feel for what the Object Oriented programming hype is all about.
BlueJ gives you an IDE and code. Like most professional programmers, you won't be writing HelloWorld.java. Instead, you'll begin with code that was already writen by others. The book will take you on a tour in which you'll be exploring the behavior of objects. You'll be asked to reimplement classes, and observe the effects your changes have on the program's behavior. The IDE shows you class diagrams, so you can begin to analyze dependencies. Objects in BlueJ are "live", and you inspect their behaviors on the fly. This is unlike most other books, where you are required to use a text editor. This is miles ahead from the other 99% of tutorial books.
BlueJ almost feels like the Java programmer is in a Smalltalk environment. BlueJ gives the beginer a real feel for code reuse, modularity, and objects, and the IDE is an integrated tool in the development process, just like it is for a professional Java programmer. An outstanding book. Having gone through piles of Java tutorial books, this is the one to learn from. This one's truly for learning OOP.

Average customer rating:

Top-notch tome
Excellent
Basic libraries coverage with a good example application.

Prototype and Scriptaculous in Action
Dave Crane , Bear Bibeault , and Tom Locke
Manufacturer: Manning Publications
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

Web Services | Web Development | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

ASIN: 1933988037

Book Description

Prototype and Scriptaculous are libraries that extend standard Ajax. They make it easier to program Ajax and provide powerful features like drag and drop and animation. In this book, developers learn by playing and see how the libraries work in the real world.

As experience with Ajax increases, developers want the standard Ajax capabilities they repeatedly use to be preprogrammed for them--and that's exactly what Ajax libraries do for them. They reduce the pain of handling cross-browser inconsistencies, they add useful language features, and provide sophisticated functionality. Of these, Prototype is the most popular JavaScript and Ajax framework for low-level user interface features such as animation, drag and drop, and pre-built widgets. Together, they free the developer up to concentrate on building the application. They make a rich user experience easy to achieve.

This book guides the reader through the Prototype and Scriptaculous libraries feature-by-feature. In just 350 pages, readers will find over 100 small working examples to help them explore the libraries. As well, they will develop a web-based image gallery that teacher them how to use Prototype and Scriptaculous in the real-world.

Customer Reviews:

Top-notch tome.......2007-06-25

Javascript has exploded onto the web development scene in the last few years, and powers much of the web 2.0 and Ajax revolution. Every web developer now needs to know how to do common Ajax tasks. Thankfully, Prototype and Scriptaculous In Action makes it both easy and enjoyable.

This is a comprehensive book. The size (510 pages) was initially intimidating, but Prototype and Scriptaculous In Action is exceedingly well written and a genuine pleasure to read. The thorough and thoughtful organization of the book provides some real structure to the discussion, making complex subjects easily digestible. This is the defacto bible of Prototype and Scriptaculous, and these days I turn to this book more than anything else on my shelf.

The book is divided up into four multi-chapter parts, any of which could stand on it's own as a definitive guide. The chapters are full of useful examples, and there's strong emphasis given to migrating existing sites to Prototype and Scriptaculous, which is a major plus. You could turn to any section of the book and immediately see how to inject some new behavior into your existing application, but if you take the time to read from cover-to-cover you'll be rewarded with some deep understanding of both the libraries and Javascript itself.

I'll summarize the four parts of the book:

Part 1, Getting Started, introduces the Prototype and Scriptaculous libraries, focusing heavily on Prototype and Ajax. There's a lot of information on re-designing an existing site for Ajax. Two full chapters are devoted to Prototype's Ajax features. You can get up and running VERY quickly after glancing through these chapters. There's also a lot of depth, and consideration is given to the pervasive effects Ajax has on architectural issues and the new ways that an application will have to manage HTTP traffic.

Part 2, Scriptaculous Quickly, covers effects, controls and drag-n-drop. This is hands-down the best Scriptaculous documentation currently available, anywhere. The core effects are explored and tweaked, and there's lot of very practical examples demonstrating some of the niftiest stuff, like running effects in parallel versus sequentially. And the drag-and-drop coverage is incredibly clear, making it easy, almost trivial, to implement. The Scriptaculous coverage is indispensable, and you'll return to it again and again if you implement Scriptaculous-enabled pages.

Part 3, Prototype in Depth, explores Prototype's Javascript-oriented features. There's a fantastic chapter on functions contexts, and the discussion of closures is one of the best I've seen. There's a lot of information about Javascript fundamentals, and how Prototype can be used to implement inheritance, address arrays, and manipulate the DOM in the browser.

And finally, Part 4 Advanced Topics, has two unrelated chapters. The first chapter overhauls an example app, giving it a Prototype and Scriptaculous makeover. The last chapter is about integration with Ruby on Rails. Prototype was initially written as the Ajax interface to Rails, so there's some strong integration.

As a long-time enterprise web developer, dealing with Javascript has always been a chore. But now I actually (gasp) look forward to tasks that involve Javascript. I'm a convert, and I have Prototype and Scriptaculous in Action to thank.

Excellent.......2007-05-22

I wrote a longer review that Amazon has apparently lost. Oh well. This is an excellent book, very well written. The authors are the rarest kind of technical author: they can actually construct prose that is pleasant to read, not deadly boring, but which works well as a reference book later. The book's organized thoughtfully--it's certainly much more than just an API reference. There's also quite a lot of general advanced Javascript information here, too.

There's at least one other book on these libraries in production from Pragmatic Programmers. If you're considering that, I strongly suggest downloading the sample chapters of both books and comparing. The Crane book is much more appealing to me (not to mention it's available now, not in six months).

Basic libraries coverage with a good example application........2007-04-19

This book lacked detailed coverage of the programming techniques and advanced topics of prototype and scriptaculous. The authors covered the basics by discussing only the API's of the libraries (more attention was given to scriptaculous API's, even though its usage is obvious and prototype API's are more extensive). With 500 pages and the libraries as the title, I expected details about the inner workings of the API's and discussions about its usages/ applications. Instead, 150 pages were devoted to verbose repetitive coverage of scriptaculous' API, which could easily have fitted into 50 pages at most. ALL of the info on scriptaculous could easily have been read online at its wiki site - the book provided no further insight (ch. 5 is especially useless)! Prototype's coverage was decent, but lacked details on several parts of its API. Although prototype and scriptaculous are tightly integrated with Rails, there was only 1 chapter devoted to its discussion, which served more like an overview than a usage guide. Based on content on the libraries alone, I would give this book 3 stars. However, if you're in need of an example application, then it may deserve 4 stars. This book provides a good example of applying prototype's ajax and scriptaculous web 2.0 techniques to a photo gallery website. It shows the advantages these libraries have over plain javascript and dhtml. The extra 100 pages wasted on scriptaculous would better serve Rails' RJS templates or a more complete/ thorough discussion of prototype. Of course it can be argued that the book is not titled, "Prototype, Scriptaculous, and Rails in Action," but it should be.

Practical Introduction to Data Structures and Algorithms, Java Edition

Average customer rating:

Depressing
The gears on the cover dont even work!
Anonymous
Very unhelpful book
I normally buy books because they contain information...

Practical Introduction to Data Structures and Algorithms, Java Edition
Clifford A. Shaffer
Manufacturer: Prentice Hall
ProductGroup: Book
Binding: Hardcover

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Databases | Computers & Internet | Subjects | Books

Java & Databases | Databases | Computers & Internet | Subjects | Books

Beginning & Introductory | Databases | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Data Structures | Computer Science & Information Systems | New & Used Textbooks | Stores | Books

Programming Languages | Computer Science & Information Systems | New & Used Textbooks | Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books

Professional | Qualifying Textbooks - Fall 2007 | Stores | Books

Look Inside Computer Books | Trip | Specialty Stores | Books
Similar Items:

ASIN: 0136609112

Book Description

The author, Cliff Shaffer provides a superior learning tool for those who desire more rigorous data structures and an algorithm analysis book utilizing Java. While the author covers most of the standard data structures, he concentrates on teaching the principles required to select or design a data structure that will best solve a problem. The emphasis is on data structures, and algorithm analysis, not teaching Java. Java is utilized strictly as a tool to illustrate data structures concepts and only the minimal, useful subset of Java is included.

Customer Reviews:

Depressing.......2007-07-14

This book gave me no hope for Analysis of Algorithm and Data Structures class, i have yet to find another book to assist me in this area. the book was so-what easy to read, but the explanation of the concepts is really horrible, dont waste ur money

The gears on the cover dont even work!.......2006-03-21

I have Dr Shaffer as my professor and he is just as boring in real life as his book. He has told us that some of the code segements are broken to make his students figure them out. DONT buy this book... It's not worth the money.

Anonymous.......2006-02-15

I would not reccomend this book for learning about data structures. With incomplete code and scampy sections on core area material, it seems to serve more as a workbook than anything else. In addition to this I find it to be poorly worded which has often caused me to overlook important details or have to read a sentence multiple times to understand what the author is saying. What saves this from being a one star product is the fact that if you do know the material, it can help you review structures but even then, the ackward wording still can slow down a quick read.

Very unhelpful book.......2005-11-29

Dr. Shaffer attempts to address the difficult topic of data structures and fails. Consistently he glosses over important points, or does not describe the implementation of data structures (the buffer pool, for example, is especially poor) adequately and leaves the hapless student confused and frustrated. For a computer scientist who already understands the subject this book may contain a few good points. Indeed, I was able to follow the sections where I had previous training, but when I studied material new to me, I was out of luck.

If you are unlucky enough to have a university that uses this text, consider trying to find a better book to get yourself an adequate understanding of this important subject, because Dr. Shaffer's text won't do that for you.

I normally buy books because they contain information..........2004-11-05

...but this was a mandatory book for my university's two-course Data Structures & Algorithms sequence that all computer scientists and computer engineers must take.

Coming in with a good deal of programming experience, I find that this book is not as clear or as complete as it could be. The sample code snippets throughout tend to be awkwardly implmented with obscure variable names and obtuse datatyping, and more often than not represent 'a' way of accomplishing a task rather than 'the best' way. Finding better ways of doing things is normally left for exercises at the end of the chapter; the answers are not included with the book.

Also, many significant details or comments are skimmed over or are ommitted from the text. Many important (and complex) observations are left as exercises - but again, the answers are not included, so there is no way of validating your answers.

Further, this book is targeted at the C++ language. It is obscene to discuss data structures and algorithms without mentioning the free, prepackaged, and optimized code of the C++ Standard Template Library. Indeed, this book and the code it includes would have benefitted from the ingenious architecture and software engineering behind the STL.

I really hope the campus bookstore will buy this one back when I'm done with it.

Average customer rating:

Great Developer book for starters to JBOSS
Great learning tool
Good ground up walkthru
Excellent Peer into JBoss and J2EE
Great overview of a broad spectrum of products

JBoss at Work: A Practical Guide
Tom Marrs , and Scott Davis
Manufacturer: O'Reilly Media, Inc.
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

General | Programming | O'Reilly | By Publisher | Books

Look Inside Computer Books | Trip | Specialty Stores | Books
Similar Items:

ASIN: 0596007345

Book Description

Consisting of a number of well-known open source products, JBoss is more a family of interrelated services than a single monolithic application. But, as with any tool that's as feature-rich as JBoss, there are number of pitfalls and complexities, too.

Most developers struggle with the same issues when deploying J2EE applications on JBoss: they have trouble getting the many J2EE and JBoss deployment descriptors to work together; they have difficulty finding out how to get started; their projects don't have a packaging and deployment strategy that grows with the application; or, they find the Class Loaders confusing and don't know how to use them, which can cause problems.

JBoss at Work: A Practical Guide helps developers overcome these challenges. As you work through the book, you'll build a project using extensive code examples. You'll delve into all the major facets of J2EE application deployment on JBoss, including JSPs, Servlets, EJBs, JMS, JNDI, web services, JavaMail, JDBC, and Hibernate. With the help of this book, you'll:

Implement a full J2EE application and deploy it on JBoss
Discover how to use the latest features of JBoss 4 and J2EE 1.4, including J2EE-compliant web services
Master J2EE application deployment on JBoss with EARs, WARs, and EJB JARs
Understand the core J2EE deployment descriptors and how they integrate with JBoss-specific descriptors
Base your security strategy on JAAS

Written for Java developers who want to use JBoss on their projects, the book covers the gamut of deploying J2EE technologies on JBoss, providing a brief survey of each subject aimed at the working professional with limited time.

If you're one of the legions of developers who have decided to give JBoss a try, then JBoss at Work: A Practical Guide is your next logical purchase. It'll show you in plain language how to use the fastest growing open source tool in the industry today. If you've worked with JBoss before, this book will get you up to speed on JBoss 4, JBoss WS (web services), and Hibernate 3.

Customer Reviews:

Great Developer book for starters to JBOSS.......2007-08-15

Its a great book if you have just started your development with JBOSS 4. It is easy to read from a developer/deployment perspective and also delves into how to automate the deployment descriptors and deploy into JBOSS. Covers most of the common J2ee/Web applications using hibernate and Ant. Probably needs upgrading to JBOSS 5 but is great if your current development is in JBOSS 4.

Great learning tool.......2007-06-27

I am most of the way through this book and so far, it's been extremely helpful and informative. It breaks all the steps down one by one and takes you from a simple Hello-World type app, to a more complicated enterprise application. A great read all-around.

Good ground up walkthru.......2007-03-23

I found JBoss at Work to be a great guide that takes you through the basic JBoss setup and configuration. Its perfect for someone who wants to get an overview of the process and understanding of how JBoss works, but doesnt want to take the time to become an expert. It serves well as a guide on understanding J2EE general development and also highlights the JBoss specifics when appropriate.
The only downside for me was the tedious review of the J2EE XML configs. I would have preferred to see just the XDoclet code and not the additional XML that it generates. Use that time to focus on WHAT config files are necessary opposed to what actually gets generated and goes into them. Its beyond the scope of the book to go into all the XML syntax in the configs so its not worthwhile to try and make the reader understand this. Again, a little extra is not so bad, but it does fill a good portion of the book with something I believe could have been left out or supplemented with a better review of what each config file does and when to use them.

Excellent Peer into JBoss and J2EE.......2007-03-22

As many O'Reilly publications, this book provides an excellent, easy read for the topic being covered. Examples are simple enough for a "let's just get it working" for the core technologies (as stated as the goal of the book) while still providing a fairly thorough insight into each of the J2EE technologies/concepts covered.

Highly recommended for anyone who has a base understanding of JBoss/J2EE and wants to start exposing themselves to new things as well as beginners just starting out with the JBoss/J2EE world.

Great overview of a broad spectrum of products.......2007-03-19

"JBoss at Work" is a great overview of a broad spectrum of product technologies. It spends enough time on each to get them working and to provide a feel for their value, customizability, and flexibility. Examples are well-presented and contain discussion about how they work and are configured for multiple populare application environments, where appropriate. It has excellent background and history for each technology, popular alternatives, and a discussion about why the author preferred this particular technology. In other words, the authors provide more than just the bare mention included in many "survey" books. There is enough to get all of them working, and working together as a cohesive set. It does not, however, provide a lot of detail on each one.

This was perfect for my needs -- to provide a strong enough introduction for me to understand into which technologies I wanted to delve deeper, and enough contact with each of them to allow me to evaluate competing technologies in their space.

Test Driven Development: A Practical Guide

Average customer rating:

Very helpful but not perfect
Great book!
Great work covering TDD from the ground up to adv. topics
Falls short of its goal
Finally, not just another book about web applications!

Test Driven Development: A Practical Guide
David Astels
Manufacturer: Prentice Hall PTR
ProductGroup: Book
Binding: Paperback

Systems Analysis & Design | Computer Science | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books

Computers & Internet | Qualifying Textbooks - Fall 2007 | Stores | Books
Similar Items:

ASIN: 0131016490

Customer Reviews:

Very helpful but not perfect.......2006-11-06

Context: I've read a fair amount about TDD (including being a technical reviewer for Kent Beck's "By Example" book), but went a long time without getting a chance to use TDD. David Astels' book gave me a chance to get a little down and dirty with the technique and some of its associated frameworks.

Maybe too dirty? As others have said, the source code in Part III of the book doesn't do what the book describes; you need to go to Mr. Astels' web site and get updated source code.

I found the coverage of Java frameworks (in part II) to be very helpful; it expanded my understanding of what TDD techniques can be used.

Great book!.......2004-06-28

Whether you are a novoice or have been practicing TDD, this book is worth reading. It is really well organized, has great examples and explains how to use available TDD tools.
Great job, David!

Great work covering TDD from the ground up to adv. topics.......2004-05-13

(Disclaimer: I worked with the author on one large project).
Dave Astels' book is a comprehensive work covering TDD from the ground up to advanced topics. While most of the book examples use Java and JUnit, it does cover unit testing frameworks in several other languages as well. I've read two books on the topic (the other one is Kent Beck's "TDD By Example") and I liked Dave's book better. The basics of TDD can be explained in 10 minutes however when it is applied on practice it gets complicated in at least 3 areas: 1) testing UI 2) testing with database - data setup, isolation, etc. and 3) mocks. Kent's book is more about a philosophy of TDD but it only goes through a very simple "toy" example. Dave's book really helped me to understand mocks and it does cover UI testing in great length. Mocks are an advanced topic, so it does require a good knowledge of Java and OOP. The rest of the book seems to be on intermediate technical level.

The only thing this book is missing, I think, is a discussion about data setup and database-related testing, dbUnit, etc., other than an advice to avoid it altogether (p. 83). While you can indeed use mocks to avoid it, on the large real projects some kind of integration testing (including testing with the database) will be necessary. I hope the second edition will come out at some point!

Overall, it's a great book for both newcomers and developers with unit testing experience. BTW, it won SD West 2004 Jolt Award.

Falls short of its goal.......2004-04-18

This book is about Test-Driven Development (TDD). Its purpose is to help you write better code (by having more tests) and give you a head start with existing tools to achieve this.

The book falls short of these goals: The explanations about writing tests are short on advice and are sometimes misleading. The presentation of the tools is long, with little useful facts.

The book is organized into four parts: Background on TDD, refactoring and programming by intention; A look at JUnit and related tools used to write and run tests; A lengthy example of TDD; An overview of other tools in the xUnit family. The book is targeted at a Java audience but programmers using other languages should have little difficulties understanding the code.

I have a major problem with the background section. The author repeatedly claims that TDD provides exhaustive test coverage and ensures that you can refactor your code with confidence. Any error will be caught by the tests. This is foolish. First, tests rarely reach 100% code coverage. Even the sample that the author provides in the book ends up with less than 90% coverage. This leaves many gaps where tests will fail to detect errors. Even if tests cover 100% branches in the code tests are not exhaustive. Depending on the data used, the same branch may exhibit different behavior. (Not to speak about race conditions and other sources of hard to find bugs.) I fully agree with the author that writing unit tests will improve the quality of the code and help find bugs. But claiming that this is a silver bullet is not wise. I would recommend reading books about tests (e.g., Myers' The Art of Software Testing and McConnell's Code Complete chapter on unit testing) in addition to this book. The section on refactoring is a summary of Martin Fowler's Refactoring book which I recommend.

The second part presents JUnit. JUnit is a framework used to write and run tests. It is a good presentation. However I would have liked to get pieces of advices on what tests to write in addition to how to write them. The author briefly mentions boundary testing but does not have much to say about the tests themselves. Again a test book is invaluable for this. The author recommends using a test coverage tool as well as Jester to measure the tests coverage. This is a great idea.

The third section is an (overly) extended example: the author walks us through writing TDD code. This could have been a great part, giving meaning to the `practical' adjective in the book title. Unfortunately it is a long rambling, showing lots of code but short on insights. The actual `meat' of this part could be summarized in less than five pages.

The last section presents variations on the JUnit tool. Many languages (C++, C#, VB, Python, etc) are discussed. This part would have been better put on a website rather than printed in the book. Given the changes in some of these frameworks the information is obsolete.

The books ends with several appendices dealing with extreme programming and agile modeling.

Unit tests are a great tool to improve code quality. Whether or not you actively practice TDD, a good book on it can provide insights into improving your code. This book contains some interesting bits of wisdom. However much of it is buried by the rest of the material.

Finally, not just another book about web applications!.......2004-02-14

Dave's book does one thing that most other books in this field do not do: it avoids the web application. Hallelujah!

This book provides a good foundation for understanding TDD: the programming cycle, refactoring, tools, mock objects... it is possible to begin applying TDD for yourself after reading the first 1/3 or so of this book.

Writing effectively about programming sessions is not easy. Only a few authors can do it well, and Dave does an admirable job in this. My only beef with the case study (which makes up the bulk of the book) is that, after a while, it becomes somewhat repetitive. This isn't Dave's fault: it's the nature of programming. Sometimes we just need to add another button or another text field. We don't necessarily learn anything new doing it, but if we want a finished product, we have to do it. I understand Dave's desire to present a complete (if small) project, and so applaud his willingness to risk some duplication in the name of finishing what he started.

The experience of learning from this book is similar to learning from real project experience: not every page contains something new and exciting, but if you follow along and ask questions (of yourself), then you will have learned a great deal by the end.

Average customer rating:

The Best Programming Book I know

Excellent coverage of advanced unit testing

Put this next to Knuth and The Gang of Four on your bookshelf

Required reading for using Java+J2EE+JUnit in the real world

Great reference book

JUnit Recipes: Practical Methods for Programmer Testing
J. B. Rainsberger
Manufacturer: Manning Publications
ProductGroup: Book
Binding: Paperback

General | Java | Programming | Computers & Internet | Subjects | Books
Object-Oriented Design | Software Design, Testing & Engineering | Programming | Computers & Internet | Subjects | Books
Testing | Software Design, Testing & Engineering | Programming | Computers & Internet | Subjects | Books
General | Languages & Tools | Programming | Computers & Internet | Subjects | Books
General | Software | Computers & Internet | Subjects | Books
Look Inside Computer Books | Trip | Specialty Stores | Books
Similar Items:

JUnit in Action

Pragmatic Unit Testing in Java with JUnit

Pragmatic Project Automation: How to Build, Deploy, and Monitor Java Apps

Java Persistence with Hibernate

Java Concurrency in Practice

ASIN: 1932394230

Book Description

When testing becomes a developer's habit good things tend to happen--good productivity, good code, and good job satisfaction. If you want some of that, there's no better way to start your testing habit, nor to continue feeding it, than with JUnit Recipes. In this book you will find one hundred and thirty-seven solutions to a range of problems, from simple to complex, selected for you by an experienced developer and master tester. Each recipe follows the same organization giving you the problem and its background before discussing your options in solving it.

JUnit – the unit testing framework for Java – is simple to use, but some code can be tricky to test. When you're facing such code you will be glad to have this book. It is a how-to reference full of practical advice on all issues of testing, from how to name your test case classes to how to test complicated J2EE applications. Its valuable advice includes side matters that can have a big payoff, like how to organize your test data or how to manage expensive test resources.

What's Inside:

- Getting started with JUnit

- Recipes for:
servlets
JSPs
EJBs
Database code
much more
- Difficult-to-test designs, and how to fix them

- How testing saves time

- Choose a JUnit extension:
HTMLUnit
XMLUnit
ServletUnit
EasyMock
and more!

Customer Reviews:

The Best Programming Book I know.......2007-03-09

This is a great book. It is directed at users of JUnit, the Java unit testing framework. But in my mind the book gives sound advice for solving your programming problems in general, not just for Java or JUnit testing. It stresses the importance of unit testing, programming to interfaces instead of implementations and just simple common sense. The author is clearly passionate about his field and extremely experiences. The combination of enthusiasm and experience comes through on every page.

Excellent coverage of advanced unit testing.......2006-01-19

Rainsberger does a very good job of detailing the techniques to unit test difficult code; including xml, ejb, servlets, jsps etc.

Put this next to Knuth and The Gang of Four on your bookshelf.......2005-12-31

This isn't necessarily the best introduction for absolute beginners (I would recommend /Pragmatic Unit Testing/ for that), but it is required reading for server-side Java, as most other reviewers have pointed out. But it's more than that--it's one of those rare computer books that transcends its subject matter. Why? Because it can make you a better programmer. While some of the credit can rightly be given to unit testing and Test-Driven Development in general, Rainsberger's book makes you /see/ better ways to write and refactor your code. The breadth and depth of examples is astonishing--he convincingly shatters "but it's too hard to test that" arguments with well-researched, non-trivial examples. In fact, I'd say that this is almost a better J2EE tutorial than most books about J2EE proper.

I'm withholding a star for one reason: the book doesn't cover GUI testing tools like Jemmy, JFCUnit, or Abbot/Costello. These JUnit extensions are ripe for a book with this depth; it's just too bad that this couldn't be that book. Other than that, I find that I turn to Rainsberger's book far more often than any other testing book or online reference.

Required reading for using Java+J2EE+JUnit in the real world.......2005-11-19

This review also appears on StickyMinds at http://www.stickyminds.com/s.asp?F=S767_BOOK_4

JUnit Recipes is a comprehensive tome of practical methods and techniques for the opensource JUnit tool to develop automated unit-tests for Java/J2EE applications. The book is split into four parts: Building Blocks, Testing J2EE, Additional JUnit Techniques, and Appendices. The Building Blocks cover the basics of using JUnit to create basic tests, organize and manage test suites and test data, running JUnit tests and reporting the results. It even includes a section on troubleshooting. Testing J2EE covers XML, JDBC, EJB, web components (including JSPs), and J2EE applications. Additional techniques include testing some well known design patterns, using JUnit add-ons and JUnit libraries (like GSBase). The Appendices include complete solutions (including code of course), some short and sweet essays on testing, and a modest recommended reading list.

The organization of the book flows very logically and the writing style is very clear and easy to follow. Along the way many insights into important design principles and testing techniques are revealed: the reader will learn about the "Hollywood principle", the Open-Closed principle, design patterns, POJOs, Mock Objects, Private and Parameterized Test-Cases, Abstract Test-Cases, Self-Shunts, and Spys. The book's coverage is very comprehensive and touches on many other popular Java/Enterprise projects and frameworks such as Struts, JBOSS, Prevayler, XDoclet, Tomcat, XPath, XMLUnit, HTTPUnit, Ant, Jakarta, and others.

Even though JUnit is often associated with "Agile" development and much of the wisdom apparent in the book applies to agile Java development, the book is useful to any Java developer on any Java project (agile or otherwise). The book also goes into considerable detail, with working code examples, to spell out exactly how to perform and apply the techniques it describes.

The book's primary audience is Java developers. Java Tester's will still find some good nuggets of information but it's quite clear that Java programmers and developers are the target audience. This isn't some high-level theoretical book mostly of concepts and ideas. This is an imminently pragmatic guide that not only conveys a great deal of highly practical wisdom but also clearly and comprehensively walks you through the explanations and the code to accomplish and apply the techniques it describes. The book is also not a "How To" for coming up-to-speed on setting up and running JUnit.

Another book from the same publisher, "JUnit in Action" is a great overview on learning more about the basics of running and using JUnit and on using JUnit to tackle a number of basic challenges with unit-testing Java and J2EE code. JUnit Recipes has some overlapping material but pretty much "picks up" where "JUnit in Action" leaves off, and JUnit Recipes goes into much more breadth and depth of coverage of JUnit methods, practices and techniques and use with other Java projects and frameworks.

I would say JUnit Recipes should probably be required reading for anyone attempting to use Java, J2EE and JUnit in the real-world.

Great reference book.......2005-08-05

After you've mastered the basics of JUnit, this book is the book to get.

However, even if you're new to JUnit, this is still an excellent book to get, as the first few chapters will get you acquainted with JUnit, such as setting it up, and with some simple, basic tests to get you started.

The rest of the book contains the most valuable and useful information that you can apply to your projects. They describe the more complex situations/environments (J2EE application server, standalone, etc.) that you encounter everyday and how to write tests for each situation. It is these chapters that will have you coming back for more, when you're stumped on how to write a JUnit test for your specific problem.

Junit Recipes also gives you tips on organizing your tests, testing legacy code, and much more. Each recipe is written in a similar format, describing the problem, background, and finally, the recipe itself, making this book easy to read. This book definitely belongs on your desk at work (or your bookshelf at home) -- it comes in handy when you are having trouble coming up with tests for difficult situations. I highly recommend it if you would like to learn how to write better tests and learn how to test code in complex environments.

The Book of JavaScript, 2nd Edition: A Practical Guide to Interactive Web Pages

Average customer rating:

If you're more advanced this book is not for you...
a very useful update
Finally!
Great Book!
Good first read--but watch out for the textual errors!

The Book of JavaScript, 2nd Edition: A Practical Guide to Interactive Web Pages
Dave Thau!
Manufacturer: No Starch Press
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books
Similar Items:

ASIN: 1593271069

Book Description

The Book of JavaScript teaches readers how to add interactivity, animation, and other tricks to their web sites with JavaScript. Rather than provide a series of cut-and-paste scripts, thau! takes the reader through a series of real world JavaScript code with an emphasis on understanding. Each chapter focuses on a few important JavaScript features, shows how professional web sites incorporate them, and takes readers through examples of how they might add those features to their own web sites. This thoroughly updated 2nd edition includes new chapters on Ajax, revised appendices, and new examples throughout. Summary sections and assignments close each chapter, making the book perfect for use in college courses or independent study. CD includes code and images for every example, answers to assignments, script libraries for hard-to-program applications, and many useful software programs.

Customer Reviews:

If you're more advanced this book is not for you..........2007-09-01

I bought this book becuase I read several reviews that stated this book would be great for those who are more advanced in scripting as well as the beginner. I did not find that to be the case. The one good thing I will say is that it was clear and easy to read, so if you're new to the world of JS, this book will suit your needs.

a very useful update.......2007-06-13

As someone who learned JavaScript from the first edition of this book, I was excited see what Thau! had in store for the second edition. He did not disappoint! Once again, he explains the most complicated concept clearly, and makes programming a breeze. The new reference section is especially useful. Thanks, Thau!!

Finally!.......2007-06-13

This book was really fantastic. Dave Thau clearly knows what he's talking about AND knows how to explain it clearly to others. This book gets a big thumbs up!

Great Book!.......2007-06-09

I've been reviewing quite a few books recently to use in my JavaScript course that I teach. Finally, I've found a book that explains all the important concepts and does it in a way that's a breeze to understand.

The author has a friendly, relaxing "voice" that puts you right at ease, even with the most challenging concepts.

If you are wanting to learn JavaScript, I cannot recommend this book highly enough.

Good first read--but watch out for the textual errors!.......2007-05-06

This book seems to be written for someone almost entirely new to programming/scripting. A good deal of the concepts are explained just as thoroughly as they need to be for him to cover the subject he is covering.

As such, I would not recommend this book for someone already experienced in programming/scripting.

In response to some other posts, which criticize him for teaching document.write instead of the more modern approach (working directly with the DOM), I disagree. I do acknowledge that it is better to work directly with the DOM, but that is far from a concept that can be taught to someone completely new to programming/scripting without boggling their mind.

Also: BEWARE THE ERRORS! This book is chock full of errors in the code snippets they display. The error in the numbered snippet on page 36, probably the 3rd or 4th error I've seen so far, is what actually motivated me to write this review. That in mind, if you're paying attention, the errors can actually be turned to an educational purpose--debugging! :)

Final advice: If you're completely new to this field or want to treat yourself as if you're completely new, then get this book. I would not recommend sticking solely with this book, though. Get this book and some others (JavaScript: The Definitive Guide and probably another instructional book such as one of the WROX Javascript books).

Practical Object-Oriented Development with UML and Java

Average customer rating:

It's impractical at all.

Practical Object-Oriented Development with UML and Java
Richard C. Lee , and William M. Tepfenhart
Manufacturer: Prentice Hall
ProductGroup: Book
Binding: Paperback

General | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Look Inside Computer Books | Trip | Specialty Stores | Books

All Titles | Qualifying Textbooks - Fall 2007 | Stores | Books
ASIN: 0130672386

Customer Reviews:

It's impractical at all........2003-07-20

Only disappoint, no more.

Average customer rating:

An excellent investment
As the title suggests
mod_perl from the horse's mouth
Definitive guide to mod_perl administration
Useful, informative volume on mod_perl

Practical mod_perl
Stas Bekman , and Eric Cholet
Manufacturer: O'Reilly Media, Inc.
ProductGroup: Book
Binding: Paperback

General | Programming | Computers & Internet | Subjects | Books

General | Computers & Internet | Subjects | Books

General | Software | Computers & Internet | Subjects | Books

Perl | Programming | O'Reilly | By Publisher | Books

Web Programming | Programming | O'Reilly | By Publisher | Books

General | Programming | O'Reilly | By Publisher | Books

Look Inside Computer Books | Trip | Specialty Stores | Books
Similar Items:

ASIN: 0596002270

Book Description

mod_perl embeds the popular programming language Perl in the Apache web server, giving rise to a fast and powerful web programming environment. Practical mod_perl is the definitive book on how to use, optimize, and troubleshoot mod_perl. New mod_perl users will learn how to quickly and easily get mod_perl compiled and installed. But the primary purpose of this book is to show you how to take full advantage of mod_perl: how to make a mod_perl-enabled Web site as fast, flexible, and easily-maintainable as possible. The authors draw from their own personal experience in the field, as well as the combined experience of the mod_perl community, to present a rich and complete picture of how to set up and maintain a successful mod_perl site. This book is also the first book to cover the "next generation" of mod_perl: mod_perl 2.0, a completely rewritten version of mod_perl designed for integration with Apache 2.0, which for the first time supports threads. The book covers the following topics, and more:

Configuring mod_perl optimally for your web site
Porting and optimizing programs for a mod_perl environment
Performance tuning: getting the very fastest performance from your site
Controlling and monitoring the server to circumvent crashes and clogs
Integrating with databases efficiently and painlessly
Debugging tips and tricks
Maximizing security

Written for Perl web developers and web administrators, Practical mod_perl is an extensive guide to the nuts and bolts of the powerful and popular combination of Apache and mod_perl. From writing and debugging scripts to keeping your server running without failures, the techniques in this book will help you squeeze every ounce of power out of your server. True to its title, this is the practical guide to mod_perl.

Customer Reviews:

An excellent investment.......2006-08-10

We have been using perl for our server side programming for over 6 years now. During this period, the popularity of our web based applications has grown. To deal with the growth, we have had to optimize the programs, as well as look at alternate server setup strategies. We acquired this book as it covers both the topics of our interest -- mod_perl for efficiency of perl programs and setting up servers that use mod_perl.

In the course of the optimizations, we have gradually moved into the mod_perl world. It has yielded significant performance improvement, probably making our web application more than 50 times as fast. "Practical mod_perl" served as a guide while we carried out this transition, which has resulted in dramatic savings in our server costs. I have no hesitation in saying that this wonderful book is perhaps the best investment we have ever made in technology.

As the title suggests.......2005-11-02

This is very practical. It starts with a lot of information on how apache works and how mod_perl and other modules intract. Then, after learning that information, it shows how you can use the knowledge to signficiantly improve the performance of your mod_perl apps.

In addition, it gives valuable advice on how to troubleshoot fustrating issues with mod_perl & apache.

This book should be required reading for anybody doing mod_perl work.

mod_perl from the horse's mouth.......2004-11-11

This one of the most informative O'Relly books by absolute metrics: almost 1000 pages packed with useful information. It pretty much covers all bases: from porting existing CGI scripts to mod_perl, to architecturing busy websites for optimal performance. One of the authors, Stas Bekman, works on mod_perl full-time, so this is it's basically as authoriative as it gets.

The only drawback of this book that I noticed is that it sometimes gets too heavy on basic Perl or sysadmin stuff, making the experienced developer flip pages in anxiety. Also, some parts are too similar to online mod_perl documentation (which is not surprising as it's written by the same person).

Still, this is the first book with substantial mod_perl2 coverage, and probably worths buying for this reason alone. All in all, if you're coding mod_perl for living, I think you owe it to yourself to have this book in your O'Relly collection.

Definitive guide to mod_perl administration.......2004-03-17

At almost 900 pages, this is certainly the biggest book on mod_perl that has been published so far. In my opinion it's also one of the most useful.

Stas Bekman and Eric Cholet are two of the best-known and (probably more importantly) most respected names in the mod_perl community so you can be sure the the information you get in this book is going to be top quality.

Part 1 of the book is about mod_perl administration. It starts with an overview of what mod_perl is and how it relates to CGI and the Apache web server before going into a chapter which gives a quickstart guide to installing and using mod_perl on some of the most common platforms. Chapter three then goes back over the installation process in far more detail. Chapter four explains how to configure mod_perl in various ways and chapter five cover monitoring, upgrading and maintaining your mod_perl enabled web server. Chapter 6 is full of advice about how to write Perl code that takes advantage of mod_perl's features.

Part 2 is all about mod_perl performance and contains chapters about benchmarking and tuning your server. I found chapter twelve to be particularly useful as it discusses a number of useful strategies for splitting server load between a mod_perl server for dynmaic content and a "plain" (non-mod_perl) server for static content. Other chapters in this section cover other strategies for improving performance by tuning Apache's configuration, changing your Apache and mod_perl build options and being cleverer about the HTTP headers that you return.

Most dynamic web sites have a database involved somewhere so part 3 covers using databases with mod_perl. Part 4 is all about debugging and troubleshooting your mod_perl server. Finally, part 5 looks at what has changed with the release of the forthcoming mod_perl 2.0.

And this isn't just theoretical stuff. The two authors have been involved in developing mod_perl for a long time but they are also mod_perl users. You can just tell from the way they write that the problems they discuss are problems they have dealt with. This is the voice (or, rather, voices) of experience.

A lot of the text in the book is based on the mode_perl guide which has been available on the web for some time, but all of the content has been revisited, updated and expanded. This book is not really in competition with books like The mod_perl Developers Cookbook or the older Writing Apache Modules with Perl and C as those books largely concentrate on how to write code for mod_perl whereas the emphasis in this book is on configuring and administering a mod_perl server.

And if you are the administrator of a mod_perl server then you should really consider adding this book to your library.

Useful, informative volume on mod_perl.......2004-02-19

Practical mod_perl is a doorstop sized volume that provides more information on using mod_perl than you ever thought you needed.

The almost 900 pages are divided into five parts and a bunch of appendices. Part I, "mod_perl Administration" covers building, configuring and installing mod_perl, followed by some Apache details and an 80-page guide to coding with mod_perl in mind. Part II, `mod_perl Performance' deals with ways of getting the best out of Apache and mod_perl, with a little about security. Part III deals with databases, including persistent connections and data sharing. Part IV is a great guide to debugging and troubleshooting. Part V is a brief look at Apache 2 and mod_perl 2.

The appendices are useful. The first is a short section of around a dozen small `recipes' for performing various tasks using mod_perl. I found these a good base for more complex tasks, particularly when combined with examples from elsewhere in the book. The second is a list of Perl modules that extend Apache and mod_perl with a brief description of each. The third gives some strategies for providers wanting to host Apache with mod_perl. The fourth and fifth give good overviews of the Template Toolkit and AxKit, an XML application server built on mod_perl.

The book is readable, tending towards heavy writing and certainly dense, but I didn't feel this was a problem in a book meant for a fairly advanced audience. I think you'd want to be a fairly good Perl programmer and well versed in Apache before needing this volume and shouldn't expect to be spoon fed. I thought it well written.

In a book of this size you expect to find a lot of example code, and you won't be disappointed. The book is peppered with short Perl examples and example command lines and configurations, all well explained. The one shortcoming is that there aren't many examples of full-blown applications where you can see everything discussed and have it explained all in one place. I would have appreciated some more of this, the examples tend to be on the short side.

This book sits well in the marketplace. It provides more details on running, installing and configuring mod_perl and Apache than mod_perl Developer's Cookbook (and also delves more into the reasons for doing something one particular way and much more help on debugging), though the Developer's Cookbookbecomes a good companion to this volume as it provides a lot more in the way of examples. For those that want to get deep into the high end of mod_perl there is Writing Apache Modules in Perl and C, which is at core a good book on high end mod_perl programming.

O'Reilly have their usual website with Table of Contents, an example chapter, and errata. The authors have their own website with some of the same information and all the code examples from the book as both individual files and one 40k tarball.

Amazon.com

With the ongoing explosion in the popularity of digital cameras, online image delivery, powerful graphics-editing programs, and digital video, the technologies involved have been receiving a lot of attention. But such technologies have been evolving for years and Digital Image Processing Using Java provides a fine snapshot (pun intended) of the state of digital-imaging art. A serious treatment of the theory and practice of encoding and manipulating graphics data, the book explains how computer programs work with pixels, colors, and other aspects of digital imaging. And the text puts an emphasis on sampling, filtering, compression, and additional manipulation algorithms.

But this book is about digital images, not Java. The Java programming language is just a tool for illustrating how to manipulate image data. (Because of its clean design, Java is particularly well suited to this job.) A typical section in the book gives the theory behind a particular kind of image processing (often with some pure math that's easy to follow with a bit of study) and then shows how Java implements the idea. Java2D API classes are used in the code listings, illustrating the results using sample images (some in color) and graphs. --David Wall

Topics covered: Techniques for representing visual information digitally, and for manipulating those representations with software. It doesn't cover individual file formats with much detail, but Digital Image Processing pays tons of attention to sampling, color enhancement, edge detection, affine transforms, and compression. Code samples in the book are in Java.

Book Description

This book features a breadth and depth that first explains IP concepts and then allows users to practice them by working with the accompanying CD-ROM. The material on this disc includes Java classes that can be used by programmers to build IP software, as well as a complete set of tools that will let them experiment with IP concepts. It provides a thorough introduction to current state-of-the-art IP technology while using the Java programming language. Computer scientists who want to learn more advanced topics in computer graphics.

Customer Reviews:

Do you know Java and will work with images?.......2002-06-06

In general terms, this is a good book for intermediate and advanced Java programmers who need to work with images.

Just as the title reads, this is a Practical Introduction to digital image processing (DIP), that is, you will not find all the theory here, and the study of images will be mostly practical: with programs, what would be a good point or not, depending on you.

The CD is a very nice complement for the book, but a couple of programs just don't run as expected, and you might want to check the code to find the error or to use the code just as a reference to write your own Java classes. I have checked just part of the code and the problems do not seem a matter of deprecated classes or the like. You can find some errata searching in the Internet, but not much at time of this writing (June 2002).

You must read the book in front of your computer, to run the classes. The book sometimes doesn't tell you all about the classes available in the CD.

Always remember, the book tries to teach you DIP *using* Java, not DIP *and* Java. If you are not confident of your level of Java, try another book first. If you know about DIP and want to study further, try a book that is more specific on such subject.

This book is NOT for you if
- you are a beginner in Java
- you need to study DIP exhaustively

This book is for you if
- you have experience programming in Java
- you need basic and general concepts about DIP

An Introduction to Image Processing.......2000-05-26

This book introduces some basic concepts of image processing. It also uses Java 2D imaging functions to implement those concepts. Therefore, it is a practical book combined with concept and implementations.

Books:

Books Index

Books Home

Recommended Books