Your Garage botysf16 Amazon Fashion Learn more Discover it PME Fire TV Stick Subscribe & Save Patriotic Picks Shop-by-Room Amazon Cash Back Offer AllOrNothingS1 AllOrNothingS1 AllOrNothingS1  Amazon Echo  Echo Dot  Amazon Tap  Echo Dot  Amazon Tap  Amazon Echo Starting at $49.99 All-New Kindle Oasis AutoRip in CDs & Vinyl Segway miniPro STEM
Profile for Jason > Reviews

Browse

Jason's Profile

Customer Reviews: 30
Top Reviewer Ranking: 7,221,993
Helpful Votes: 428


Community Features
Review Discussion Boards
Top Reviewers

Guidelines: Learn more about the ins and outs of Your Profile.

Reviews Written by
Jason RSS Feed (United States)
(REAL NAME)   

Show:  
Page: 1 | 2 | 3
pixel
Learn to Program (Pragmatic Programmers)
Learn to Program (Pragmatic Programmers)
by Chris Pine
Edition: Paperback
45 used & new from $1.74

55 of 57 people found the following review helpful
4.0 out of 5 stars Learn Programming Through Ruby Colored Glasses, February 1, 2006
As a relative newcomer to Ruby, one of the first things that struck me was the overall simplicity and clarity of the language. I couldn't help thinking that Ruby could serve as an excellent language to teach programming fundamentals. Chris Pine's "Learning to Program" tackles that very task. The latest title in the Pragmatic Programmers Facets of Ruby series, "Learn to Program" arms the reader with the basic skills and concepts required to write their own computer programs using the Ruby language.

The book begins with downloading and installing Ruby and then quickly gets the reader writing their first program - and it's not "Hello World". Pine instructs the reader on the basics covering everything you'd expect: numbers, strings, variables, type conversion, basic IO, methods, flow control, classes, and more. The author does a fine job making the material easy to read and easy to understand through his clear presentation and conversational tone. "Learn to Program" is chock full of simple examples, and this book is very well suited to sitting down with at your keyboard and working your way through each chapter. The chapters are short and can be absorbed quickly without bogging the reader down unnecessarily. Several of the chapters conclude with short programming assignments for the reader to attempt in order to apply the concepts just learned.

"Learn to Program" is written for those who have little to no experience programming. It is a fine introduction for the person who has never written a single line of code. It's no Dummies book though, and a certain degree of comfort and familiarity with computers is a prerequisite for getting the most out of the book. Pine never tells us exactly who his audience is, but it would certainly be suitable for the college student, technically minded adult or gifted high school student.

As much as I like this book, and I do like this book, there are a few things that could serve to complement it. First off, I'm surprised to find that there's no index. It's not a huge book and the chapters are well laid out, but it's hard to imagine the rationale for not including an index. Also, the book could stand to have some more assignments for the reader to try. They are there, but there aren't enough of them in my opinion. It would be nice to see a companion workbook to provide more problems to work through and to provide sample solutions for those problems. While "Learn to Program" doesn't read like a textbook, add the workbook and some lesson plans and I suspect you'd have the basis for a nice course in introductory programming.

While I suspect an argument could be made as to whether or not every vital Ruby feature was covered, I would conclude that every feature required to get the beginner writing code was presented. It's important when evaluating this book to keep in mind that its purpose is to teach programming and not to teach the reader how to become a master with the Ruby language. "Learn to Program" is a fine introduction to programming and demonstrates that Ruby is well suited for this task.
Comment Comment (1) | Permalink | Most recent comment: Jan 2, 2013 4:18 PM PST


Data Crunching: Solve Everyday Problems Using Java, Python, and more.
Data Crunching: Solve Everyday Problems Using Java, Python, and more.
by Greg Wilson
Edition: Paperback
30 used & new from $0.01

