Programming Books

Dos ultimos livros que tenho comprado, assim como os da serie Head First da O'Really este livro superou muito as minhas espectativas.

Como um livro de tutorial foi maravilhoso e me trouxe muito conteudo !!!

Realmente vale a pena !!!

It's an excellent book, the book teaches you how to develop a site in three layers (presentation, business and data) in my ishe goal of this book.

It is cover a lot of great part of asp.net 2.0. It is easy to understand and implement. Some code is very profession and hard to understand. Most of them cover SQL,ASP,WEB service,security issue.I will say it is the cool part of ASP.net. You can see author spend a lot of time to collect the beauty of asp.net. You will like it no matter how many time you read the book.

'Beginning ASP .NET 2.0 E-Commerce in C# 2005: From Novice to Professional' by Cristian Darie and Karli Watson is one of the most unique and important books out there for anyone that is developing an E-Commerce site with ASP.NET 2.0. Starting from scratch, the authors step by step show you how to get a site running and WORKING well and efficient. Packed with 650+ pages of material, the authors break the steps down in logical parts, show how they go about the work to be done, and then provide the code which does the dirty work. Not only is it helpful, but it's a joy to follow the steps as so much of the curtain is pulled away to show the developer how to get the job done. This is easily one of my favorite Apress books that I have seen. One of the nicest things about the Apress line of books is the fact that they write and publish books that no one else seems to and this is a perfect example of this. I'll close with a chapter overview for your inspection:

01. Starting off
02. Laying Out the Foundation
03. Creating the Product Catalog: Part I
04. Creating the Product Catalog: Part II
05. Searching the Catalog
06. Improving Performance
07. Receiving Payments Using PayPal
08. Catalog Administration
09. Creating a Custom Shopping Cart
10. Custom Orders
11. Making Product Recommendations
12. Adding Customer Accounts
13. Advanced Customer Orders
14. Order Pipeline
15. Implementing the Pipeline
16. Credit Card Transactions
17. Integrating with Amazon

Tack on 2 appendixes to the end and you have a MUST-HAVE book for anyone that is looking to achieve the same goals that this books does!!

***** HIGHLY RECOMMENDED

This book covers it's topic E-Commerce very well. It also takes advantage of the new features found in ASP.Net 2.0 including some of the new ADO features. If you are getting ready to setup an E-Commerce site I highly recommend this book. I also recommend it for beginning developers wanting to know more about ADO and database design.
The authors have a great approach to design that anyone doing E-Commerce would do well to follow. Better yet they mention the pros and cons of different approaches and explain why they chose their approach. I've been thrilled to learn some new strategies to improve performance that I hadn't considered before as well as some new features in ASP.Net and ADO 2.0 that I wasn't aware of.
The only negative, for me, is the database as well as ADO basics this book spends many pages covering. However there's plenty of worthwhile content to justify the price. So if you are familiar with database design and have a working knowledge of ADO you can just skip past those pages. I do recommend you skim thru them though as, like me, you may learn some new 2.0 features you weren't aware of.
The book covered all my E-Commerce questions: catalog design, how to scale up/performance considerations, SSL, Security issues, credit card processing, and costs involved. They even point you in the direction of a few recommended credit card processing businesses. Best of all they approach the site creation in such a way you can quickly get up and going and then later on focus on fine tuning payment options and really making the site standout with features.

This book was an oasis in the desert of COM/CORBA obfuscation and confusion. This is the most fair, useful and easy to comprehend overview of these two models that I've come across. The author has the ability to convey the material in a way that makes it almost painless to comprehend...buy the book NOW.

Though not explicitly meant to be this book might also serve as an introduction to both CORBA and COM: quite an achievement. The authors waste no words and keep a neutral standing between the poles. I hope the next edition will contain some information about Microsoft.Net too.

A concise and comprehensive analysis of two technologies that are not necessarily mutually exclusive. Mr. Pritchard did an excellent work of dissecting each one and at the same time, achieved a perfect balance between theory and code examples that is so rare on this field. If you need to decide between COM and CORBA on your next eBusiness or back-office integration project, this book will set you on the right path.

If you're in the process of architecting a new system or planning to rearchitect an existing system, this book will prove invaluable in helping you evaluate the strengths and weaknesses of each approach. Even if you're just interested in both technologies and want to dig deeper into each, this book is a sure bet!

