1 comments about Android Essentials (Firstpress).

1. This book could have been decent, but instead it's just outdated. Too many things have changed in the SDK. I recommend waiting either for an updated version of this book, or a different book covering 0.9 beta, or better yet, 1.0.

5 comments about PHP and MySQL by Example.

1. I purchased this book for the retail price of $49.99 at my local bookstore. I did this based on the preface that states an errata, as well as the lab solutions, can be found online. Since I know all code books contain some errors, I usually look to see if these errors, when discovered, have been posted on the book's site.
   
   Well, even though the book states there there is an errata, truth and in fact, there isn't. When I emailed the publisher they stated "Thank you for purchasing our book. I'm afraid we've not yet compiled an
   errata. Would you be willing to share the errors you found with me, so
   that I can inform the author?" Strike One.
   
   The preface also states that the solutions to the labs, that usually end each chapter, can also be found online. Truth and in fact, only 4 of the labs can be found online while the other 10 or so are not posted. Strike Two.
   
   The last problem I had with this book is the amount of errors. As I stated before I expect books to contain errors. We are all human and I hold no grudges for this. But to be honest, this book contains the most amount of errors I have ever seen. Did they have someone proof read this? The publisher told me "I apologize for the errors you're finding, but I admit that in a first printing, which is what you have, this is not unusual." Strike Three.
   
   I will say that the publisher did deliver excellent customer service, and while not refunding the money for this title, they promised to send another book based on the same subject. I have not received it as of today, but if I don't by Friday, I'll update this review.
   
   As for the book itself. The first few chapters are done really well and explain to a beginner, like myself, the concepts of PHP. But when you move past Chpater 5 you start finding numerous errors, one of which had me thinking I did something wrong and spending over 2 hours trying to work it out. (The errors in the book are also on the CD-Rom files that come with it!)
   
   This book has a lot of potential, but because this is the first printing I would suggest staying away until they either fix the errors or keep their word and publish the errata and lab solutions.
   
   Oh yeah, and beware of the first review... isn't he also the co-author? He might be a little bias.



2. This book contains many, many, many errors. The book itself gives the URL for the publisher's website, claiming the errata is posted there. It isn't. Shame on the reviewers and on the editor for allowing this to go to print with so many mistakes.
   
   On a positive note, finding and correcting the errors has helped me learn the material more thoroughly, and I'm finding there are some other great books out there on PHP and MySQL.



3. I purchased this book for a class and have been going through the examples on my own. Several of the examples have typos that result in the example scripts not running. Some of the errors are as blatant as leaving out closing brackets on HTML tags. Others I still haven't figured out. There is no errata online, which is disappointing.
   
   A programming book written for beginners really needs to have extra proofing done by the author (a typical proofer in a publishing house wouldn't understand the code and couldn't catch errors) prior to being published, and it is clear that this book wasn't proofed very well at all.
   
   If it were not for the errors, I would recommend this book.



4. The book and cd code are error prone. The co-author writes a five star review trying to come off as an instructor in a php boot camp. Come on!! This book should not even have been published in this state.



5. Here's everything you'll ever need to know about the only PHP book you'll ever need:
   
   1. This isn't it.
   
   2. Zend has outsourced all of their online training nonsense to one of this book's authors, so if you have any doubt as to whether or not his bountiful errors and omissions were worth paying $40 for, take care not to make the mistake of paying $1,000+ for more of the same.
   
   3. All the 5 star reviews are fake.

5 comments about GNU/Linux Application Programming, Second Edition (Programming Series).

1. I've been programming for a good while but I am relatively new to Linux. Sure I've flirted with it a little in the past but I've mostly been down in the worlds of Nulceus, vxworks, and threadx.
   
   I found myself needing to come up to speed fast on a lot of little things - multi threading, communications, piping and build processes. This book covers it all in good enough detail to get you on your feet fast. The sections on signals was especially helpful as was the nice overview of gdb which while not the debugger type I'm used to - really proved to me how useful that old program still is (and since I'm stuck with the command line version of it - how to really make that version sing).
   
   As a quick reference/introduction this book can't be beat. Highly recommended