6 of 7 people found the following review helpful
5.0 out of 5 stars Just the information you need to know to get rolling, July 21, 2005
There exists a set of tasks common to every software developer independent of the type of application developed and the language used. Concisely presenting these tasks to the new developer has always been a problem without burying the hapless soul under a pile of thick texts. The Pragmatic Bookshelf attempts to remedy this situation by giving the developer the knowledge they need to get the job done in a concise and, well, pragmatic format. One of the latest offerings in this outstanding series is "Data Crunching: Solving Everyday Problems Using Java, Python, and More" by Greg Wilson.

The core of programming comes down to data manipulation. This may be parsing XML, reformatting text data, searching a database, or any other number of a host of tasks. Typically, figuring out how to do each of these would require digesting several books in order to just get to the nuts and bolts of simple operations. "Data Crunching" fills this hole by concisely presenting the minimum amount of information required to get the job done. Just the information you need to know to get rolling, without all the fluff.

There are chapters on manipulating text files, XML documents, binary data, and relational databases. Included is a nice chapter on regular expressions, as well as a chapter on various "glue" topics relevant to solving data manipulation problems. Each chapter examines the tools and methods used to successfully manipulate the format of data being discussed. The examples used, and the book is chock full of them, are practical and relevant to the problems most often faced by developers. The examples are clearly illustrated and easy to follow.

Wilson does a fine job of presenting things in the "pragmatic" style that readers familiar with other books in the series have come to know. Each chapter stands well on its own, so the book may be used as a reference, although it's concise and a pleasant enough read that it's also worth reading through once. Great for the new developer who hasn't yet gotten his feet wet with data manipulation, yet also a nice reference for those who have been around the block a bit more, "Data Crunching" makes a fine addition to the Pragmatic series and is definitely worth having on the bookshelf.


Hibernate in Action (In Action series)
Hibernate in Action (In Action series)
by Christian Bauer
Edition: Paperback
93 used & new from $0.01

10 of 11 people found the following review helpful
5.0 out of 5 stars The definitive tome on Hibernate, May 4, 2005
Data persistence is quite naturally at the heart of most enterprise applications. There are a myriad of choices the Java developer faces in choosing a persistence mechanism. JDBC and EJBs have long been the standard options, along with relative newcomer JDO, and various commercial Object/Relational Mapping (ORM) solutions. All of these have their place, but they also come with some baggage as well. Enter Hibernate, a popular open-source solution for ORM designed to meet some of the perceived shortcomings of the more traditional Java persistence mechanisms.

Manning's "Hibernate In Action", written by two members of the core Hibernate team (including the project's founder), takes the reader step-by-step through the process of getting up and running with Hibernate. The book begins with an introduction to issues involved in object / relational persistence. Naturally, Hibernate addresses each concern raised with this topic. Right from the beginning I couldn't help but get the feeling that the authors were trying to sell me something. The rest of the book however proceeds in typical Manning "In Action" style by diving into the nuts and bolts of what it takes to get up and running using Hibernate. An example application, an online auction application, is used throughout the book to illustrate the implementation of a Hibernate solution. The examples are clear and easy to follow, and serve adequately to prepare the reader to implement Hibernate in their own applications.

"Hibernate In Action" has to be considered the definitive tome on Hibernate. As the authors are intimately involved with the project, the insight on Hibernate that they provide can't be easily duplicated. That said, the authors' own, often controversial, opinions on common design practices (DTOs for example) are sprinkled liberally throughout the text, and this may turn off some readers. Still, if your project is going to be using hibernate or is considering using Hibernate, this book is a must-have.


Pragmatic Unit Testing in Java with JUnit
Pragmatic Unit Testing in Java with JUnit
by Andrew Hunt
Edition: Paperback
41 used & new from $0.01