This book is quite thin, and yet it includes so much. The open mind towards competing technologies is important, we should all look at facts in an objective way. The book gives an excellent view on COM, CORBA and the differences between them. It also shows programming examples (not in depth) and explains things like "push" technologies very good. I would expect the first book in this subject (side-by-side approach) written by a technician, to be too detailed, with a poor language and not very educational. I was very wrong. An amazing book!

I feel like Groovy is like a programming language "Eintopf", it aggregates some best characteristics of a variety of programming languages. No matter which programming style you prefer - procedural, functional, object-oriented, meta-programming, static typed, dynamic typed... - Groovy has much to offer. The most beautiful thing is, you can easily combine different programming styles in one language and write most concise and self-explanatory code to solve your problem. With Groovy, you suddenly have so much mind-freedom, you have the choice of expressing your algorithms as close to the nature of the problems as possible.

There are languages having very concise syntax but the code is not easy for human to read. There are languages and APIs require more strikings on keyboard than thinking. Groovy is different. You have all kinds of syntax sugar while the code still tells a literal story in your problem domain.

The only fields I think Groovy might not be suitable are the machine-level infrastructures and image/audio/video processing. C and assembly languages are not replaceable by Groovy. In most other application fields, using Groovy can dramatically boost programmers' productivity and reduce programming errors.

I started off by simply renaming all .java files in my test packages to .groovy files. Worked. Then tried out it's closures and curry calls. For me there are a lot more to explore. Haskel fans will like Groovy. Smalltalk fans will like Groovy. Python fans will like Groovy. Lisp fans maybe too. Java folks? I for one, have already been conquered. If you program at all, by all means do yourself a favour and have a look at Groovy.

Groovy in Action is an excellent book on Groovy and programming. Get this book and get the insight, you'll be glad you do.

For those of you who haven't heard of Groovy, Groovy is a scripting language that is built on top of Java. Since it is written on top of Java, a Java developer can pick up pick Groovy in a snap.

I first heard about Groovy In Action (also known as GINA) during a Groovy presentation almost a year ago, the presenter was referring to Groovy In Action as one of the best references out at the time, After reading GINA, I was not disappointed. The roadmap given at the beginning of the book is a great guide to see how the book is organized out. As an added bonus, the book includes some great reference information at the end of the book. It contains Groovy Language information, a GDK API quick reference, and several great cheat sheets for items such as closures, lists, etc.

The book is full of great examples that you can use (some of the examples illustrate some of the finer points of the language).

In fact someone recently asked about where to find a complete specification of the Groovy Language. Guillaume Laforge, Groovy Program Manager and co-author of Groovy In Action, responded that the most current information can be found in Groovy In Action (source user@groovy.codehaus.org mailing list 3/16/2008).

Groovy in Action is one of the Groovy books that is a must have for anyone looking to get into Groovy Development.

This book is totally awesome. The book makes it very easy to jump around and come back to previous chapters. The book's online forum is great too. The author(s) respond very quickly. It is well worth the money. Order it now and you will be programming in Groovy very quickly.

While getting a little long in the tooth (GINA was released pre-Groovy 1.0, Groovy is now above 1.5), the material presented in the book is still very relevant and helpful. The biggest issue is that some of the newer (and cooler!) features, such as ExpandoMetaClass, of the language are not covered.

That being said, this is still a great introduction to the a language that will likely become an important player in Java shops as developers migrate existing designs to take advantage of the power the dynamic programming provides. The authors do a great job of explaining the concepts and syntax of the language, making it easy to quickly begin writing code of your own.

While books such as Groovy Recipes: Greasing the Wheels of Java are now available that cover the newest features in Groovy, a perusal of GINA can help to flatten the learning curve.

This book is fantastic. Very well done, easy read. It was the first tech book that I read cover-to-cover -without getting bored- in a long time. The author does a good job of explaining how Groovy works under the covers and does a great job of detailing how to make effective use of it.

The language itself is also impressive and I hope Groovy gets the attention it deserves. I hope all Java developers read this to see what they're missing in Java-land. :-)

Hindsight is 20/20, I'm sure the authors are sorry they included the last chapter on Grails as they did. But I don't fault them, as I'm sure the publisher was not uninvolved in that decision... ;-)

