Programming Books

This is a very good java programming book, especially for beginning programmers. I've used it for both my java classes in college and it has helped me immensely in laying the foundations of my knowledge about java. It is very well organized and there is a nice flow to the book (the illustrations and examples are really helpful).

The best thing about this book is that it explains each new concept in detail, so that it would make perfect sense to somebody who has never had any prior programming experience.

This is one book that keeps you glued to the pages and makes learning a new language seem almost simple! I highly recommend buying this book!!!

I've used this book in my Java 2 class and found it very useful and accessible. I also used it as a reference when grading other homeworks. Either way the book was extremely good. This book shows clearly the authors knowledge of the subject and mentality of meeting the students at least halfway as they learn programming.

Heartily recommend this to anyone!

The Dean's emphasis on readability make this book very easy for someone who is not experienced with the philosophies of programming (OOP) and the Java language. Having used the materials for my own use, the content definitely help pave the way for mastery of other languages (c++, objective-c, javascript, etc) - thanks to the fundamentals from this book.

I would definitely recommend this book to those wanting to pick up Java or build a good foundation for understanding the principles of software development!!

This is the best Java book I ever seen. It explains all topics in a simple and efficient way. You can start knowing nothing about programming and you will finish with the first steps to be an expert. Reading this book helped me get 2nd place on the ACM Regional Programming Contest last year and several other awards. I've read some other Java books and this the best. I recommend this book to anyone!!!

If one wants to learn S-PLUS, there couldn't be a better book than this. Similar in style to Kernighan and Ritchie's books, this book is brief but covers a lot of ground. Lot of care and thought has gone into professor Phil Spector's writing and in my professional life I have always turned to this book whenever I was unable to solve any S-PLUS problem myself.

Some of the readers who have never programmed before or have been used to 1000+ pages books with zillions of screen shots and similar page fillers will find that this book will require a somewhat slower reading in the beginning to fully comprehend it. But it will be a worthwhile effort.

I have taken statistical computing courses under Phil Spector and they have been fun and this book is no different. My only regret is that he has not written books on other programming languages. (He just does not have time.) However, currently I am relearning SAS from reading his free notes (downloadable from his webpage at UCB, and I have picked up a lot in a short period of time.

Thanks Professor Spector.

The book "An Introduction to S and S-Plus" by Phil Spector is an excellent text for anyone who wants to get things done with the S/S-Plus statistical package. The book covers the basics of loading data into the system, how to manipulate datasets using the various operators and functions of S-Plus, as well as how to make full use of the graphics subsystem. Advanced topics such as how to dynamically load object code into S are also covered. The best part of the book is that it offers very useful examples of how to do things. Unlike many other computer books, the examples aren't contrived expository devices that the author cooked up in a minute. I've found that, even after using S-Plus for many years, I come back to this book over and over again for guidance on how to get things done. I give the book my highest recommendation.

Clear, concise, and to the point. Dr. Spector teaches statistics courses at UC Berkeley, and it shows.

This is a great book for the S-Plus novice. While it doesn't cover every topic it does explain a lot of basics in easy to understand English. The examples and explanations are very informative.

although this isn't my favorite pascal book, it's a good textbook without any major flaws.

EDIT: pascal is a dead language. for a simple but useful language, try Delphi (based on pascl) or Visual Basic.

This was my textbook for Pascal at the University at Central Florida. It has helped me through Computer Science I and II. It is well written and easy to understand. It helps for both the beginner and advanced programmers. This is a need for anyone who programs in Pascal.

I will definitely be purchasing other books from this author. He has a very direct, and extremely clear way of explaining what would have otherwise been confusing principles.

The High School I attended used this book for its first-year programming course. It is well written, and clearly explains all of the basic concepts, without leaving out any of the more complex parts of the language

After taking a class from Phil, I went ahead and bought his book. I have found it to be one of the best resources for general Java matter, as well as in depth discussions on advanced technologies. A+ Phil.

This books introduces the more advanced Java topics, wich are mentioned in other books but never explained. This book explains these topics in clear and easy to understand way. If i see a Sybex book i mostly leave it in the bookstore, but this book is ok to pick up!

The book presents the relevant concepts of the likes of the delegation event model excellently, and even delineates the APIs quite succintly. But,somehow,it lacks sufficiently detailed, concrete examples for advanced topics like RMI and JDBC-ODBC bridges, et cetera. However, all taken into account, it most definitey can be considered eponymously as a ( package one.In.All && must.Buy() deskTop::Reference() && nice::bedSide.Read()) for solid Java developers in the market eg. guess who!!! -Apurba Krishna Sircar

This is definitely one of the better (a lot better!) books on Java I've bought so far(I've got about 10 others). Explains difficult topics well. I use a more general book on Java for a general view of the language/classes and I use this one for more difficult topics which a lot of books only mention but do not explain. The use of diagrams and figures together with easy to follow explanations gives a better understanding of Java topics like streams, threads and networking.