2. This book covers a wide breadth of what you need to get started with Linux programming. The writing is very good and readable.
   
   The examples though simple, are very clear and concise, and makes you understand at a fundamental level what elements of Linux you need to know.
   The ones I liked in particular were:
   - IPC (interprocess communication)
   - Linux process model, and pThreads
   - shell scripting, awk, sed
   - bison, flex
   - tools like GDB (debugger), gprof (performance), gcov (code coverage)
   - sockets programming
   
   Note that this book does not go very deep into these topics, but if you need a refresher on the basics, or you don't know a particular area of linux, this book is highly recommended.
   
   Most of the examples are in C, as expected, (being Linux) except for a very short example in Ruby with Sockets programing.



3. Looks like I'm going to break the mould of giving five star reviews to this book.
   
   Part I is a brief overview of the history and motivation behind Linux. No bones there.
   
   Part II covers compiler and related tools. I learnt a few things from these chapters (I wasn't familiar with either autotools or gcov).
   
   Part III covers application development. The emphasis is mainly on IPC. There are some grim errors in the code. In particular, I winced when I saw the use of asserts that contained statements performing actions with (necessary!) side-effects. Compiled in optimized mode in most environments, this code will crash. For this section, Stevens/Rago APUE or Rochkind AUP serve much better.
   
   Part IV, shell scripts and tools is OK, as is part V, debug/test.
   
   I'm not sure why there's a CD included. It contains the source code (of little value, easily downloaded) and all of the diagrams used in the book. I can't imagine that they will ever come in handy.



4. Bought this book as it had so many good reviews on Amazon.com. I really should have paid more attention to the one review that said "Disappointing" (Paul Floyd of Grenoble, France).
   
   I haven't yet read the bits about history, tools or shell scripting. What I have read is the section covering application development. This skims through areas such as sockets, threading, semaphores, mutexes, message queues, memory-mapped files etc. All useful areas, but this book does little more than tell you what the man pages tell you. That's where the first bit of lazy authoring comes in. The second bit of lazy authoring is the complete absence of an explanation of how to use these areas together, or an example of using them together. Given the list of topics, an example would have been useful that starts a worker thread to handle a TCP connection, that thread waiting on file descriptors and a timeout using select or poll, using mutexes to protect data, a message queue to communicate between the main thread and the worker thread, and possibly a memory-mapped file to create a circular log of the last N actions performed. Unfortunately the author didn't attempt that. But we should possibly consider ourselves lucky that he didn't, as the example code he does provide contains some major failings, most notably putting code inside assertions that is required even in optimised release builds. When this code gets compiled out in an optimised release build the examples fail. Obvious to anyone that knows about assertions, but not necessarily to everyone reading the book.



5. This book is perfect for anyone who needs to write application software for GNU/Linux. It describes all those miscellaneous features for programming that are above the kernel but below the level of integrated development environments. It describes makefiles, gcc, debugging, object file analysis, sockets, pthreads, performance analysis and much more. The latest edition also has an excellent overview of virtualization.
   
   The author doesn't go into detail on any one subject, and that is what makes the book so good. I can find details in various online sources. This book is perfect for someone who had normal training in C/C++ and now needs to understand how to develop on a GNU/Linux system.

5 comments about Designing Object-Oriented Software.

1. I am a System Analyst by profession. I needed a book which will help me in understanding the basics of Object Oriented Technology to enable me to perform System Analysis and Design for developing OLTP applications using the Object Oriented Technology. I must admit the book served the purpose.



2. I am a veteran lecturer of object oriented programming> Unfortunately, despite the popularity of the subject and the (seeming) abundance of books in the discipline, I still have a difficulty in providing my students with a comprehensive source of information. This book, however, covers more than any other book I know of, in the clearest form.



3. This book is great because it makes sense. Its simply well thought out, consistent in its approach, and extremely insightful. Even if you dont use CRC cards or dont use the term "Responsibility Driven" in your work, you will find this text and the concepts it presents fit in nicely with the newer UML notation and "way of being." Although you won't find "Use Case" in the index, the stability of the common sense put into this book will map easily to whatever modeling doctrines you use. The fact that Amazon.com is shipping a software design book that is almost 10yrs old in 24hours should also tell you something about its credibility. Simply, a great book.



4. When the book is more than 10 years old and still a required literature in the area, that really tells you a lot. Especially if the area is software engineering where things tend to change quickly. After more than 10 years this book is still a fundamental reading from OO design. Even IBM recommends this book for it's Object Oriented Programming exam. First several chapters are really classic - everything is there: why OOP?, objects, classes, responsibilities, collaborations, hierarchies. If you read this first and then go for any C++/Java/put_your_favorite_oop_language_here book, everything is going to be much much easier and more clear even if you have a decent OO design background. There are even couple of presentations of complete implementations of fair software projects using the terminology and techniques described in the book (last two chapters). If you are beginner in OO design or you have to read just one "theoretical" book from OO design or don't know where to start concerning OO design, I recommend this one. The only drawback is that book is still pretty expensive, but I am sure that you will not regret...



5. When I started learning Object Oriented Design, I was a C programmer with some COBOL experience. I was having a hard time making the paradigm shift to object orientation. This book was the best of several that I read. It was while reading this book that "the light came on". Since then, I've been recommending this book to anyone who is trying to make that paradigm shift themselves.

   The book is language neutral - just as design should be. So you won't get hung up on examples in a language that you don't have.

   Wirfs-Brock takes you through the design process, from the requirements to finished design, helping you understand how to discover your objects and assign responsibilities to them (Responsibility Driven Design (RDD)). She uses Class/Responsibility cards (similar to if not the same as CRC cards) to illustrate the documentation of information. Though there are more modern tools (UML) to capture some of this information, I still use these cards early in a design process because of the ease of changing/correcting them.

No comments about MCITP Self-Paced Training Kit (Exam 70-237): Designing Messaging Solutions with Microsoft® Exchange Server 2007.

5 comments about Cocoa Programming for Dummies.

1. A decent introduction - but it starts off assuming you already know C (like most intro to Cocoa books -- When will someone write a learning to program with Obj-C/Cocoa for beginners new to programming?).

   The book could use more detail in describing why you do certain things in Obj-C/Cocoa instead of just saying do it this way.

   But the worst part is the huge number of errors and inaccuracies in the book. Every chapter contains multiple errors - usually with missing steps or method names changing between steps or being differnent in the pictures. The editing is HORRIBLE. This really should be .5 Edition - it really is too error ridden to be a 1st edition.

   If you are looking for a book to get you up to speed on Project Builder and Interface Builder (based on the Dec. 2002 Developer Tools) then it is a decent introduction. But don't expect this to get you started in programming for OS X if you don't have any real programming experience. And the constant errors in editing are pretty bad; you have to keep on your toes to make sure you account for them or sometimes the examples won't work.

   Finally, to the cocoa book writing community in general -- please address the market for new programmers who want to learn to program in Obj. C/Cocoa and who do not have any extensive (or any at all) programming experience in C.




2. I've been trying to teach myself Cocoa for over a year now. OS X is an absolutely stunning piece of software, and I love the idea that Apple includes in the box a full set of developer tools I can use to create my own little OS X masterpiece.

   The problem, however, is the learning curve. For a first-time programmer, Cocoa is one tough nut to crack. There are lots of third-party books out there now. Unfortunately, they are all geared toward experienced programmers. Every book assumes fairly extensive C or OOP programming experience, and none cover basic programming or Objective-C in sufficient detail for the complete programming newbie.

   While this book isn't really an exception to the rule, the approach is definitely more newbie-friendly. I purchased the book on a Thursday, and finished it on Sunday evening with a much greater appreciation and understanding of Cocoa technology.

   What made the difference? For one, by the time this came out, I already had some exposure to the underlying technologies: I trudged through Apple's Objective-C documentation (hard-going for non-programmers, but after a couple of read-throughs, the material starts to gel). I did the Currency Converter tutorial, which got me familiar with Project Builder and Interface Builder, the two most important tools in Cocoa development. I read various other portions of Apple's on-line documentation, and looked at some tutorials available on the web. As noted, I'd also taken a crack at some of the other books available on the subject, throwing in the towel on all of them before hitting page 100 or so. None of this taught me how to program in Cocoa, but it gave me enough background to tackle this book and understand just about every topic covered.

   If, and probably only if, you've at least looked at Cocoa and Objective-C before (or have significant experience in C, Java, Smalltalk, or other OOP), you will be able to not only work through, but understand, the exercises in this book.

   And the exercises are very practical and clearly explained. Rather than build a book-length, professional quality application, the author builds small, toy applications to demonstrate Cocoa patterns that you can actually use to build your own software. For example, the chapters on text handing, window management, and file and folder management, are clear and concise, allowing the reader to work through them quickly and without complication. This fast and dirty approach, at least for me, had the added benefit of allowing me to get through the book in less than a week, take a step back, and appreciate how all I learned could be used to start building my own, more complex project.

   I'd like to thank Mr. Tejkowsi for being first to market with a Cocoa beginner's book that actually works for beginners. His effort gave me a taste of the power of Cocoa, and the confidence to return to other, more advanced texts that I'd walked away from before. Thanks to him, I'm not ready to give up on Cocoa just yet!




3. I must echo decker's complaint about the editing, which really is horrendous.

   But my criticism of the book is deeper still. On pp. 55 - 56 in discussing the use of number formatting for output in the interface, the text describes the "bug" as resulting when "the count of digits in the decimal protion doesn't match between the two numbers". This is a material misstatement, and neglects any attempt to explain the real cause of the problem that the formatting is intended to solve: The inexact representation of (most) decimal fractions in machine representation. Yes, this is an advanced programming topic - and may not be of interest to beginning programmers; but there is no excuse for giving an incorrect explanation instead. Why does this book waste pages and pages on repetitive explanations, yet remain incapable of providing a sentence or two on one of the most fundamental facts for computer programmers. This insults the intelligence of even a beginner.

   Chapter 6 (for example) contains repetitions of very basic material introduced in Chapters 3 and 4, some it word-for-word duplication of passages on outlets and actions and their connections in Interface Builder (pp.117-128). Where was the editor during the production of this material? This whole repetition seems to be for the benefit of introducing the Objective-C keyword "id".

   Later, on p. 121, the author misses a golden opportunity to introduce the reader to the benefits of Cocoa's naming conventions for accessor functions in classes. The method that returns the value of an instance variable can (and should!) have the same name as the instance variable. Many advanced features of Cocoa (especially in Panther and Xcode) become much more usable if one follows this convention. It couldn't have taken more than a page or two to introduce the subject, yet the book repeats itself annoyingly on several other topics. One suspects neither author, editor, nor reviewer knows anything about many important Cocoa topics. What a waste!

   Then, further, the inclusion of some material seems inappropriate for this introductory level. For example, why waste several pages digressing on the use of the File Merge utility. No beginning programmer needs to worry about this, and there are far less risky ways of modifying the interface after files for it have been created.

   "Cocoa Programming for Dummies" finds its way to the top of my list of "Worst Programming Books Ever Published." I felt after finishing it that the reader would know EXACTLY as much as the author about Cocoa programming - no more, and no less. In other words, Tejkowski "holds nothing back"; he's told us EVERYTHING he knows about Cocoa programming. Perhaps I should be more sympathetic: Why did the acquisitions staff for the Dummies series rope a RealBasic programmer into writing a Cocoa book? Couldn't they find someone more qualified? The Dummies series generally handles its material in a light-hearted and clever fashion; how did it sink so low in this fiasco?




4. The number of errors in the code and processes in the book make it very frustrating for beginners. I think with a good rewrite and update for Xcode, and more careful editing (some errors were obviously a result of the production process, missing lines of code that were included in the online extras files, missing steps in development instructions, and such) this would be a useful beginner's book.



5. This is not a very good book for learning Objective C and Cocoa. The author programmes in Basic, and it shows. Get the much better introduction called Cocoa Programming for Mac OS X from Aaron Hillegass.

2 comments about On the Way to the Web: The Secret History of the Internet and Its Founders.

1. Michael Banks does an excellent job consolidating the characters involved in the events leading up to the web. My first instinct was to think this book was going to be just another boring "history lesson" of the web. I couldn't be more wrong.
   
   Michael is very in-depth with the stories associated to each character in his book. While all have their own story, the drama surrounding one character in particular, Bill von Meister, was especially thrilling.
   
   While some aspects of the book will be more appreciated by geeks, it is good for all audiences -- geeks, students and your average PC user. I would highly recommend digging into "On the Way to the Web".



2. I'm old enough to have to admit to having owned a 300 bps modem connected to a Commodore 128, and being in awe of the ability to exchange emails in three or four days with people on the other side of the planet. Michael A. Banks takes you back to those times in the book On the Way to the Web: The Secret History of the Internet and Its Founders. It's far too easy to forget exactly what led us up to the place we are today when it comes to instantaneous communication via the web. This was a book I thoroughly enjoyed, and it brought back fond memories of my initial fascination with online activities.
   
   Contents:
   Looking Back - Where Did It All Begin?; In The Money; Making Contact With CompuServe; The Source; Dis-Content and Conflict; Evolution; Online Experiments; Trials and Errors; The Second Wave; AOL Gestation; The Third Wave; In With The New, Out With The Old; AOL Evolves - Expansion, Integration, and Success; Prodigy - The Flat-Rate Pioneer Who Just Didn't Get It; Moving To The Net; Omissions, Additions, and Corrections; Online Timeline; Bibliography; Founders; Index
   
   Banks starts out in the 1960's with the beginnings of what we now know as the Internet. ARPANET was the first attempt to network two computers together through a common set of protocols that would allow dissimilar computers to communicate with each other. But even though ARPANET worked, it was still limited to government and educational institutions. The ability for the common man to hook into that power was nonexistent. Of course, the personal computer was not even a concept that most people could grasp. Computers were big and powerful (for the time), and who would need one all for themselves? This started to open up more in the 70's, when online database resources started to become available. Timesharing computers were available to connect to these sites via terminals, but the cost was incredibly steep, often in the hundreds of dollars per hour of connect time. To play in this world, you had to be rich.
   
   But as time went on, the personal computer started to become a viable option for people, and with it an accessory that opened up the world... the modem. Companies started realizing that all the unused computing power on evenings and weekends could be made available to consumers with modems, and thus launched services like CompuServe, The Source, and Prodigy. Although purely text-based to start with, computer owners started to flock to these services offering revolutionary features like discussion forums, CB simulators (chat), and online news. Much like the dot.com era that's more understandable to people, the race was on to make your fortunes in the online world. Text-based offerings gave way to graphical interfaces, prices started to drop, ideas were born and died in a matter of just a couple of years, and greed and personalities were still in conflict with solid business plans.
   
   Banks wraps up his book in the mid-90's, when Internet access was starting to become accessible to nearly anyone with a computer and modem. Bulletin board systems started dying out, as people didn't need to dial to get to individual sites any longer. A single phone connection to their ISP would connect them to the full world of the Internet. Walled-off content systems like CompuServe and Prodigy no longer had a monopoly on information, and had to adapt or fold. The "Web" had started to take off, and the proprietary offerings of content and navigations were in their final chapter.
   
   For aging codgers like myself who were into computers during this time, On the Way to the Web is an incredibly interesting step back into the past. I fondly remember calling bulletin boards for hours on end at 300 bps, tying up our phone lines and incurring the wrath of those trying to call me. Getting a free trial period to a service like Online Airline Guides made me feel like I was on the bleeding edge of information and technology. At the time, it's hard to look at where you're at and envision a future vastly different than what you currently have. On the other hand, looking back now reminds you that history repeats itself, and the dot.com frenzy wasn't very much different than frenzies that came before. This book will be a great "blast from the past" for those like myself, as well as a great resource for those interested in how we got from two computers networked together to constant connectivity to everyone else.
   
   You can even get your kids to read this and start with the "when I was your age, we didn't have..." stories. :)

