Sale70 Sale70w Sale70m Hier klicken Jetzt informieren Book Spring Store 2017 Cloud Drive Photos UHD TVs Learn More TDZ HI_PROJECT Mehr dazu Mehr dazu Shop Kindle AmazonMusicUnlimitedEcho BundesligaLive longss17
Profil für Sean Kelly > Rezensionen

Persönliches Profil

Beiträge von Sean Kelly
Top-Rezensenten Rang: 7.064.237
Hilfreiche Bewertungen: 10

Richtlinien: Erfahren Sie mehr über die Regeln für "Meine".

Rezensionen verfasst von
Sean Kelly "Consultant" (Dallas, TX USA)

Seite: 1 | 2
Java 2 Exam Guide, w. CD-ROM (Career++ Certification Series)
Java 2 Exam Guide, w. CD-ROM (Career++ Certification Series)
von Barry Boone
  Gebundene Ausgabe

2 von 2 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen I want my money back!, 21. Juni 2000
The true test of the Java 2 Certification Exam Guide is to actually take the Java 2 Certification exam and see if you pass.
But that's something I'm not going to risk after reading this book.
While there's thoughtful treatment of many Java issues, from the mundane to the esoteric, the presentation of these issues suffers from errors in both substance and typography.
Consider chapter 2, Java Programming Essentials. As you read through the chapter, you manage to ignore the various typos, after all, you already know Java, you're just trying to study for the exam. (It's just annoying to have to put up with them.)
You work through the exercises, and get philosophical as the authors ask you a question about a method that isn't even defined in the code sample they present. Are you supposed to use your imagination? I don't think that'd be a good idea on the actual exam.
Finally, you get to the end of the chapter to check your answers. Chapter 2 has exercises numbered 1 through 17. But the answers are numbered 1 through 19 ... and the answer for 17 doesn't have anything to do with the question for 17! You toss the book down in disgust.
That's unfortunately representative of much of the rest of the book. It seems pretty clear that the authors, the editors, and the publisher were rushing to get this text out. More's the pity, the book had real potential, with a lot of breadth. Maybe these problems will go away in a second or third edition ... but maybe Java 3 will be out then, too!

Lost Deep Thoughts: Don't Fight the Deepness
Lost Deep Thoughts: Don't Fight the Deepness
von Jack Handey

5.0 von 5 Sternen Give us more, Jack!, 5. Juni 2000
Jack Handey's at it again with his characteristic blend of pseudo-feel-good musings. "The Lost Deep Thoughts" features enormously funny observations, remembrances, hypotheses, and situations in Handey's finest style.
Handey returns to his more traditional style of humorous deep thoughts in this volume, featuring briefer musings than in his magnum opus, "Fuzzy Memories." From the dangers of King Kong (kids seeing that huge genitalia), to the king and queen who loved laughing (until they remembered they had the plague), to the problems of owning a robot (having to whip it to get it to fetch the paper in cold winters), this book's loaded with wonderful, side-splitting thoughts.
Jack! Please write more!

Fuzzy Memories
Fuzzy Memories
von Jack Handey

5.0 von 5 Sternen Jack is back!, 26. Mai 2000
Rezension bezieht sich auf: Fuzzy Memories (Taschenbuch)
Jack Handey (his real name) is back with a pseudo-brilliant collection of delightfully funny semi-philosophical quotations.
Whether you saw his words of infantile wisdom on NBC's series "Saturday Night Live" or had a list of his sidesplitting quotes sent to you by email from a colleague, you're in for a treat with this latest set.
_Fuzzy Memories_ features a themed collection of Handey's "deep thoughts" centered on family and growing up. From his remembrance of challenging a boyhood friend to eat a worm for a million dollars (having only paid him about $9800 as of last week), to going for a Sunday drive with his grandpa (who attempted to sell him into servitude to a European couple), each and every one made me laugh so hard my head started hurting!
Although many of the quotes follow his traditional style, some longer deep thoughts in this book span a couple pages, getting funnier as they go on!
This is a great book to keep out on a coffee table during a party. Inevitably, someone will open it up, read a few out loud, and engage everyone in laughter.
Give us more, Jack!

Refactoring: Improving the Design of Existing Code (Object Technology Series)
Refactoring: Improving the Design of Existing Code (Object Technology Series)
von Martin Fowler
  Gebundene Ausgabe
Preis: EUR 53,99