I'm giving it 5 stars anyway. Good work!

If you want to understand and write professional Windows Service programs, buy this book. You will find good C++ examples and best practices in Windows Service writing.

There has been so much written on the reviews for this book that I don't think I want to repeat all the good stuff said about it. The author has presented the various topics clearly and I like the style of writing. This book has been a great help. If you need to understand NT Services and how to program something decent; this is the book. Not for someone new to Windows programming. Just hope he comes out with another book soon.

The book is comprehensive, clear, and easy to read. The source code works and it is easy to follow (the code is available on-line.) The discussion on ATL COM servers is truly enlightening and by itself worth the price of the book. If you are writing an ATL COM server this book is a must, especially if it will be a multi-threaded server.

From the beginning the author has the attitude that NT services are easy to understand and his "prophecy" becomes self-fulfilling throughout the book. The book is well organized and it pays special attention to service design and usage patterns.

Also notice that the book does not cover hardware drivers. By the way, do read the previous review titled "One of a kind" as it gives very useful tips on installing ATL services (using "myservice.exe -Service") and housing COM objects in a service; I have not found that information in the book.

This book addresses all the issues related to such complex problems as NT Services. The author explains them in very great details, and makes you understand how all this works. The sample code works and you can use the classes from the book to start coding NT Services very fast. The author is very talented in explaining difficult concepts. Funny enough, this book has the best explanation on MSMQ, as well as apartments. As an alternative to the classes provided in this book, I recommend the CodeGuru NT Service C++ wizard written by Joerg Koenig. But even with a wizard, it is good to know how all this works.

No other source compares to the quality and convenience of Professional NT Services, either in book form or on the Internet. The only other way to get this information is to read sample code on MSDN, which is a less-than-optimal way to learn the subject.

Professional NT Services describes the issues involved in writing services, such as security and threading, and provides sample code every step of the way. The book also details how to build a service with ATL and even tells you how to improve ATL's implementation. It even talks a bit about Microsoft Transaction Server (now part of COM+).

Here are three bits of information that I discovered elsewhere that I wish were more evident in the book -

1. If you create an ATL service, the default registation code registers the EXE as a COM server instead of a service -- run "myservice.exe -Service" to register the service.

2. The easiest way for multiple clients to be able to use a single COM instance that's housed in the service is to implement the COM class using DECLARE_CLASSFACTORY_SINGLETON. This is your typical "server" pattern.

3. Clients that want to connect to COM objects housed in the ervice should use CLSCTX_SERVER in CoCreateInstance

Perhaps this information is buried in the book somewhere, but I didn't find it. At any rate, without this book, I wouldn't have known where to start.

Finally, for all its great qualities, the book needs to be revised for Windows 2000. It mentions some new features of "NT5" but I wonder how accurate this information really is.

This book is an excellent read start to finish. Topics are introduced gradually, the same topics are dug dipper as we proceed. The author makes sure you understand clearly as we proceed.
No confusions created with too many scribblings and notes, going back and forth; like in the "Head First..." I had to drop that one at end of 2 chapters, you can refer to that for some examples if at all.
With this book I never had to refer to anything at all. I definitely recommend this book over the "Head First..."

What I was most impressed in this book was how clearly it's written and yet it goes deeply on those details that can always get you confused on a certification exam.

I am very satisfied.

This is a good book to learn the concepts of EJB but for the exam you need the HFEJB book.
The details of Context objects (which method of Context object you can use in which method call of the Bean class) are more descriptive in HFEJB
If you are planning to sit for the exam this book should be accompanied by HFEJB

This is a very good book on a complex subject. Explanations of the concepts are easy to understand. Exam objectives are covered in detail with example codes and review questions.
Each chapter covers the individual exam objectives as well as summarizing the gist. Logical organization of the chapters helps conceptualize even the toughest topics.

The Quick Prep Appendix for last-minute cramming and free downloadable Whizlabs SCBCD exam simulator are very effective tools for the exam.

I recommend this book as must have SCBCD exam preparation book that can be also used as a reference book on EJB.

