Sponsored links

Valid XHTML 1.0!
Valid CSS!
Product: Book - Paperback
Title: An Embedded Software Primer
Publisher: Addison-Wesley Professional
Authors: David E. Simon
Rating: 4/5
Customer opinion - 4 stars out of 5
Good overview

This book is very good overview of the process of embedded software design. Experts in embedded software design will probably not get much out of this book as he doesn't go into much detail on the individual topics he covers. However, the scope of this book is intended for those who are looking for a general overview of embedded systems so criticism is not really warrented IMO. Topics covered include RTOS, memory management, message management and multi-tasking system development. Anyone looking to get started on learning the principles of embedded software development should find this book worth a look.

Product: Book - Paperback
Title: HTML for the World Wide Web with XHTML and CSS: Visual QuickStart Guide, Fifth Edition
Publisher: Peachpit Press
Authors: Elizabeth Castro
Rating: 5/5
Customer opinion - 5 stars out of 5
Best book to learn HTML quickly!

After reading several really extensive books, I happened to find Elizabeth Castro's book, "HTML FOR THE WORLD WIDE WEB." For such a slim book, it is jam packed with almost everything that you need to prepare excellent Web pages. She discusses everything from basic HTML to Multimedia. She recommends several editors for HTML. There are so many she couldn't mention them all, but HOTDOG is one that I use. It is simply the best editor in my humble opinion. The discussion on linking icons to external images was put to use immediately for the screen shots on a Web page that I had done. This book gets you "up and running" quickly! Thanks to the author for your gift of conciseness without loss of content.

Product: Book - Paperback
Title: Thinking in Java (3rd Edition)
Publisher: Prentice Hall PTR
Authors: Bruce Eckel
Rating: 5/5
Customer opinion - 5 stars out of 5
Great book as far as basic language goes; poor Swing

The book is great! I particularly enjoyed the following chapters:

- inner classes (this chapter kicks serious butts; far better than even Core Java 4th edition's chapter on them)
- the Class class and its usage (same stands for reflection)
- discussing the Collection classes just kicks ass - Just Java 1.2, the only book Ive read that contains SOME info on these classes is far less comprehensive. Bruce kicks ass!
- I also loved the chapter on threads - this book is the only one (I've read several Java2 books) to discuss WHY suspend/resume/ stop are deprecated in Java2 (actually, the reason for deprecating stop() is a bit misleading - the author should have stressed that it's exiting run() from _inside_ an atomic operation that causes the problem here). Just Java 1.2 doesn't even try to discuss the problem of these three methods.
- I really liked it that Bruce Eckel always prefers experimenting to repeating what the Language Specification says
- the remarks scattered in the book are particularly cool. Even Core Java 4th ed lacks the number and depth of remarks, not to speak of other books (Just Java 1.2 is even worse in this respect) <hr>
The bad points of the book:
- the Swing chapter sucks... it needs REAL update. There are no other JFC libs, either - there is no Java2D, accessibility, drag-and-drop etc.
- the discussion of sing the clipboard is far worse than that of Core Java 3rd ed. vol.2.
- the same stands for 1.1/1.2 security - both Core Java 3rd ed. vol.2. (1.1) and Just Java 1.2 (1.2) are better in this respect
- the same stands for i18n
- the introduction to CORBA was particularly weak (not that other Java-books are good in this respect)
- the author pays too much attention to the 1.0 event model - it's unnecessary. Most widgets are presented first using the 1.0 even model - do NOT teach your students 1.0 event model. At least, we at Sun Microsystems do NOT teach it any more - why would we confuse our students? So, all widget presentations should be rewritten to use the 1.1 event model.
- nextToken()'s return value when there are no more tokens is NOT an empty String but a NoSuchElementException
- there is no GridBagLayout in the book (not that I use it.. I dont even teach it at our courses).
- PipedOutputStream's constructor param is NOT an PipedInputStream instance (only the other way round) <hr>
I still LOVE the book and recommend it to my students. You should get Core Java Foundation Classes and Core Java in addition to this book, though.

Product: Book - Hardcover
Title: Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science)
Publisher: The MIT Press
Authors: Harold Abelson, Gerald Jay Sussman
Rating: 5/5
Customer opinion - 5 stars out of 5
Lots of useful material here

The reviews here that complain that there isn't anything to learn in SICP, or that there aren't any ideas, or that there's nothing but philosophizing and handwaving, are bizarre.
SICP is full of detailed, complete examples of parsers, interpreters, compilers, and digital simulators. It shows how to build your own object-oriented programming system from scratch. It shows how to construct a extensible database query language with a backtracking search to find the answers to complex queries. It shows how to build an optimizing compiler.
Sure, none of this is useful---if your goal in life is to grind out CGI scripts. If that's who you are, this book definitely isn't for you. But the folks who don't recognize the SICP examples as real, practical programming projects are living in a funny little fantasy world. They might use the optimizing compiler every day, but it doesn't occur to them that someone actually had to write that optimizing compiler. Nope, code generation and peephole optimization techniques are not applicable to the real world because `nobody' writes compilers.
Every one of these big, complex programs is explained in detail, with *complete* code examples. You can type them all in and run them. These are big projects, and there's a lot of code, so you shouldn't expect to understand any of the examples on the first glance; you have to study it closely to understand how the parts interact.
If you're looking for silly little toy examples that fit on one page, this definitely isn't the book that you want. I get the feeling that a lot of the one-star folks are after little toy examples. Maybe they want a CGI hit counter or something.
I don't know how well this book works as an introductory book; I had already been programming for about fifteen years when I first read SICP. So perhaps the criticisms that it isn't properly aimed at beginners are on target. But the other criticisms, that say that ``There is absolutely nothing interesting here. Just a couple of bored MIT professors trying to teach extremely boring and pointless concepts'' really miss the mark. Sure, building an object-oriented programming system is a boring and pointless concept---if you happen to be a ditchdigger. But what if you want to be the person who constructs OO programming systems? Or what if you want to extend the OO system you usually use with new features? What if you *don't* want to open up a can of precooked beans and heat them up on the stove?
There are two kinds of reviews on this page. One kind is from people who say that the book is pointless and there's nothing useful. The other kind is from people who say that the book is full of useful, concrete examples.
Maybe the people who found the book useful were suckered. But how can you trick someone into thinking that something pointless and empty is actually useful? That's a hard trick to play! How could there be so many people wakling around, doing their programming jobs, *thinking* that they're using techniques and strategies that they learned from SICP, when actually there was nothing there at all? Where did those techniques come from, then?
On the other hand, another explanation is that maybe those people who think that the book is pointless and empty just missed the point. That seems more likely, doesn't it? People miss the point of things all the time. They read a little to quickly, or a little too carelessly, and the explanation or relevance goes over their heads. That happens every day.
When the reviewer says that `nothing in the book is applicable', that could be a problem with the book, or it could be a problem with the reviewer. My vote is for problems with the reviewer.