5 comments about Mastering Algorithms with Perl.

1. As a guy ( engineer not computer expert ) who uses computers everyday to help his research, I would steer you away from using Perl for any task involving mathematical concepts more complicated than addition/subtraction/multiplication and addition.

   I heard this same advice before buying this book and ignored it, I really wish I had listened back then.

   While MAP has some nice pictures which broadly describe the essential concepts, it will give you no idea as to how to actually implement those ideas. Further, all the code is available in CPAN ( If you don't know CPAN, check it out before going any further - at the very least install a module ) and much ( at least what I attempted to use ) appeared to be broken.

   Authors of computer books are usually good about answering e-mail but these authors did not deign to respond to mine.

   If you are out there, struggling to learn algorithms, I would suggest taking a good computer course on the subject. I'm 99% certain the course will be taught in C/C++ or similar language -these languages have tremendous advantages over Perl when it comes to data structures and, believe me, even as a novice I've come to appreciate them...

   If you really know algorithms and wish to write a few in Perl, you can do without this book. Pick up Deitel & Deitel's 'Perl: How to Program' instead or O'Reilly's basic book ( which is good, but I prefer Deitel and Deitel ) ....besides D&D answer their e-mail.




2. This book is a great book, not only on the subject of algorithms, but also on how to implement them in Perl. A huge number of topics are covered, from Data Structures, to Searching/sorting, to cryptography, and much more. And what I found to be among the most useful additions was that for every subject, they give you a full implementation on the subject. I've read a few books on algorithms, but this is one of the most easy to read, and definitely one of the most practically useful. Recommended for any Perl programmer, regardless of skill.



3. Klowledge of algorithms and data structures is vital for effective programming, and Perl is one of the most popular programming languages around, so this book fills a long-needed niche.
   
   If you've ever looked at "Introduction to algorithms " by Cormen et al (CLR), this book will look familiar. It covers many of the topics covered in CLR, though not in such theoretic depth. It does, however, have mountains of Perl code implementing those algorithms.
   
   This book can seemingly have two purposes - one is to learn algorithms (as the title suggests), and the other is to understand the implementation of algorithms in Perl.
   
   IMHO, the authors fulfilled the second part quite well. For the first part, CLR is a excellent book and is hard to better. I don't think "Mastering algorithms" explained the topics in a clear enough way to compete with CLR, but it can indeed be a terrific companion to CLR (get the first edition, used copies cost pennies). Read about the algorith m in CLR, understand it from the pseudo-code and diagrams, then take "Mastering algorithms with Perl" and learn the Perl implementation of the algorithm.



4. If you have ever studied algorithms and data structures, then balanced trees and O(N) notation may still be a painful memory. Also, part of Perl's strength is in its built in parsing and sorting features so why would you need to know other ways of doing the same job? If your work does not challenge Perl's features then you probably do not need this book. However, if you have no computer science background and Perl is your language of choice then this book requires serious consideration.
   
   The book is concise and the advice given in concepts like choosing an appropriate data structure or in benchmarking your program is actually quite sound. It covers a wide number of topics such as sorting, searching, sets and matrices together with material you may not find in a data structures book like geometry, cryptography and statistics.
   
   Your choice depends on the task at hand. If you're looking for a Perl book where you can find routines to encrypt a string or find the maximum distance between two points then this book will not disappoint. Indeed, I believe that anyone serious about programming would benefit greatly from some of the Computer Science subjects discussed and implemented in Perl that are offered in this book.



5. This is a very accessible introduction to data structures and algorithms in Perl. It doesn't go into a lot of theory, it isn't going to answer your computer science homework, but it does give a good feel for the various applications of algorithm research.
   
   Plus, the code is all in Perl, which is not as unreadable as received wisdom asserts. It's certainly more accessible for the interested Perl-savvy amateur than the pseudocode in Introduction to Algorithms.
   
   Obviously, you're going to have to move onto the likes of Cormen et al, if you're really serious about this stuff. And practically speaking, yes, most of this can be found in CPAN without you having to worry your pretty little head about the mechanics. If just getting something done is your main concern, then this is not the book for you.
   
   Plus, it must be admitted that the level of detail varies across the chapters, and some of the explanations can be opaque, even for the simple stuff. I felt I had to work unnecessarily hard to comprehend some of the material: the discussion of the A* algorithm, some of the tree-related algorithms and the section on compression all suffered from this to varying degrees. This is the sort of book which requires concentration (plus copious scrap paper for scribbling down arrows and boxes) to get anything from.
   
   But to complain that Perl doesn't need you to write these data structures from scratch, and it isn't a suitable language for this sort of thing anyway, is to miss the point of at least part of the book. It's about communicating the intellectual pleasure of wrapping your head around these fundamental bits of computer science, and in that respect it succeeds admirably. If you're looking for an introduction to the area, this is definitely worth getting hold of.

5 comments about A Programmer's Introduction to C# 2.0, Third Edition (Expert's Voice).