I used this book as a primary preparation tool for the Sun Certified Business Component Developer (SCBCD) exam. Being a beginner in EJB, I found this book to be very friendly. I liked the layout of the book in general and the writing style of the author in particular. Only relevant pieces of code are presented to focus explanation of topic in question. A complete running application may be downloaded from the author's website. The multiple choice questions at the end of every chapter and ALERTs in every chapter made remembering main points easier. Deployment descriptor elements are clarified in considerable detail and they are explained well. Please note that there are errors in this book - some of them are fairly obvious such as using a capital letter as opposed to a small letter (Java versus java) while others are not so obvious but noticeable by experienced java developers. Regardless of its minor faults, I consider this book to be a valuable addition to my library. Normally I would have a cut a star for the errors but because of its content quality, I felt compelled to give 5 stars. I just passed the exam today thanks to this book. I know that I will not hesitate to buy another book from this author. Thanks Mr.Sanghera! I recommend this book highly without any reservations whatsoever.

I have just recently started looking at smalltalk and like many people (being used to c++), when starting out in smalltalk, just going through the code didn't actually tell me much about anything, it's hard to find where anything is actually being done. After reading this book this task was significantly easier, the reason is simple, after going through this book one gets a much deeper understanding about why the code is split the way it is and gains a real insight into why this is a better approach than the usual C++ style with 100-200 lines of code methods. Kent Beck's writting makes the book a very nice read, must admit i was actually sorry when i finished it.

I wish more Java/C#/C++ programmers would read this (and maybe even learn Smalltalk) so that they can appreciate the weaknesses in those languages and possibly in their practices that they might not even realize today. I certainly did. While Robert Martin and others have offered up some of the canon of good design for contemporary developers, this little gem really reveals the "feel" of good OO.

I'm always looking for ways to make coding work better, at any level from nanosecond arithmetic operations to decade-long enterprise operations. I didn't find much of use here, but there were a few good points here (very few). Let me start with those.

The "Execute Around Method" pattern is good idea, applicable far beyond this Smalltalk context. The Beta language has "inner" inheritance, which makes the idea easy, but most other languages lack a good mechanism for undefined logic between matched operation pairs (open/close, setup/cleanup, etc.) "Enumeration" is another good one, enshrined as "Visitor" in the Gang of Four book.

Most of what's left is either trivial or Smalltalk-specific and face it, Smalltalk is mostly a cult language with nearly no commercial significance. The Smalltalk pretty-printing and variable-naming rules, fatuous at best, are just not applicable to most langages. Some of Beck's "practices" are language features (like 'super'). Other "practices", like the long chapter on Collections, seem to describe standard library classes and messages. Yet others (e.g. Type Suggesting Parameter Name) correct language defects - Smalltalk chose to give up the error detection capability offered by variable typing. Beck tries to sneak it back in with variable naming conventions sort of like Microsoft's old Hungarian naming. Some of his suggestions are just dangerous, like that one that says a constructor should "half-way construct an object in one place, then pass it off to another to finish construction. (p.23)" This distributes an object's setup responsibility across its client classes, leaves unusable and incomplete objects floating around, and causes subtle exposures in multithreaded systems - I'd rip out any code I saw built this way.

The good news is that no new trees died to make my copy of this book - I got it used, and it's returning to the used market. At least my conscience is clean on that account, no matter what I'm doing to the poor guy who buys this book next.

//wiredweird

I wish I had read this book when I started getting into OO programming. This is OO to the max, at maximum granularity.

Beck's style is clear and concise, the patterns are understandable even by a non-senior Smalltalker like me.

SBPP has changed me. Kent Beck has changed me.

SBPP shed a new light on my previous knowledge of "patterns" in computer programming. I was deep in the DP tar pit. SBPP saved me. SBPP changed almost all my thoughts on programming. It has changed what I value, and how I pursue it.

Kent Beck says that he is not a great programmer but just a pretty good programmer with great habits. Build great habits with this book. Read and reread this book every morn.

If you have studied DP, this book will open your eyes to the wider world of patterns. You will think about DPs quite differently after this book. You will be able to escape from the bad effects of DP abuse.

If DPs were nouns, verbs and adverbs/adjectives, SBPP are articles and auxiliary verbs. SBPP are used much more frequently than DPs. When you learn a language it is very important to learn more frequently used words first. It could be less efficient(or even dangerous) to learn "appreciate" before "thank (you)".

--JuneKim

Got the equavalent of what it cost me after about 5 minutes. Great reference and have just recently started at chapter 3 for in-depth how to instructions.

Well written.