This is the greatest book I have ever read (excluding Bert Silverman's "Bert's Eye View: Coping with Macular Degeneration. I can only find it coincidental that they are related and that both of them have great dedications to Dan Afergan.

This book has everything you need, just only a few description about every class of the java API, but enough to use it. besides it is cheap.

The book's title is somewhat misleading. It's not an extensive reference to Java as a whole. If you're looking for that in a small book, you might want to see David Flanagan's book, Java in a Nutshell instead. However, where Java Quick Reference really shines is in referencing the Java API. In contrast with Flanaga, Afergan tells more about what each method in each class actually does, and the values they return. All extensively indexed. Assuming you're generally familiar with the Java APIs, this is a hand book to keep handy while you're actually programming.

this book, released in 1996 was definately one of the BEST Java references available at the time. Java in a Nutshell gave some in depth discussions about Java topics, however this book was the perfect reference guide.

although old, it is a classic for JDK 1.0

Heave an egg out of an open window almost anywhere in the world today, and the odds of striking a Netscape user are in your favor. The odds are even better that this person either knows nothing of Java or believes that it is safe. Pick up almost any book on Java programming, and you will see the same superficial and misleading treatment of security issues. This important book is the first one to address the myriad problems raised by Java. It clearly and concisely explains past problems, current issues, and future risks. McGraw and Felten grab the high and mighty Java industry by the ear, and they offer sane and sensible advice to every level of Java programmer and user. One can only wish that this book had appeared a year earlier and had been widely read by Java's cheerleaders and hucksters. Perhaps then more of the problems would have been solved by now, and fewer risks would remain.

This book is wonderfully written and full of good information. It would be useful for anyone from novice users to managers to Java Programmers who are concerned about security. In fact, I strongly recommend them buying a copy to read as this is one of the best technical books I've read in a long time. The only audience I wouldn't recommend it for are the people who are doing very advanced Java Security work such as writing their own Security Manager, but they may even learn something from it.

I'm writing this review in April, 2002 when IE 6.0 became a standard browser and Netscape is RIP.
This book was written 6 years ago in the days of NN 2.0 and IE 3.0 .. Although it's more then
outdated by now it clearly explains what security risks exist for Java-enabled browsers
and answers my (and may be your) question "How the hell applets can break through Security Manager ?!"
It's main idea is to explain readers what harm applets can do, why is it possible at all
and what is done about the subject by the browser manufactures. Good work for 1996.

Note that it's not "Java security book" in the terms you may think today - in 1996 Java
was only understood as a flashy applets popping-up in the Web.

If you use a web browser that is Java enabled (versions greater than Netscape Navigator 2.0 and Microsoft Internet Explorer 3.0) ,and are concerned about Java security, this book is required reading.

At under 160 pages of text (not counting the appendices), Java Security provides a superb overview of security issues involved with using Java. The authors are security veterans. Felton heads up the Princeton University Safe Internet Programming Team and is famous for discovering quite a few holes in the Java security model.

One might think that two security experts who know the depths and implications of Java security may come out with a reference with suggestions that are overly restrictive and perhaps paranoid. That is not the case here. The recommendations that the book suggests are rational and reasonable. Java Security provides commendable guidelines on how to use Java more safely and what the future holds for Java security features.

The 6 chapters of the book provide an excellent and comprehensive analysis to all aspects of Java security. Chapter 2 provides a significant amount of detail about the Java Security Model, with in-depth coverage of the 3 prongs (as they call it) of the security model, namely: the Byte Code Verifier, the Applet Class Loader and the Security Manager.

Chapter 3 follows with a discussion detailing serious holes in the security model. The authors consider a flaw to be serious when the breach has the potential to corrupt data, reveal private information, or infecting the workstation with a virus. They fittingly note that all of the flaws detailed in the chapter have been fixed by Netscape and Microsoft. The function of the chapter is to show what sort of things can go wrong. Chapter 3 concludes with a summary of 8 significant security problems that were discovered last year in implementations of Java.

The book also goes into great detail on what developers and end-users can do to make Java much more secure. Their six guidelines for Safer Java use are:

1. Know what web sites you are visiting 2. Know your Java environment 3. Use up-to-date browsers with the latest security updates 4. Keep a lookout for security alerts 5. Apply drastic measures if your information is truly critical 6. Access your risks

Fenton has his doctorate in computer science, nonetheless, the book is written in a very clear and coherent manner. Add this to your bookshelf.

Easy to follow, very concise examples, wide variety of topics

Firstly, this book does a great job of introducing the javascript core language in a thorough and engaging way. The author goes to great lengths on topics that will concern real-world developers and discusses in depth the right and wrong way to write code.

This leads on to a more general reference on the language. It is here that the book really shines. As well as lots of examples, the fundamental principles behind the langauge and any associated technologies are mentioned. All this is done in a very avuncular style and I must admit I enjoyed reading the book, and trying out some of the examples/topics on my PC.

There are some caveats:

This is not a book for pure novices. Previous exposure to other languages is inferred and the author(s) point out similarities with Java and C++.

Netscape is the preferred browser here, but unlike some other tomes, at least IE gets a mention and differences are noted, though the writing does favour the NS browser.

These are small gripes with what is otherwise a much needed and well scripted (sic) resource.

This review is based only on a quick glimpse of the book, so read this with some reservation. I might follow up with a more thorough review later.

This book looks very comprehensive, and seem to be very much up-to-date with latest browsers and W3C standards, including DOM 1 and DOM 2.

But more than a 1000 pages probably makes it very difficult to read in bed ! ;-)