15 of 17 people found the following review helpful
5.0 out of 5 stars A cornucopia of wisdom, July 28, 2004
Refusing to rest on their laurels from their 1999 success The Pragmatic Programmer, Andrew Hunt and David Thomas are back with a vengeance. They've taken a step back from their previous title to write The Pragmatic Starter Kit, billed as a prequel to The Pragmatic Programmer. The Pragmatic Starter Kit, meant to lay the foundation for a pragmatic programmer, consists of three titles: Pragmatic Version Control, Pragmatic Unit Testing, and Pragmatic Automation. Together, these titles show how to set up a sound development infrastructure, and educate as to fundamental practices, tools, and philosophies which may be used to enhance productivity within this infrastructure.

Pragmatic Unit Testing, the second volume of The Pragmatic Starter Kit, teaches the developer to code smartly by practicing a regime of disciplined unit testing. Hunt and Thomas begin by convincing the reader just why it is we must write unit tests, and then quickly debunk the most common excuses developers use for not testing. Now that we are suitably convinced, the authors go on to explain how to plan and write unit tests, how to work with the JUnit framework, and how to use mock objects.

Most books on this subject don't really go too far beyond how to write unit tests. Where this book stands head and shoulders above the rest though, is the great depth the book goes into showing us exactly what tests need to be written. Through a series of helpful mnemonics, the reader is taught exactly what to test, how to correctly test boundary conditions, and what the properties of good tests are. We are also given general testing principles to keep in mind, as well as questions to ask ourselves about our code while testing. The concepts given herein are invaluable, and if the book ended with just this, it would be well worth the money.

The book doesn't stop there however. The authors offer excellent advice for integrating unit testing within the scope of a project in a team environment, and we are given a look at how unit testing can influence design. Exercises are presented to help the reader practice key concepts throughout the book.

There are a couple of things that this book isn't. This book is not a treatise on how to unit test specific components in an application. As stated previously, this book is less about how to test specific components, and more about what tests should be written in the first place. This book also does not overtly espouse any particular process. Extreme programming and test-driven development are certainly mentioned, but they are not championed above other processes.

This book is concise, weighing in at around 159 pages. The book is a very quick and pleasant read. It is appropriate for the novice as well as the developer who's been around the block a couple of times. If you write unit tests, and particularly if you are new to the game, this book is a cornucopia of wisdom. Pragmatic Unit Testing is to the practice of unit testing, what Joshua Bloch's Effective Java is to the Java programming language. That's certainly high praise indeed.


Ender's Shadow (The Shadow Series)
Ender's Shadow (The Shadow Series)
by Orson Scott Card
Edition: Mass Market Paperback
Price: $6.55
314 used & new from $0.01

3 of 4 people found the following review helpful
5.0 out of 5 stars Outstanding complement to Ender's Game, July 27, 2004
With Ender's Shadow, Card brings us back to Battle School and the Bugger War in what he terms a parallax to Ender's Game. This time the story follows the path of Bean, the smallest and youngest of the Battle School students.

Orphaned and begging for scraps of food on the hellish streets of Rotterdam, Bean manages to survive through sheer force of will and an unnatural intelligence. Managing to escape the murderous clutches of the desperate streets, he is recognized for his potential and sent to Battle School. It is here that the story of Bean eventually entwines with that of the person whose shadow he is destined to live in - Ender Wiggin.

Card brings the series back to its roots in a story that is every bit as action packed and thoughtful as Ender's Game. His psychological portrayal of Bean as someone unable to emotionally attach to others, and whose overriding selfish goal is his own survival is exactly what one would expect of one who grew up as Bean did. The fact that his reactions to circumstances are perfectly consistent with his early experiences lend a tremendous amount of depth and realism to the character. Aside from being a riveting story of adventure, Ender's Shadow is an excellent study of a gifted yet troubled child.

If you loved Ender's Game, you'll love Ender's Shadow. It is not necessary though to have read Ender's Game in order to enjoy this book, as it stands on its own. Highly recommended.


Children of the Mind (The Ender Quintet)
Children of the Mind (The Ender Quintet)
by Orson Scott Card
Edition: Mass Market Paperback
Price: $6.55
257 used & new from $0.01