This book is fairly comprehensive. There were just a few topics I would have liked to have seen more on. All in all, it really helped me get the job done.

This book was just what I needed. I'm an RPG programmer who has to learn SQL for a new application we're developing. Found most of what I needed here.

I had a vendor in the day this came to work. He asked me if I had a good SQL book and I replied, "Let's find out" and opened the box. It was perfect for what we needed. I have used it several times and it is easy to read. Being new at SQL on the 400, I am a little frustrated with the index. I was trying to figure out how to substring and couldn't find a reference anywhere. Twice I have had to forego the book and ask another person.
It is a great learning tool and I'm very glad I bought it.

SQL the standard for data access is now presented in a AS400/iSeries user format. The differences that exist for the DB2/400 user are minor but significant enough to warrant 500 pages plus.

Conte and Cravitz flood the text with real working examples that hit homeruns with the IBM midrange user. Yet, minus the sprinkling of RPG/ILE & Cobol code any DB2 user would find the text extremely helpful.

Keep this book at the ready since it's a "quick grab" when questions come up regarding triggers, UDF's or Database Modeling and design.

The Book is a great starting point for the AS400/iSeries guru looking to open their database to the outside world. With a solid SQL footing the JDBC mountain is a much easier climb.

Conte & Cravitz keep up the great work!

Wow. Bucknall has raised the bar on advanced Delphi books. This books coverage of Algorithms and Data Structures is suburb. This book should be required reading for all Delphi developers. No one can call themselves an expert level Delphi developer with out understanding the concepts taught in this book. Bucknall's knowledge of Algorithms and related concepts places him in a category with Knuth & Sedgewick.

This is a book that I've been waiting for for a long time (according to the acknowledgements, Julian has worked on it from April 1999 until February 2001, probably even longer). But it has been worth it, because it's an excellent book about algorithms and data structures implemented in Delphi (and Kylix) - usually version independent.

The book consists of 12 chapters. But even before the first chapter Julian takes on the question of "why a book on Delphi algorithms?" in the introduction. He explains that a number of Computer Science algorithms books are hardly practical, and the practical books are mainly for C, C++, or Java. This is a book about algorithms and data structures using Delphi (for Windows, but also Kylix for Linux), with a lot of focus on practical and useful techniques that make sense.

A great plus is that the code in the book works for every version of Delphi and Kylix (and probably also in C++Builder), and I'm fairly confident it will remain working in the next version(s) of Delphi and Kylix to come. A bonus point is the syntax high-lighting in the source code listings. A small effort for the author/publisher, but a great help for the reader who sees the source code for the first time.

This wonderful book is now again available for purchase from lulu dot com. The known errors have been fixed and its got a new smarter look and feel.

I still think of myself as being a beginning programmer, although that's not totally true, having messed around for about ten years with CAD macro's and dbase add-ons and turned them into full-blown applications that finally became fairly complex. However, I never had a decent IT training beyond some basics in Fortran and Algol, and know next to nothing about OOP.

I first thought Bucknall's book would not be for me, as I was afraid of landing into high level topics and getting lost in jargon.

On the contrary, I hardly can stop reading the book, which finally provides a very practical approach to Delphi/Kylix programming, giving light to many abstract topics you will not find in most books : the trade-off between speed and memory efficiency, how data structures and the mix you make of them in your application affect your program's speed and reliability, easy steps that make debugging and testing more efficient,...

Once you've got the hang of using the VCL within Delphi and know how to place controls on a form, you can immensely benefit from this book, that can be used as a reference into many algorithms and their Delphi implementation, or can be read chapter by chapter as an introduction to analyse the merits of several ways to sort/search/hash or use various data structures to solve a problem you face as a programmer.

Julian Bucknall's text is very understandable, even to non english native speakers, stays close to the topic while providing you with a wide scope of insights into related subjects. He's also keen on giving you all the tips he can coming from his personal practice as a programmer that make you understand why some theoretical topics matter to your program's quality. It's nearly like having him looking over your shoulder and helping you making the best choices. The book provides you with a real simple alternative to searching the web multiple times or trying to translate C coded algorithms into a Delphi equivalent, hence it will be a time saver to many Delphi user's, even a casual one like me.

This book is a must have, as a complement to a good Delphi / Pascal reference.