Giving 5 stars might seem a bit optimistic without further investigation, but I'm pretty sure it is a at least a 4-star book.

I wanted to learn JavaScript, up and rearing to go. So I got David Flanagan's book "The Definative Guide". But the concepts flew over my head. Its the best book on JavaScript, without a shadow of a doubt, but simply fearful to the poor old newbie like myself. Don't get me wrong, its well written, but if he had written it the way I needed it to be, it would have taken up 100000 pages. Shipping would be a nightmare!

Anyway, about this book.

It's a good book, great for newbies. I don't know why the other author review mentions that you need to have prior experiance with a programming language. That's rubbish IMO. Sure he mentions Javascript having a simularlity to C/C++/Java, but its not like you gotta learn those languages, its just a mention, thats all.

He explains basics, like what a token is, how if/else/for statements work. You know, basic stuff for a newbie to learn. If you are a programmer already, just skip the first five chapters, and you'll be in the meat of the book about JavaScript, so its just as relevant for experienced programmers too.

Anyhow, once you are finished (and applied the concepts with a mock up webpages) you are no longer a newb. Then move on to that gem which is David Flanagan's Definative Guide. After going through that and applying it, you'll be well on your way to becoming a "good" JavaScript Programmer.

P.S: Becoming actually Good is no mean feat. Take JavaScript seriously folks!

P.P.S: You MUST learn HTML and CSS before reading these books. JavaScript is almost entirely based in the real world on manipulating markup and style sheets. To attempt to learn JavaScript without knowing them properly (I do mean properly) would be a major folly.