1. A print copy of this book is probably a bad idea, since its main value is its capability of describing differences between C# 1.x and 2.0. Not written to groove anyone into using C#; targeted more at people who know 1.x intimately or those coming from a java or c++ background, wanting to know about generics and other "new" features. It would sure be nice to have the pdf freebie that comes with a lot of apress books, but no -- it costs another $30. If you really want to know about C# from the ground up, this book can only be ancillary to something like Liberty's book or Troelsen's Professional C# and the .Net Platform. Hence the fact that you can buy it used for $10 or less.



2. I expected this book to just cover the enhanced 2.0 features. That's not the point at all. This is an all you can eat C# introduction book that goes really, really fast. Read in the title that this is for 'programmers'. That means that the author expects you to understand how to program an object oriented language. If you know that already then this book will get you into C# 2.0 quickly and easily. If you don't know how to program, then this book is not for you.



3. If you have not been programming for years or have a degree in Computer Science don't buy this book! However if you are a "real" programmer and want to learn the C# fast, it is a very easy to read, quick and pleasant why to get up to speed.
   
   Once you have learned C#, you will need to read some books that cover what ever part(s) of the .NET framework you wish to use. However knowing C# before you try to learn the .NET framework will give you an advantage.



4. Easy to read and understand.
   If you are new to C# look elsewhere (Troelsen, Liberty).