34 of 44 people found the following review helpful
3.0 out of 5 stars Picks up where Xenocide left off, June 30, 2004
"Children of the Mind" is the final book in Orson Scott Card's Ender Quartet. It picks up right where "Xenocide" left off, and is the logical conclusion to Ender's story, wrapping things up in a satisfying enough manner.
Like the books that preceded it, "Children of the Mind" is largely character driven, and this is certainly one of its strengths. Few of the characters are explored in excrutiating detail, but Card gives us just enough of a glimpse into their lives and personalities to give the reader the feeling that we know these people.
While the book is certainly satisfying in that it ties up all the threads woven in the previous books, I feel that it is the weakest of the series. I'm not sure that much would have been lost if it had simply been compressed and included as the final chapters to "Xenocide". That said, if you are a fan of the series, and particularly if you have read "Xenocide", then "Children of the Mind" is a must read.


Xenocide: Volume Three of the Ender Quintet
Xenocide: Volume Three of the Ender Quintet
by Orson Scott Card
Edition: Mass Market Paperback
Price: $7.99
292 used & new from $0.01

4 of 6 people found the following review helpful
4.0 out of 5 stars Sci-fi for the thinking-person, April 2, 2004
Xenocide is Orson Scott Card's third installment in the Ender series, and the second book of the Speaker trilogy. Congress has sent its fleet to the world of Lustiania, intent on destroying it in order to put an end to their rebellion. Lusitania also happens to be the only known home in the universe to sentient beings other than Humans, so the result of its destruction will be xenocide - the total annihilation of an entire alien race. When the fleet mysteriously disappears, Congress enlists the aid of Gloriously Bright on the world of Path to discover what has happened.
Xenocide is not one of those action packed non-stop thrill-a-minute science fiction stories that readers of Ender's Game might be hoping for. Instead, Xenocide is much closer to Speaker for the Dead in its pacing. This is sci-fi for the thinking man. Card has a lot he wants to say. He addresses themes of religion, sacrifice, the family, the connections we all make with one another, and much more. Card examines our place in the universe and what it means to be a living thinking being. Card even invents his own science to explain events from the physical, such as the creation of the Universe, to the metaphysical, such as where do our soul's come from. In the midst of all this is an engaging and enjoyable yarn, complete with a rich cast of characters.
If you are looking for a story that makes you stop and think, you will enjoy Xenocide. If you enjoyed Speaker for the Dead then this is a must read. Be warned though, Xenocide doesn't wrap up all of its threads before finishing, so you'll probably be looking forward to picking up the next book in the series in order to resolve those unanswered questions.


Test Driven Development: By Example
Test Driven Development: By Example
by Kent Beck
Edition: Paperback
Price: $34.56
85 used & new from $24.68

53 of 60 people found the following review helpful
3.0 out of 5 stars A decent introduciton, March 12, 2004
This Kent Beck title is an introduction to the world of Test-Driven Development (TDD). The book teaches the concepts of TDD by working through two complete sample projects. Along the way, Beck gives the reader valuable insight into the thought process and techniques behind successful test-driven development. When the reader has finished working through these sample projects, he should know enough about TDD to get started working on a TDD project.
The book is divided into three sections. The first two sections are each walkthroughs of the aforementioned sample projects using TDD. The third section is a collection of notes and useful tips to try to get the most out of TDD. If you've ever read anything from Beck, then you should be familiar with his style. If you haven't, Beck is an engaging enough writer, and the text flows smoothly and is fairly pleasant to read.
It would help to be familiar with some member of the xUnit family prior to reading this book. Beck uses Java and JUnit for the first section, but never really goes into discussing the JUnit API. Readers unfamiliar with xUnit may have no idea how to proceed with writing their own tests using one of these frameworks. True the API is simple enough that its functions may be ascertained simply by reading the code, but this is no reason not to provide explanation. The second sample project is an actual implementation of xUnit, so a bit more information may be gleaned here. Beck made the curious decision to use Python as the language of implementation for the second project, although he does provide explanation of the language's fundamentals. Finally, none of the sample projects are really complicated enough to do more than get us going on the path of TDD. There will still be many hurdles to climb when working on a real-world project.
If you are seeking a basic introduction to test-driven development, then you might enjoy this title. If you are a Java developer interested in exploring TDD more in-depth, there are better books out there.
Comment Comments (3) | Permalink | Most recent comment: Jul 4, 2012 12:53 AM PDT