When I received this book, I was impressed by the fact that it contained 943 pages on Kylix - without covering any database or internet development. Now that I finished the book, I'm even more impressed. Not by what's not in the book, but by what's actually covered in the book.
Somehow, the book reminds me of the years I spent at the University of Amsterdam (back in 1983), and first learned to work with UNIX and Minix.
I'm not sure why. Maybe the fonts, maybe the quality. But one thing is for sure, like the cover said: this is not a Delphi book 'ported' to Kylix. This
is a true Kylix/Linux Development book, and as such, I'm sure every Delphi developer can learn something from it.

The book consists of four sections, and a number of appendices. The first section contains about 250 pages about Object Pascal. But before we
start the first section, there's chapter 0: Hello Kylix, in which the author explains why Kylix is great, and what this book will offer (and what not -
so you'll know right away). It also explains where to download the sample code, and then continues with a first hands-on getting started tour in
Kylix.
The first real section of the book consists of four chapters (252 pages) and is about Object Pascal. From data types and datastructures to program
syntax and structure. As a Delphi developer, it was the 'least interesting' section of the book to read, although I would still recommend browsing
through the pages, since there are numerous tips or footnotes that are worthwhile to read (as the back cover says: "even long-time Delphi
programmers will find some surprising details here", such as the part on libraries and dynamic linking). In fact, it reminded me of the excellent Pascal
textbooks I read during my study (mentioned before), and I can recommended it to anyone who wants to learn Object Pascal.
The second section of the book extends the 'simple' Object Pascal languages and moves on to Kylix - the RAD Development environment on Linux.
In five chapters, we'll learn how to use Kylix (the IDE, designing, debugging), and the components that can be used with Kylix. When I say
components, the author has split them in a few different chapters. First, we get the Visual Objects (VisualCLX components on top of Qt), followed
by a chapter about Foundation Objects (the non-visual components and support classes such as collections and streams, as well as threads), and
finally library routines (only the most important ones, like Strings, Dates, Maths, etc.), and component building in Kylix. Although - like I mentioned
before - this is not a Kylix 'port' of a Delphi book, the author does place 'cautions' and notes in the chapter to highlight some of the differences
between Delphi and Kylix that are important to Delphi developers. The repeated reminder in the border that keeps telling us that "Kylix is not Delphi"
grows a bit tiresome after a while, but the notes themselves are good points.
The third section of the book is about Linux - for Windows developers, and using Kylix. It covers Linux and Linux programming from a Windows
programmer's perspective, explaining the differences, and showing what to do (and how to do it differently) under Linux. Subsections include files,
memory, processes, regular expressions and scripts (this brought back some fond memories when I first used UNIX almost two decades ago). The
final chapter in this section introduces X and Qt (we've seen Qt before in the previous section). It's only a short chapter, which is good, since I
consider this only background information (to give an architectural overview of X and Qt). VisualCLX is build on top of Qt (and X) and in theory you
should seldom have to sink down to the API level.
The fourth section of the book is about entire projects, and contains two chapters: one about a visual find utility (imitating Windows' Find Files),
and a chapter on Mandelbrot 4 (I wasn't too interested in this, but the results look very nice).
Fortunately, the book wasn't finished after this last chapter, since we still have a number of interesting appendices. Covering topics such as "Kylix
for Visual Basic programmers" (there may be more than you think), "Kylix for Delphi programmers" (a bit late if you read the entire book already, but
it gives a short summary of the most important changes and gotchas, including references to chapters that cover these in more detail). So Delphi
developers may want to start reading the book with Appendix II. Other appendices cover topics like Optimization and a BASM quick reference,
although these two are too short to be of real use I'm afraid. Appendix V on Deployment is a whole lot better, especially since this is indeed an ever
returning Kylix developer's FAQ. Well written, and helpful for deployment on systems that don't have Kylix installed.
Apart from the regular text, the book contains numerous little "notes" that contain tips, background information or just useful techniques worthy to
highlight. The index seems complete, but could use a smaller font to get a better overview. Syntax highlighting is used in source code listings,
which I always consider to be very helpful. Unfortunately, on a few places it was missing or inconsistent (just as I sometimes didn't agree with the
source code indentation and layout, but these are personal feelings of course).
Back in the beginning of the book, in Chapter 0, the author explains that he wants to write a 'classic' book. The book that a bookstore would carry
if it had only one Kylix book. I'm not sure if this book is the classic Kylix book (not without database or internet coverage), but it sure is a great
book to learn Kylix as well as Linux - for everybody!

And when it comes to the missing sections (on database and internet): I can also recommend Delphi/Kylix Database Development by Eric Harmon, as well as the Kylix Developer's Guide (for which I wrote the web development chapters).

There are an infinite number of ways to skin any given cat, and when covering a new RAD environment, which one you use depends almost entirely on who your target audience is. Jon Shemitz has written his book for the experienced programmer coming to Kylix from other RAD environments on platforms other than Linux/X. This, I feel, is the source of Kylix's user base: Not the casehardened command-line Unix-lifer gcc guys, but people who have been using Delphi, Visual Basic, or Visual C++ under Windows.

For people like that, it's a natural. Jon begins with a "Hello Kylix!" project to let people get their bearings within the Kylix idea, and then systematically explores the programming language (object Pascal), the environment and toolset (Kylix itself) and finally the underlying platform (Linux, Qt, and X.) People who already have their Unix scar tissue can skip the Linux section, but Windows expatriates will be glad it's there. The coverage of Object Pascal skims the simple stuff and emphasizes the subtleties that most books gloss over: inheritance, properties, class references, and the rest of the OOP machinery that far fewer people understand than claim to. (For that part of it, I recommend this book even to people who are sticking with Delphi under Windows!) The Kylix coverage, again, goes for depth: The section on threads is clearer than anything else I've read on that topic. The Unix material is well-chosen, and I learned far more about Qt from this book than I did from the Qt doc.

The overall quality of the book is very high. The writing is superb, and the screen shots are well-chosen and clearly reproduced. Scattered throughout the text are "Kylix is not Delphi!" tips, which people coming to Kylix from Delphi had better read. The text is set in smaller type than many "fat books" on programming, so I would guess this 950-page book represents about 1100 pages using conventional layouts. No fluff, good example code, fine index. Finally, APress has at last dropped the CD stuck into the back page. The example code may be downloaded in tarball form from the publisher Web site.

My recommendation? No matter how many Kylix books you end up buying, buy this one first. Then go for the specialty texts like Eric Harmon's Delphi/Kylix Database Development.

This book is a whopping 1000 pages and never did I get the feeling that _any_ of it was fluff. Not only does it give you a thorough exposition on writing programs in Kylix, it also delivers vital information on writing and running programs under Linux. Many programming books come with source code as does this one, but I almost always never use such code because of poor quality or a lack of relevance to my project. Within 10 minutes of starting this book I had found critical uses for several of the modules Shemitz provides, and I see a lot more that I'll be using in the future.

There's a wonderful chapter on Kylix that existing Delphi programmers will find absolutely invaluable. In addition, programmers coming from the Windows environment like me, will find some terrific chapters on the Linux knowledge you need to get up to speed fast, saving you from torturous safaris through the Internet. Without question, a terrific book.

Well done, Jon Shemitz. Two things jump out from this book: first, lots of text and virtually no screen shots. That means a LOT of very erudite content. Second, brilliant organisation. It's not a feature of many Delphi/Kylix books, even the worthy ones, and it is manna when it droppeth.

The book touts itself as "a comprehensive guide for developers wishing to make quick inroads into developing native applications for the Linux platform". Comprehensive it is, but this is no quickie how-to. This author goes the extra yards and provides good, lucid explanations for why a certain thing is as it is. It reflects excellent research, meticulous QA and the trait of the true teacher, to share what he knows. As a result, I'm finding topics in this this book that have eluded me for years of Delphi work - being absent from the popular titles, the Borland help and the Borland knowledgebase.

When (not if!) you buy this book, pay attention to the Notes panels and the footnotes. Shemitz (or his editor) has been very tight about delivering the story. His post-its and those vital snippets of experiential background are not buried in the main story but are distilled out expertly and consistently into these two reader aid devices. The plot stays right on target and those tricky bits are just where you want them, without having to dive off to a cross-reference.

Because I live in a remote area, I have to buy books "sight unseen". Hence, my tech library is a "lucky dip" of useful titles and doorstoppers. With this one, I really lucked in. I think it was a gutbuster to write and consider it worth every drop of blood, sweat and tears.

This book is not pretentious about what it tries to do. It has no grandiose notions of explaining theories behind architecture, capturing history of the field, how to select architecture to enhance certain architectural qualities, trade offs to consider or patterns to choose from.

It is simply a guide on what architectural views are more relevant than others when trying to build large scale systems, what the view points guiding the generation of those views are, how to use these views effectively when guiding software projects. This it does admirably well, to the point.

It does point to other reference material of relevance for other topics on architecture that is useful for deeper knowledge.

Apart from avoiding pitfalls, this is a good book to help train senior developers and leads who want to move to architect roles. Also helps in developing shared vision on architectural deliverables to be generated among stakeholders.

4 Stars since it is rather pricey.

An excellent reference on what UML diagrams to use to capture the achitecture of a large software project. And this isn't based on the authors' ivory-tower opinions, but on their actual experience of using these diagrams in the real world. We have since used their approach to successfully capture (and thereby communicate to others) the architecture of software projects at our company.

The writing style is a bit dry (there are no humorous anecdotes), but this is more than made up for by being concise.

The book also includes an excellent primer of the various roles a software architect (and other software managers) should take within a large project.

This book presents a very practical guide to designing and developing large-scale software systems. I've been involved in a number of large-scale projects and this is the first book I've found that includes many of the things you usually find out the hard way. Things like how to effectively communicate the design to the team, how to manage iterations and how to document designs and changes to the design.

Since the topic is large-scale systems, the book focuses more on techniques than on specific examples, but it more than makes up for that by providing practical tips and recommended reading references. If you are leading a software development team or plan to, this book will help you on a very practical level.

[Review duplicated from Amazon.co.uk]

Jeff Garland and Richard Anthony have written a very practical and accessible explanation of the process of designing and describing the software architecture for a large information system. All of the major architectural structures are covered and the depth of experience of the authors is evident from the solid, practical advice given throughout. There is also a huge amount of practical advice as to how architectural structures can be described using UML, which is particularly valuable.

The only significant criticism I've have is that they don't talk about the quality properties of the architecture all that explicitly. The focus in most of the book is about capturing architectural structures rather than talking about the required architectural qualities that led to the structures being selected. The reader is left to discern this for themselves.

This said though, I'd still recommend the book to any practicing information systems architect.

I like the way Ms. Lemay wrote the book, She makes it easy for a beginner like me in VBscript easier to understand the language. It is like one of her Teach Yourself books! I highly recommend this as a good reference!

If you want to learn vbscript quickly (and correctly), pick up this book. Vbscript is rapidly becoming a great scripting language for MS internet web sites. This book gives tons of great examples that actually work when you type it in! And there's several thorough programming references in the appendices

Excellent step by step lessons on using ActiveX and VBscript. This book cleared up alot of questions I had. I just bought this book a week ago (May 1999) and I wish I had bought it a long time ago. Although this book was published in 1997, it is unbelievably useful today!

This book does a very good job of getting you right into ActiveX, and then slowly adds the VBScript. While the examples on the CD are well documented, I couldn't get a few of them to work (SelectedIndex) for one. However, I would recommend this book as both a good reference and usuable tool. Note that you should have a pretty good understanding of HTML. If you don't, you'll have problems, but the CD has an HTML book on it that is easily indexed. It helped me out greatly.