5. When I started at my current job, I was asked to program in C#, even though I had originally been hired as a Java programmer. Faced with this task I went to the bookstore and bought a book. The title of this one won me over, since I didn't want a book that explained object oriented programming from scratch - I had experience with Java and C++ already - I just wanted something that walked through the various features of C# at a fast pace.
   "A programmer's introduction to C# 2.0" does an excellent job at being such a book. The authors rapidly go through the various aspects of the C# language and the .net platform, introducing some peripheral topics, such as Windows Forms, on the way (just one chapter though, so don't buy the bok for this). Generally more attention is given to topics where C# differs, subtly or substantially, from similar languages like Java, and less attention is given to the basics that most C family languages have in common.
   As such I've found that the format of this book enabled me to learn C# very rapidly based on what I already knew about other languages. I would strongly recommend it to programmers in a similar situation. My only gripe right now is that the book would ideally be updated for C# 3.5, but this doesn't seem to have happened yet - however C# 3.5 programmers can read this book and get the additional topics from other sources.

5 comments about Safeware: System Safety and Computers.

1. This is an OK book that should have been an excellent book. Frankly, it was a big disappointment. The author is the grand poo-bah of software safety, and so I expected the book to be deep and profound. Instead it is rather shallow with lots of generalities. A lot of what is said is the type of common sense discussion that I would expect from a social scientist, rather than a scientist. I was particularly surprised to see but one page on independent verification and validation. This is a very important topic for ensuring software safety, yet one evidently not on Professor Leveson's radar screen.