This book it's of essential importance for all mid-level delphi programmers. If you like to know the low-level working of common data structures of the IT software engineering (or if you like to build one), then buy hands down this book: it's the best around. Moreover the ezdsl (the author free library) is the fastest implementation that i have seen. Personally i look that ezdsl/delphi is faster than the STL equivalent under c++.

This book teaches with extreme clarity everything you need to know to program for Director/Shockwave 3D. A rarity amongst programming books due to the didactics, organization, and clarity/accuracy of code. It is current with Director MX 2004 and I suspect it is current with Director 11 given the information Adobe just released. You cannot go wrong with this one. The only problem is that it is hard to find, I had to buy my copy from a reseller.

I have every book publish about developing interactive 3D using director. This is the best one of the bunch. After reading this book I wish I hadn't purchased any of the others. Although the book is for director 8.5 it still the best book for Director 3D +

As anyone knows reading this review knows Director is the only program that will allow you to create 3D games and programs for the web. Hopefully Adobe will update it rather than let a very powerful program fade away.

This is an excellent book for Director and Director 3D. It is very in depth and involved, although a bit hard to understand at times. This book is not for beginners and requires a lot of hard work to obtain its end results, but they are very much worth it.

Other reviews have captured the gist of this wonderful, accessible, and thorough treatment of Director's 3D functionality. What I would like to add is that Catanese's book is just as current with Director MX as it is with Director 8.5.

If you plan to do 3D in Director MX, either games or presentations, you owe it to yourself to read this book.

I'm an IT student and possessing VB & C/C++. I have never learn about 3D and Director before. So when I want to make a Director project (game), I need a book!
And this book is the great answer. Everything you need about Director 3D is in this book! (although this book doesn't cover about Havok Physics Engine).

This book tells you WHAT and HOW, I mean, this book not only tells you HOW to make something (ex: primitive object) but also explains about that thing. (ex: what is a primitive object). So, you're not only able to programm but also understand about WHAT are you doing.

This book explains from basic and the last page explains advance technique. So, if you start from first page and finish the book, you'll become an advance 3D Director programmer (even before you read this, you're nill in 3D Director).

OK, I'll tell you what I get from this book, here is my project: a Multiplayer First Person Shooting (FPS) game! (like Counter Strike, Quake, etc). Notice that this is my FIRST 3D Director project! And I got A!

NB: if you're NOT a programmer and don't WANT to possessing 3D Director programming SERIOUSLY, I don't recommend this book, for this book is code heavy, full of code programming, just try "Macromedia Director 8.5 Shockwave Studio for 3D: Training from the Source" (by Phil Gross).
Just a note: I learn about Multiuser form Director 8.5 Studio (you won't find about Multiuser in Director's Third Dimension).

It covers majority of the database topics and is a very useful reference.

I am a MS SQL DBA learning Oracle and this was the first book I read after going through the Oracle's official curriculum. Here are my thoughts.

1)This book is definitely not for the beginners. I highly recommend you start with a more basic book that gives you an overview of Oracle. Oracle tools are highly unintuitive and using them can be a frustrating experience especially for MS SQL DBAs *smirk*. Learning to just to connect to an Oracle database is a learning experience that will take knowledge on how Oracle's network and security function.

2)If you already have a working knowledge on how to operate an Oracle database, this book will no doubt provide a more solid foundation for your knowledge (except RAC). I particularly found its chapters on RMAN and IMPORT/EXPORT utilties particularly helpful.

3)Perhaps the best part of this book is that it encompasses what the author believes is the most essential knowledge to becoming a highly competent Oracle DBA. The book does not try to be a reference for every Oracle topic. Instead, the author has smartly picked the most important information needed and presented them in a readable format.

4)My only issue with this book is that it is wordy. The book is 1200 pages long and it could easily have been 1000 pages or fewer.

An excellent book covering all essential DBA topics for Oracle 9i Administration. Explained very well covering In-depth details, Illustrations and examples makes this book invaluable. I use it as a true source of reference and I will strongly recommend this book.

This is a great book. All Oracle people must have this.

I just got this book from the library and I decided to read through it before I buy. I think I will buy a copy of it. The book touched pretty much all the areas of Oracle 9i. It is a book to have on your desk as key reference. I will recommend this book to new DBA. The author did a pretty good job. The book seems too big but very useful. I give 4 stars.