Speaker for the Dead (The Ender Quintet)
Speaker for the Dead (The Ender Quintet)
by Orson Scott Card
Edition: Mass Market Paperback
Price: $7.19
328 used & new from $0.01

0 of 1 people found the following review helpful
5.0 out of 5 stars Not "Ender's Game", but an excellent story in its own right, March 2, 2004
It has been three thousand years since Ender Wiggin defeated the buggers. Over time the name "Ender" has been transformed from one that was celebrated as a savior of humanity, to one that is universally reviled as responsible for the extermination of an innocent species. Relativity has left Ender a young 35 year old, wandering the known worlds seeking to release the Hive Queen from her cocoon prison, and with that act his own redemption. No longer practicing the ways of war which he learned in Battle School, he is now a "Speaker for the Dead", telling the stories of the deceased so that those left behind may truly understand the truth of the lives of the departed. As a "Speaker for the Dead", Ender is called to a distant outpost of humanity where he must solve the mystery of the only other sentient race that has been encountered since the Bugger War.
Readers of "Ender's Game" expecting more of the same from "Speaker for the Dead" may be disappointed. Although "Speaker" is not the same style of story as "Ender's Game", it is nevertheless the natural sequel. What Card gives us is a wonderful story about an alien society. There is emphasis on the friction that naturally arises when different cultures interact, stemming from differing perceptions. This theme is played out throughout the book in the interactions between not only the humans and alien pequeninos, but amongst the other various characters as well. Card strives to show us that the we must seek to build relationships based on understanding in order to bridge our differences.
While it is not militaristic sci-fi in the mold of "Ender's Game", "Speaker for the Dead" is an excellent story in its own right. If you just can't get enough of Ender, it's definitely worth checking out.


Unit Testing in Java: How Tests Drive the Code (The Morgan Kaufmann Series in Software Engineering and Programming)
Unit Testing in Java: How Tests Drive the Code (The Morgan Kaufmann Series in Software Engineering and Programming)
by Johannes Link
Edition: Paperback
Price: $59.44
60 used & new from $1.98

5 of 5 people found the following review helpful
4.0 out of 5 stars Worth the effort, February 18, 2004
Johannes Link's "Unit Testing in Java: How Tests Drive the Code" bills itself as "a practical introduction to unit testing for software developers." Link's book is very comprehensive and touches on most of the topics a developer will need to know about before setting off on his own, including some topics that have not been addressed in similar titles.
The first half of the book addresses basic techniques for unit testing. The author is a proponent of eXtreme Programming and test-driven design, and those concepts are explored as they relate to unit testing. This first part of the book is quite exhaustive and contains in great detail pretty much everything you would expect. One pleasant surprise here was a nice chapter on inheritance and polymorphism as it relates to unit testing. Link offers some excellent advice on this rarely addressed topic.
Once you've mastered the basic techniques, Link kicks it up a notch and addresses some more advanced topics relevant to our day-to-day lives as Java developers. The book discusses unit testing persistent objects, web applications, and GUIs, as well as rarely examined topics such as concurrent programs and distributed applications. As if that weren't enough, Link throws in an outstanding chapter on the role of unit tests in the software process which is necessary reading if you are attempting to integrate the book's practices into your own organization.
"Unit Testing in Java" isn't an overly large book, but it is certainly a dense book. The tone is academic and some of the phrasing is awkward, although it should be kept in mind that it is a translation from German. I like to think of "Unit Testing in Java" more as a text to be studied, rather than as a reference. However, there is so much that is good in here, that it is definitely worth the effort spent reading it.


Page: 1 | 2 | 3