4 von 4 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Recipes for improving code, 5. Mai 2000
Like the Gang of Four's landmark book _Design Patterns_, Fowler and his cohorts have created another catalog-style book, this time on refactoring.
Refactoring refers to taking existing, working software, and changing it about to improve its design, so that future modifications and enhancements are easier to add. _Refactoring_ is primarily a catalog of 70 or so different kinds of improvements you can make to object-oriented software.
Each entry in the catalog describes an implementation problem, the solution, motivation for applying the solution, the mechanics of the refactoring, and examples. The book's examples are all in Java, but C++ programmers should be able to approach the refactorings with ease. Often, Fowler diagrams the refactorings in UML, so a little Unified Modeling Language experience will help, too.
While the catalog is nice, the kinds of refactorings are obvious is most cases. Even moderately experienced programmers won't need the step-by-step mechanics described. The real benefit, though, is that the mechanics of each refactoring help guarantee that you can pull off the refactoring without introducing new bugs or side effects. They encourage you to take smaller, verifiable steps, than the more gross refactorings that most developers would naturally take. You actually save time doing so.
How do you know your refactorings are safe? Unit testing is the answer that Fowler et al. provide. Java developers will find the introduction to the Junit Testing Framework the most valuable part of the book, more so than the catalog of refactorings itself.
There's more to the book than the catalog and Junit, of course. There's discussion of the history of refactoring, how to evaluate refactoring tools, and how to convince management that what appears to be an overhead activity is actually useful in the long run.
Unfortunately, these sections are all too brief. And there is no discussion of how refactoring fits in with various software development processes. For example, programmers using Extreme Programming (XP) would probably feel right at home with Fowler's recommendations of refactoring in duets and unit testing, but developers stuck with a Software Engineering Institute process like PSP categorize testing as failure time and something to be minimized if not avoided. Cleanroom developers are taught that unit testing inteferes with metrics for quality, and that verifications are what should be done. Should such developers redo verifications after each refactoring? There's no answer in this book.
An unusual chapter, called "Bad Smells in Code," gives overall motivation for the refactorings. These vague notions, such as "long methods" or "lazy classes" humorously provide a foundation for starting your own refactorings. I say "humorously" because (mostly) Beck's and Fowler's odd analogies (classes becoming too intimate and delving in each others' private parts) provoke a chuckle (as if a chapter about "bad smells" in code weren't enough).
Overall, I've enjoyed reading this book and referring to the catalog while putting my own unit tests and refactorings into practice. Fowler's writing style is smooth and fluid, and it's easy to digest the catalog in no time. The book's typesetting is crisp, the figures quite clean, and both the refactoring index and "smell" index are enormously useful.

The Ax (Hors Catalogue)
The Ax (Hors Catalogue)
von Donald E. Westlake

4.0 von 5 Sternen Delightfully dark!, 5. April 2000
Rezension bezieht sich auf: The Ax (Hors Catalogue) (Taschenbuch)
Westlake's ingenious plot of a downsized executive's attempts to reenter the industry is underscored with the macabre. The protagonist, Burke Devore, makes a dalliance with death, as he literally kills of the competition for a position in industrial paper sales.
Westlake's novel couldn't be more disturbingly apropos, with hundreds of organizations laying off thousands of workers. His everyman protagonist struggles to find a job, but realizes, after collecting his competitors' resumes through a bogus help-wanted ad, that he doesn't have what it takes professionally. The reader can't help but be moved by his strife, and that's when the twist comes in. Devore decides to kill the top seven competitors, and he has all he needs: names and home addresses from the resumes.
Westlake maintains the everyman in Devore as he becomes a murderer. His character is sickened by the first killing, but gains confidence with each murder. Occasional comic mishaps and brushes with law enforcement caused me to turn each page with giddy anticipation, both anxious and afraid to see if Devore would succeed or be caught.
Westlake's writing is direct and clear, and his ending dovetails nicely with the rest of the novel. It's a short one, yet enjoyable, even if you're not into dark comedy.

Dave Baum's Definitive Guide to LEGO MINDSTORMS (Technology in Action)
Dave Baum's Definitive Guide to LEGO MINDSTORMS (Technology in Action)
von Dave Baum

4.0 von 5 Sternen Essential reading for any LEGO Mindstorms enthusiast, 16. März 2000
There's no denying that LEGO Mindstorms robots are the hottest toys for kids, balding middle-aged engineers in shirt-sleeves, and everyone else with a penchant for the ultimate unification of autonomous hardware and software.
And Dave Baum's book makes the entire experience better.
Baum presents a series of original robots each demonstrating unique challenges in the physical engineering and programming of LEGO Mindstorms. He starts with basic concepts (frames, gearing, pulleys) and builds on those to develop a repertoire of construction and, later, programming techniques.
Baum introduces his own language for LEGO Mindstorms, NQC, included on the CD-ROM that accompanies the book. NQC provides a traditional text approach to programming LEGO robots that's superior to LEGO's own graphic RCX language. For those who actually like RCX, Baum includes RCX versions of many of the programs in addition to NQC. The CD-ROM also includes a Windows version of RCX Command Center, giving a virtual "remote control" to the Mindstorms RCX brick. This makes experimentation with different building ideas a breeze since it requires no programming.
Juvenile readers should have no problems approaching the material. Unfortunately, though, Baum writes in an unven style, often relying on passive voice. The conclusions to each chapter sound excruciatingly forced. An extra editing pass might've helped with consitency.
There are certainly no lack of figures depicting step-by-step instructions of each robot. But I hope a future edition prints the figures in color; it's sometimes difficult to see what certain models require since many of the parts meld together in a sea of dark gray.
Baum gives a nice section of obtaining additional interesting parts in an appendix, and leaves the reader with other new developments to explore in the LEGO Mindstorms universe.
Overall, it's a great book.

Toward Zero Defect Programming
Toward Zero Defect Programming
von Allan M. Stavely
Preis: EUR 24,49