2. The key to understanding safety lies in the understanding that no one component failure or no human error ever occurs in isolation - an accident is a result of some systemic problem, and this is the fundamental theme of this book. No single book could ever address in detail all of the finer points of system safety analysis (indeed this would take a series of books) but Leveson is able to capture the core issues in an engaging manner. This book is a must read for any student of software and system safety, and will continue to be relevant in an age where automated technology is ubiquitous.



3. This book is among seminal works on system safety and safety engineering and should be read by anyone who is entering the field. One may not necessarily agree with Prof. Leveson's views (e.g. her often unfair and unjustified dismissal of european approaches to safety engineering) but her views in the field are simply too important and influential to be ignored!
   The book is a good "bed time reading" that gives an overview of the field, major problems and introduction to some major approaches. It is however not a handbook per se - you will not understand any particular method sufficiently to apply it.
   Overall, very good introductory text with a good coverage and a very easy and clear language!



4. Interested in the development of high integrity software? Looking for a system safety engineering text? This is not the one for you.
   
   This book won't describe when to use a sequence number or what size CRC is appropriate for your safety-related communication, or what level of code coverage is appropriate or what level of requirement coverage is appropriate for your identified hazard etc. It won't describe the actual versus perceived issues with OOA/OOD, what aspects of a hard real-time design require attention or how to meet the expectations of an independent assessor or certification agency.
   
   The principles of software design assurance/software integrity can be garnered from the standards such as DO-178B, and DO-248-style discussion papers or from CENELEC 50128 and good old MIL-STD-882B to name but a few. Alternatively a free start can be achieved by downloading the Joint Software system Safety Handbook from the US DoD.
   
   Save your money for the works of Moriarty (executive-level), Ericson (introduction/supervised practitioner), or Dunn (software controlled system safety intro) if you must buy something.
   
   But if you're looking for some stories to put into your slick safety presentation or seminar then it might be just the right book.



5. This book is a starting point of what is important to make a system safety.
   This provide over all view of system safety not software safety.
   The case studies in appendix are very important for safety engineers.
   Appendix A is the therac-25 story on Medical devices.
   Appendix B is Apollo 13, the DC-10 and Challenger, Aerospace.
   Appendix D is windscale, Three mile island and Chernobyl, Nuclear power.
   These are very bad accidents, so we should study more deep.
   The naming "safeware" is very good wording, this is not safe software nor safe hardware.
   Go ahead, after this book. There are many resources about ssytem safety and software safety.