1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Cleanroom method---distilled!, 19. Januar 2000
Rezension bezieht sich auf: Toward Zero Defect Programming (Taschenbuch)
Dr. Allan Stavely has done for the Cleanroom Software Engineering method what Martin Fowler did for the Unified Modeling Language in his book "UML Distilled." He's analyzed the best and most useful parts of the Cleanroom method and found a great way to present them. After reading this book, you'll be controlling defect rates and shortening development times on your own software projects.
For those not in the know, the Cleanroom method is a set of practices pioneered by the late Harlan Mills. The idea is to use some simplified mathematical formalism along with group verifications. The result? You shift time away from hack-and-slash debugging towards review. Often, the entire start-to-finish development time is shortened.
With object-oriented languages and template instantiation times, this is a really good thing: the compile-debug-test cycle is far too painful and too slow to support today's shortened deadlines.
The key to Cleanroom is that the mathematical formalism is simplified and "just enough." Stavely demonstrates the typical structures found in programs and shows how intended function statements (the math part) are used in the group review (the verification part) to discover defects in the code. Later, a testing group exercises the paths through the code that users are most likely to take, giving statistical metrics on mean-time to failure and feedback into the quality of the method's practice.
Stavely's conversational writing style makes grasping the material efficient. Each chapter focus on just one aspect of the method, and exercises at the end test how well you grasped the material. Although Stavely includes hints to the answers for selected questions, I would've preferred complete answers to all the questions. That'd make the book more useful outside of a classroom setting.
Transcripts of review sessions show how the method succeeds in the group review. Although hypothetical, Stavely based them on actual review sessions taken by his coworkers and students over the years. They help guide newcomers to the method on how to conduct the verification step.
Overall, this is a great introduction to the Cleanroom method and after finishing the book you'll be able to introduce it to your own group in no time. Buy a copy for everyone on your team!

von William Gibson
Preis: EUR 7,99

4.0 von 5 Sternen Gibson's back!, 4. Januar 2000
Rezension bezieht sich auf: Idoru (Taschenbuch)
After giving the world of science fiction a swift kick in the pants with "Neuromancer," Gibson's novels dropped in quality like a brick into a black hole.
But then "Idoru" comes along, redeeming the venerable creator of the cyberpunk subgenre. The characterization is "just enough," the imagery is stunning, and the story is quickly accessible and not at all frustrating as prior novels had been. And it's a clever story, too, with unique ideas.
I don't want to give them away, but pick it up. If you remained loyal to Gibson, you'll see some familiar faces along the way, too. And if you've never read a cyberpunk novel before, go ahead and start with "Idoru" ... "Neuromancer" will always be waiting.

Constantine on Peopleware (Yourdon Press Computing Series)
Constantine on Peopleware (Yourdon Press Computing Series)
von Larry L. Constantine

2 von 2 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Constantine's Columns ... Collected!, 4. Januar 2000
Larry Constantine's columns on peopleware issues are finally compiled into this single volume.
Although he shares the term "peopleware" with DeMarco and Lister's management classic "Peopleware," Constantine's book doesn't focus solely on management and workplace issues. Inside you'll find his insights on user interfaces, team construction, tool use, group learning, and more.
Because each chapter is a reproduction of an article previously published throughout various journals and at various times in Constantine's career, there's a lot of breadth. And it's easy to skip over things that aren't appropriate to your project or company. But each article is small, and it's easy to digest one or two a day while at work.

The Unified Software Development Process (Addison-Wesley Object Technology)
The Unified Software Development Process (Addison-Wesley Object Technology)
von Ivar Jacobson
  Gebundene Ausgabe

3.0 von 5 Sternen I can't believe I actually finished it, 2. Januar 2000
After mastering the Unified Modeling Language, it's a natural progression to apply UML in a documented and time-tested process. That's what the creators of UML set out to describe in this third book of the UML-Big-Three, "The Unified Software Development Process."
Getting through this book will be challenging, though. You'll be thirsty not for more material, but a glass of water by the time you're done. It is bone-dry.
The Unified process has five workflows (requirements, analysis, design, build, test) that repeat within four phases (inception, elaboration, construction, transition). There are unfortunately huge chapters devoted to each of the workflows and each of the phases separately, with only a smaller amount of material focusing on how the process is actually done, which is each workflow occuring in the context of each phase. As a result, the book seems a lot bigger than it needs to be. (I'm not panning the process, though, which does indeed work, just the presentation.)
There's a running example through the text of building an automated teller application. While running examples help unify ideas, they show a narrow view of how the process can work in practice. In applying the process to my projects, it's difficult to translate such a financial application to my work (which is scientific and library-based in nature). I'd like to see a lot more examples that give alternative viewpoints in addition to the running example that demonstrates the process as a whole.
Unlike the other two books of the Big-Three, the diagrams in this one are the best. They're clean, consistent, and easy to read, and there are a lot of them. It's professionally typeset and each page is pretty.
What we need is a book similar to Fowler's "UML Distilled" called "Unified Process Distilled." The process is great---it just shouldn't take 500 pages to describe it.

Seite: 1 | 2