Programming Books

I absolutely enjoyed reading the book. This is a book that covers some very advanced topics in a way that it seems so easy to comprehend. I liked the way author uses examples and explains not only the technology but the use of the development tools as well. This is just one the best technical books that I have ever read.

After trying numerous .Net books I found that this one was extremely helpful in getting to know the most important parts of the .Net framework. The book covers a lot of ground, since anything can be a 'component'. The discussion is split into front end, middle tier and back end components. So the scope is big. This book assumes you know .Net, and have played with VS.Net, so don't expect an introductory level text. I think the author does a great job of picking out the most important parts of the .Net framework and demonstrating their practical use in short but useful examples.

I have been disappointed at numerous books that spend ages covering the same ground like introduction to .Net and using windows or web controls, leaving meatier issues untouched. In contrast, Faison treads quickly, and clearly, through major topics in .Net such as (not in order): using windows & web controls, user windows & web controls, Crystal reports, database access & data grids, session management in ASP, security, web services, and so on. Many other areas of the framework are covered in passing; for example a handy section on using the web browser control in .Net.

The discussion of UML in the beginning is a bit fast, particularly the terse presentation of numerous design patterns, but the author's use of UML sequence diagrams through the book is excellent.

My main criticism is that the author tries a bit hard at humor with the quotes before each chapter. Otherwise, it's a great book.

This is a comprehensive book on component-based development (with C#). It's ~1000 pages thick and packed with code and developer information that is well referenced. A bit short on component "packaging" frameworks. This book also complements well Groove development(GDK with .NET)...

Highly recommended for serious software developers.
One of the best books I have read.
Part one is almost biblical to software development process.
This is not just for .NET, the same principles are applicable to Java or Windows developments.
I have good understanding on VC++6.0, but facing VS.NET I feel daunted.
My experiences with the Windows system, MFC class lib and VisualStudio are not much useful.
This book helps a lot. .NET is very rich and deep, so you should not expect
realizing .NET with a signle book. Yet this book is a must on your reading list.

The "Search Inside this Book" feature was not available when this review was posted. This book contains the following (excellent) articles:

TABLE OF CONTENTS

I. COMPONENT DEFINITON.
1. Definition of Software Component and its Elements.
George T. Heineman, William T. Councill.
2. The Component Industry Metaphor.
Hedley Apperly.
3. Component Models and Component Services: Concepts and Principles.
Rainer Weinreich, Johannes Sametinger.
4. An Example Specification for Implementing a Temperature Regulator Software Component.
Janet Flynt, Jason Mauldin.

II. THE CASE FOR COMPONENTS.
5. The Business Case for Software Components.
John Williams.
6. COTS Myths and Other Lessons Learned in Component-Based Software Development.
Will Tracz.
7. Roles for Component-Based Development.
Paul Allen.
8. Common High Risk Mistakes in Component-Based Software Engineering.
Wojtek Kozaczynski.
9. CBSE Success Factors: Integrating Architecture, Process, and Organization.
Martin L. Griss.

III. SOFTWARE ENGINEERING PRACTICES.
10. The Practice of Software Engineering.
George T. Heineman.
11. From Subroutines to Subsystems: Component-Based Software Development.
Paul C. Clements.
12. Status of CBSE in Europe.
Barry McGibbon.
13. CBSE in Japan and Asia.
Mikio Aoyama.

IV. THE DESIGN OF SOFTWARE COMPONENT INFRASTRUCTURES.
14. Software Components and the UML.
Kelli Houston, Davyd Norris.
15. Component Infrastructures: Placing Software Components in Context.
Steve Latchem.
16. Business Components.
James Carey, Brent Carlson.
17. Components and Connectors: Catalysis Techniques for Defining Component Infrastructures.
Alan Cameron Wills.
18. An Open Process for Component-Based Development.
Brian Henderson-Sellers.
19. Designing Models of Modularity and Integration.
Kevin J. Sullivan.

V. FROM SOFTWARE COMPONENT INFRASTRUCTURES TO SOFTWARE SYSTEMS.
20. Software Architecture.
Alexander L. Wolf, Judith A. Stafford.
21. Software Architecture Design Principles.
Len Bass.
22. Product-Line Architectures.
Martin L. Griss.

VI. THE MANAGEMENT OF COMPONENT-BASED SOFTWARE SYSTEMS.
23. Measurement and Metrics for Software Components.
Jeffrey Poulin.
24. The Practical Reuse of Software Components.
Don Reifer.
25. Selecting the Right COTS Software: Why Requirements are Important.
Cornelius Ncube, N.A.M. Maiden.
26. Build vs. Buy: A Rebuttal.
George T. Heineman.
27. Software Component Project Management Processes.
William T. Councill.
28. The Trouble with Testing Software Components.
Elaine Weyuker.
29. Configuration Management and Component Libraries.
Hedley Apperly.
30. The Evolution, Maintenance and Management of Component-Based Systems.
Mark Vigder.

VII. COMPONENT TECHNOLOGIES.
31. Overview of the CORBA Component Model.
Douglas C. Schmidt, Nanbor Wang, Carlos O'Ryan.
32. Transactional COM+: Designing Scalable Applications.
Timothy J. Ewald.
33. The Enterprise JavaBeans Component Model.
David Blevins.
34. Bonobo and Free Software Gnome Components.
Michael Meeks.
35. Choosing Between COM+, EJB, and CCM.
Andy Longshaw.
36. Software Agents as Next Generation Software Components.
Martin L. Griss.

VIII. LEGAL AND REGULATORY.
37. CBSE as a Unique Engineering Discipline.
John Speed, William T. Councill, George T. Heineman.
38. The Future of Software Components: Standards and Certification.
Janet Flynt, Manoj Desai.
39. Commercial Law Applicable to Component-Based Software.
Stephen Chow.
40. The Effects of UCITA on Software Component Development and Marketing.
Stephen Chow.

IX. CONCLUSION.
41. Summary.
William T. Councill, George T. Heineman.
42. Future of CBSE.
William T. Councill, George T. Heineman, Jeff Poulin.
Appendix A. Glossary.
References.
About the Authors.

I hope this helps.

This book is an excellent collection of articles describing all of the important issues surrounding the construction of component-based software systems. Each chapter describes a different aspect of the question of how to build a system using reusable components. Although each of these chapters is written by a different author or authors, they have been edited so that they read as a continuous whole. It is interesting that the editors were able to get some of the biggest names in the field to write articles on their specialties. A look at the author biographies show that they include industry practitioners, academics, industrial researchers, and independent consultants. Together they have a very impressive amount of experience and varied expertise. Perhaps my only complaint is that because so many different topics are covered, and each article is rather brief, some of the articles just touch the surface of the issues. But they do provide a balanced picture of these issues which then allow you to go out and do further in-depth reading on salient topics using the included list of references.

Covers the full spectrum of component-based software engineering, from the basics to legal aspects. Contains one of the most authoritative collections of essays and whitepapers on the subject between two covers. I have used this book as a basis for component-based development, and have also used it as the foundation for a SQA initiative because the material also addresses quality. Many of the essays support a software reuse strategy, which is an added bonus. Another use of this outstanding book is as a resource for in-house training in many aspects of software engineering outside of the component-based domain. It's that comprehensive and complete. I recommend using this book with Successful Software Development as the two primary references in mature development organizations.

This 818 page collection of 42 papers and articles is a definitive work on component-based software engineering. Regardless of your area(s) of interest, there is probably a chapter that addresses it. More importantly, each chapter is written by a top expert in their subspecialty.

Instead of giving a chapter-by-chapter description, I am going to cover the chapters that I found useful. To begin, Part II, chapters 1 through 3 gave me a quick primer in software components and highlighted the need to think in a different frame when dealing with component-based development. If you are new to CBSW then the 48 pages devoted to the basics are worthwhile reading.

Part II's five chapters on making a business and technical case for components is outstanding and the authors cover every facet. I found Part III, which covers software engineering practices, particularly useful. The value to me was the status of CBSW engineering on a global scale because I am currently providing consulting services to an India-based company that specializes in components. For this reason I also found Part IV's eight chapters on managing component-based software systems especially valuable.

The real eye-opener [for me], however, was in Part VIII, which devotes four interesting chapters on aspects of legal and regulatory issues as they related to software development as a discipline, and component-based software engineering specifically. In particular, chapter 38 on software component standards and certification was enlightening. I was also enlightened by chapter 39's fascinating discussion on commercial law applicable to component-based software, and the effects of the Uniform Computer Information Transactions Act (UCITA) on component-based software development and marketing.

This is an excellent book that covers the entire landscape of component-based software engineering and, although is a weighty 818 pages, is not difficult to read through. Each chapter is really a paper or article, so each is standalone. If you are dealing with off-shore development in any way, the book is especially valuable, and if you are doing CBSW in-house, the key differences between this approach and other development approaches are highlighted and will give you sufficient information with which to approach CBSW intelligently and effectively.

This book is fantastic! It's like a more "fleshed out" version of Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science). It uses a neat (if somewhat weird) language called Oz, which has a number of interesting features, which are used to demonstrate the concepts of the book. Much like SICP, this book is a real masterpiece, elegantly composed and explained.

Modern programming has become fragmented into a variety of computational models (OO, functional, imperative, etc), and a variety of languages supporting those computational models. Neophyte programmers are typically introduced to just one of these models, and only learn the other, "less natural" models later. With CTM, Van Roy and Haridi take an alternative approach. They teach programming as an integrated discipline, and demonstrate the underlying links between the different computational models. By the time the reader is done with the book they will have a much better understanding of the discipline of programming, and will be well-equipped to decide which model is best suited to the task at hand. Reading CTM is an extremely worthwhile experience for anyone wishing to achieve a deep understanding of the art and science of programming.

CTM has been compared to Abelson and Sussman's "Structure and Interpretation of Computer Programs". They are similar, in the sense that they both provide the reader with a deeper understanding of programming than most programming texts. However, the content of both books is quite different, and it is definitely worth reading both.

Another book that I feel makes a good companion to CTM is Hoare's (sadly hard to come by) "Unifying Theories of Programming". It covers a lot of the same material as CTM, but in a much more theoretical sense. Where CTM is concerned with practical programming, Hoare is concerned with mathematical underpinnings. The two complement each other nicely.

In 1976 Edsger W. Dijkstra elevated programming to an intellectual discipline and taught us how to reason about what we now call "imperative programming". To illustrate his methodology Dijkstra solved challenging problems with unforgetably beautiful, yet simple and powerful example programs that are as relevant today as they were forty years ago. Since then, programming has splintered into paradigms, methodologies and suffers from baroqueness, perpetuation of obsolete conventions and other practices that restrict the full expressive power of programming "as a whole".

In 2004 Van Roy and Seif Haridi have given us a glimpse of what programming can be like without unnecessary restrictions imposed by paradigms and other heavy baggage caused by politics, ideology and historical inertia. Using the remarkably mature implementation of the Mozart system and the conceptually clean, simple, elegant, yet powerful programming language Oz, Van Roy and Haridi show us how dogmatic heavy baggage falls away when we can look at programming as a whole and choose the best programming concepts that the solution of a problem requires. Such a program becomes simpler, more elegant and therefore less error prone than an equivalent solution that is restricted to a specific paradigm.

This book is a real mind-bender that illuminates paths for computer design at both the conceptual and practical levels I'd never travelled down before.

The notion that one language can be so flexible as to accomodate both the syntax and semantics of so many different computational models, or paradigms, took some unlearning of bad programming practice before its power, elegance and potential began to sink in.

It also explodes the myth that "pure" languages -- i.e., pure OO, or pure functional, etc., languages--have some kind of innate advantage over so-called "hybrid" languages. In fact, "hybrid" (or as the authors would prefer to call them, "multi-paradigm") languages come out of this book looking even more powerful than the "pure" ones, insofar as they allow the programmer to use the right model for each task, instead of trying to make OO fit, for instance, in places where it doesn't fit so well.

The idea here is that each computational model represents a completely different way of approaching a domain problem. Used by themselves, each has its niche. For instance, everybody knows OO is good for domain modelling and busines objects. Prolog-type languages are good for applications that need to apply rules over a set of data. Functional languages are great in mathematical applications. And so on. What is new here is that one can program in an environment in which all of these tools are available in a single core semantics that seamlessly weaves these computational models into a complementary whole. Used together judiciously, with an eye toward program correctness, they make things possible that have long been considered very hard -- for instance, constraint programming.

Mozart-Oz, the underlying technology, is a strange language when you first look at it. It's hard at first to get used to concepts like "higher-order programming" or "by need execution" or "lazy execution" if you are the programming grunt in the field of most modern IT shops, forced by bosses to code in your standard fare -- Java, C#, VB, etc. If OO in Java is like the hammer that makes everything look like a nail, in Mozart-Oz you have a language that is like walking into Ace hardware store, a swiss army knife of a language (conceptually speaking) that challenges you to become a highly skill code craftsman, not just a programmer.

But, if only for the personal growth you will experience grappling with the concepts in this book, I recommend it very highly even to "non academic" programmers (like myself) as well as to any advanced student of computer science. It may be painful, you may scratch your head in places where the concepts just seemed to leap over your cranium, but if you are patient, do the exercises (and at least think about what it would take to tackle some of the research projects), you will grow.

Unfortunately, you may find the languages you work on to be rather confining, and maybe even boring, after you get a whiff of what multi-paradigm programming can do. More likely, however, is that you will grasp very clearly how the language you code in today works, and that can only make you a better software engineer. So do it-buy this book!

This book is a continuation of the first book. The book covers deployment of web application in great detail. It takes you through the development of a JSP, custom tags and does not leave you hanging like other books. It takes you through the steps of compiling, building and installing your web app. It covers security filtering and much more.

Another interesting technique this book uses, is it take the web developer through the different types of web development. It starts with development of custom tags and takes the reader through JSTL libraries and then discusses the Struts framework.

Finally, I used this book to help me through deployment of my web application. It was an invaluable tool.

I highly recommend this book. I have not had it for very long but I already find it very useful. It has helped my team introduce new technology and features into our applications. The Application Events Framework in chapter 6 helped me debug my application and discover that Struts creates a new session, if one doesn't exist, on every request In fact, JSP Tag files technology discussed in chapter 7 was the basis for a new reusable common component that we have created.

I like the style of the book very much. One thing in particular that I like is when a new technology or feature is introduced the steps needed to use it are numbered and laid out clearly without going into too much detail. Then as the feature is developed and each step is examined in detail the steps as a whole are repeated. This helps keep things in perspective - you can see more clearly where each thing fits into the big picture.

The authors also do a good job of trying to give small but useful and instructional examples of the different technologies - not always an easy task.

Whenever I look into this book I find new and interesting ideas. Even the concepts that I am familiar with I still learn new things about them. I wish I had more time to read through the entire book.

"Core Servlets and JavaServer Pages, Volume 2: Advanced Technologies" targets developers who already know Java and basic servlets/JSPs. Note this book's second edition does not cover the latest technologies. It uses J2EE 1.3/1.4 and Struts 1.3.

The main topics are advanced deployment descriptor settings, security, custom tags, filters, event handling and JSTL. Then there are three chapters on Struts 1.3. These additional chapters were very good although I'm not sure what they have to do with "core servlets." The browser screenshots were good for showing output and the examples were excellent.

As with "Core Java", the 700 page book contains some long classes. I could have done without the complete 5 page deployment descriptor at the end since it was gradually built up with new additions highlighted. The highlighting does help with spatial orientation.

I did notice a couple typos in the book. None of these affected the meaning, but it gives you the impression it wasn't proofread as carefully as other books. And (at least my copy) had a printing error where one page was missing a few lines.

For most part the book pointed out best practices. There were a few exceptions such as one chapter mentioning which jsp page should establish a database connection. Different chapters had different opinions on whether there should be scriptlets in a JSP as well.

Overall the book was fine although I would prefer to invest in a different title - either fully on Struts or fully on servlets/JSPs.

2nd edition has all the details for environment setup so it makes it easy and clear how to start your first web application. I always refer to this book when I need some reference or to review basic web application development.

You want to know a great way on "how to" identify classes from any type of user requiremnets? Buy this book now!

A lot of OOA books like to tell how to design from start to finish. However, some (most) of us are thrown in some obligatory process without consent. CRC will bridge the gap on getting your Classes defined.

Also, CRC works well for "Use Cases". I use CRC after a good Use Case session for Class Diagrams. Some prefer to do CRC before Use Cases. That's the beauty, CRC can be injected anywhere you deem fit.

And, finally, this book will get you "thinking in objects" fast!

I have been trying to teach OOD to new graduates for a couple of years. Now I teach through this book first. It has more good information about how to get groups to come up with good designs than any other book I have found. Be warned, it's not about UML or Java. The book is about how to get people to work out a design together.

This book and the stream of thought it stems from is one of the most influental in OO software engineering. It focuses on sharing responsibility in a system. It takes into account the obvious parallels between software teams and their software systems.
The technique itself can be very enjoyable and if you can convince very formal people to use it, it will change their lives, much more then any formal OO methodology will do. CRC Cards make you live software systems! This should be the first experience of everybody who wants to learn OO. You can even use it to explain your work to your kids:-)

This book encourages better OO design and analysis, shows how to involve the entire team of developers to the design of the whole system. The authors also describe how to gain benefit from involving the user and other parties to the OO design process.

I was in OO development for five years and I was thinking about a solution which will improve the efficiency of OO design and help to avoid splitting the program between developers who create their own set of classes they are responsible for. Such splitting leads to integration problems and overall design imbalance. Fred Brooks has described this consequences in his famous book "The Mythical Man-Month", where the modules are being written first and integrated later, and the coordination of interfaces between modules written by each developer requires essential effort and time. The CRC Card Book shows how to have "the interfaces" coordinated in the very beginning.

However, the methodology described in this book is "fragile". As soon as it isn't followed by all of the developers, it became useless. But if it is followed, the results are amazing. The book, however, is not very easy to read and lack something which can attract the developers who are "neutral" to improving their way of creating OO programs. But, for the people who already have strong OO background and are seeking the way how to improve their efficiency significant, the book is a must-have.

I am computer savvy, but not a programmer. I had never written any HTML when I read this book, but after I finished it, I was able to put together a Web site. I think I learned more from this book than from a lot of the $50 Web books I've purchased since.

I found this book extremely helpful in re-working my websites. The book is easily read and understood - even for those who aren't "computer geeks". It builds up from the basic to the advanced in HTML writing in easily digestable chapters. I give it a hearty thumbs-up! Gabriele Endress

As a professional web developer, I am always looking for ways to brush up on my skills and stay competitive. So of course, when I saw this book, I was eager to see if it could provide me with any new techniques for the creation of web pages, particularly "cool" ones, using the popular new Hypertext Markup Language.

Sadly, I found it very disappointing. The author advocates many methods of web page creation that are inaccessible, woefully out of date, or just plain wrong. When I suggested implementing some of the coding techniques in the book, I was literally laughed at by my colleagues.

The book does not cover even the most rudimentary basics of semantic markup, and even suggests using the FONT and TABLE tags to apply styles without even the briefest mention of CSS.

I will certainly not be recommending this book to my fellow web developers any time soon.

(In all seriousness, I read this book when it was new, and it got me started tinkering with web pages. Now I work for Yahoo. The 5 star rating is honorary.)

There are a lot of "The Web's so cool and if you just buy our book you can make a million dollars" kinds of books out there. I've gotten tired of them very quickly. For one, the Web is just new, it's not the salvation of mankind. For another, they always have some underlying motive (beyond making money), and usually its ramming their own web pages down your throat. Taylor doesn't do this. In fact, he makes you feel very welcome as he explains, in a pleasant narrative style, this big blob of networks called the Web. He's not condescending about it, he's not pushy about it, but he is excited about it, and it appears genuine. The book itself details the standard beginner stuff, with some advanced carrots that leave you drooling for more (I know how to do tables but how do I set up a counter?). Many of these books will disappear rapidly over time because of the advent of HTML editors like Netscape Gold, but this book will stick around - there's plenty in there for the advanced user too. One complaint: Dave, stop using Microsoft Internet Explorer!

A good user friendly guide to help you understand the shortcuts and operation of Cubase. I found Robert Guerin's explanations of midi and it's use in cubase most help full.Also the use of the project pool and how best to organize and remove files on the hard drive.In the back of the book you will find the most relevent shortcuts for use on the keyboard for Audio recording and Midi operation.
There is alot more to the book as others have aready mentioned.
The bottom line is if your having trouble understanding how to operate this recording software,BUY THIS BOOK!
This book is definitely worth buying.

This book is twice what the handbook is, especially if you only have the pdf version. Since the pdf version is the only version you get when you buy Cubase and if you want the hardcopy version you have to buy it, save yourself some time and money. Buy this book instead of the Cubase manual. This book is easily laid out and enjoyable to read. The illustrations are right on the mark and compliment the text excellently. My knowledge of Cubase doubled after reading this book, and it helped take my recording to the next level. As I pick out recordings and listen to them, it is easy to tell which one were recorded before reading this book and which one were recorded after. I recommend this book for anyone serious about recording using the Steinberg Cubase software.

Cubase SX and SL are exceptional packages that actually come with good manuals. Unfortunately, the reference manual is 700 pages long and only provided on disk (to be fair, it is also available for purchase separately). Some people adapt well to electronic books, but I don't - I like to riffle through the pages looking for useful tidbits and inspiration. For folks like me, Robert Guerin has written the perfect book.

Cubase SX Power is written very much from the practitioner's point of view. It offers a tour of the software, accompanied with little exercises, that covers the things most likely to be of importance to someone trying to create and record a piece of music. As such, it is a bit more focused that the manuals are. It tries to give you the basics you need, and doesn't dwell at length on some of the more intricate details that are more confusing than helpful at first..

What it does very well is get you over the initial learning curve that Steinberg's software presents to the novice. The writing style is clear, without any frills. This isn't a 'for dummies' kind of book though - Guerin assumes that the reader already knows some of the basics of recording and is intelligent enough to have a computer in the first place. The book has stood the test of time for me and is often the first place I look when I have a question - which is the best recommendation I can give any reference book.

Anyone who has Cubase Sx knows that the rather large manual comes in PDF format on the CD. This is both annoying and a little cheap on the part of steinberg. To the rescue come Robert Guerin's Cubase Power. Much more than a manual this is a great tool for anyone who uses Cubase SX. If you new to the program or a long time user, this book is a must. The thing that sets this book apart from many similar books is the writing style of the author. Using a clear and easy to follow style, he never gets bogged down in the details but never loses site of what he is trying to teach you. Teaching by example he leads us thought real world ideas and issues.

I kept thinking about another book "Making Music With Emagic Logic Audio by Stephen Bennett" while reading this. How deferent the two books are. How one author has a clear idea of what he is trying to do and how another is lost in useless details and unclear language. How one may be a an "expert" but have little idea how to share the knowledge in easy language.

This book should come with Cubase SX instead of the PDF manual. It would make using Cubase SX an even more elegant and rewarding experience.

For some of us learning programming has been less of a structured approach and more of a journey, picking up what we could as we went along. This book is a significant aid in that it takes us back to the basics of how to write problem solving code and at the same time giving us an extended toolbox to apply to how we perform it. It has been a real help to me by reinforcing things to me that I thought I understood, and teaching me new ways to do things that I had no idea on how to approach.
Al Edlund

Michael McMillan's "Data Structures and Algorithms Using Visual Basic.Net" is an excellent resource for the serious programmer using Visual Basic.Net. With the advent of the .Net technology there have been some major changes to Visual Basic, one of them being the collection classes. Most vb reference books provide a weak introduction to the collections and how to use them; this is the focus of the book and really allows the reader to gain enough confidence to start using them effectively in their own programs.



I look forward to more books from this author.

McMillan does for Visual Basic in .NET what other languages like Java, C and C++ have long had. Fundamental data structures like hash tables or hash sets, arrays, linked lists. He shows how to use these in the VB context. They greatly simplify your programming tasks. These constructs are so widely used in any practical programming language.

Without them, you find yourself having to tediously reinvent basic functionality. Adding little value. And with the risk that your implementations might be buggy.

McMillan shows how to use the structures in several algorithms. Having said that, this book will not be of any surprise to someone already familiar with algorithms. It does not go into these to the depth of Knuth's 'Art of Computer Programming', or Sedgewick's texts.

I have selected this book to be the textbook of an introductory course in data structures and algorithms for my second year programming students. There were three major reasons behind this choice:

1- The book doesn't go into the mathematics found in other books. Of course, mathematics are essential for those who want to create algorithms, but it's not the case for the majority of programmers, at least in the business computing field, who just want to implement them. On the contrary, I think that teaching the mathematics underlying the construction of algorithms makes the learning process unnecessarily hard.

2- On the data structures field, the book takes advantage of structures already implemented in the major development platforms. As the author says it: "students of data structures and algorithms can now see how to use a data structure before learning how to implement it" (Preface, p. vii). From an educational standpoint, this is a far better approach than starting to discuss a concept abstractly.

3- The examples are in VB .NET, which I consider a good starting programming language. For those who rather prefer another language, the author has recently published the same book for C#: "Data Structures and Algorithms Using C#".

In a word, I consider this book an excellent practical approach to learn common data structures and algorithms without going into the complexity of mathematics.

Having programmed the AS/400 since its inception, I thought I knew everything about the DB2/400 database. But Conte's insightful volume reveals new possibilities and capabilities.

Filled with a perfect mix of theory and hands-on examples, this book allows a reader of any level of experience to benefit from the author's many years of expertise. Conte is a stickler for professionalism and attention to detail, and "Database Design And Programming For DB2/400" not only typifies his love of excellence, but encourages the reader to raise his or her own personal expectations.

If you're a manager, buy every programmer a copy and make it mandatory reading. If you're a programmer who wants to be the best, you must have this book; my copy rests at arm's length on my desk. If you're an educator, this would make an ideal textbook.

This is the best work on the subject available today. Paul obviously put his heart, soul and considerable talent into this book. It's hard to believe that a book so filled with useful information is available at the rather low price of $75. ----small errata---- There's an error on page 410, 2nd paragraph. The sentence which starts out "Although the SQL precompiler requires Declare Cursor statements to be coded in the procedureal part of a program..." is not true for Cobol. Cobol allows you to put Declare Cursor in the Working-Storage Section as well.

It has become my daily Bible in my job as an AS/400 DBA. Even after reading the whole book last winter, I still seem to read a passage from it everytime I need inspiration on doing something new or different (or that I can't remember how it is done) with DB2/400.

I am looking to modernize our AS/400 database development with the latest modeling tools and functions without disrupting the traditional DDS-centric RPG development efforts of my programmer customers. I serve customers in dozens of countries with varying levels of SQL/400 knowledge, but being an ex-mainframe DBA, I appreciate the effort IBM has placed into DB2/400 (or "DB2 for AS/400") into giving it mainframe-DB2-like capabilities. I am hoping Paul Conte will come up with a new edition of this book for OS/400 V4.3 because I would love to see these issues addressed in the same manner that DB2/400 V3.6 is presented in this book. Maybe even a chapter devoted to interoperability issues between DDS and SQL/400 and why/how to make the migration would be splendid.

I wish I had this book as soon as it was published. After programming on the S/38 and the AS/400 (in RPG) for over 14 years now (with some interruptions), I consider this one the best AS/400-related computing book I have purchased - ever! And compared to other computer books, well, if only that kind of quality would be available on other topics as well more frequently, either DBMS's or programming languages. The book saved one of my clients hours of work: with no previous SQL knowledge but having this book they were able to do some work with SQL that otherwise would have required them to write a program. Another client (and myself for my own system) took advantage of the chapters on Referential Integrity. If you're serious about accessing your data on your DB2/400 database, you owe it to yourself to buy this book !

The 3 customer reviews i saw for this book are quite accurate in this readers opinion. this book provides an excellent foundation for database design

however, i think giving just the in-topic highlights would have helped an interested reader like myself,in making a more informed decision; and as such, i thought i might include these here in a review :

Re:
(A.) Database Implementation & Design elements;
-----------------------------------------------

You will learn all about : how to ;
-Represent business processes with ERD's in a conceptual design & data model/design blueprint,
-Create, control & modify a database,
-Structure a table & normalize it,
-Transform a data model/design blueprint into a relational db,
-Lay-out a solid phyical design, and
how to implement your design/blueprint solution by:
-deciding on the db sytem architecture to use,
-creating,tables,constraints, views,
-controlling db object priveldges,
-transporting data via bulk copy, a study on the import/export wizard,
-querying databases using SQL , subqueries, joins
-SQL procedures ie: Triggers,User defined functions, creating & using stored procedures, flow-control structures ie: IF's , WHILE loops, CASE statements ,et cetera ;
-creating & managing indexes and index views
-Data access via ADO, ODBC,OLE DB

Re:
(B.) The Database Application Development aspect;
-------------------------------------------------

You will learn all about :
-creating database applications with Visual Studio.Net,
-Developing a Web based Applications interface to a database system ,viz:
-creating forms based on views/queries
-creating reports, embedding subforms and subreports,
-creating reports based on stored procedures
-creating network databases ie: client/server architecture,
-using XML, XML datafiles, XML schema, creating XML Web services with Visual Studio.Net

Re:
(C.) Database Administration elements ;
----------------------------------------

You will learn all about :
-Installation of SQL Server
-Server security, Managing Database User accounts,
-Security Authentication, Roles, Permissions,
-Backup and recovery
-Database Replication
-Database Optimization & tools used in performance tuning ie: transactions & locking
-Building a database maintenance plan.

Re:
(D.) Data Analysis Services elements;
-------------------------------------

You will learn all about :
-Building & Designing an OLAP (On-Line Analytical Processing) solution
-Building a Data warhouse ie: dimensional modelling, fact table, ETL(extract,transform,load),
-DTS-(data transformation services)
An example OLAP Case study : demonstrating visually a star-schema, snowflake-schema etc

Re:
(E.) -Data mining ;
-------------------

You will learn all about :
-developing data-mining models ,
-data-mining algorithms
-creating decison trees
-deploying data-mining results with DTS
An example data-mining Case study

et cetera, et cetera

i hope this helps

Excellent book, Easy to understand and covers most topics of database which includes database design with detail explanation about data modeling, table structure, normalization and transformation of data model to relational database, use of SQL in managing database objects and querying databases, views, indexes, cursors for database applications and much more.
Other topics includes data accessing techniques, use of database in network environment, database administration, data analysis using Online Analytical Processing (OLAP), data warehousing, and other analysis tools, and also discusses about data mining.
Since it provides detailed easy to follow instructions using step-by-step case based approach, it helps to understand database concepts clearly. I recommend you to buy this book.

If you consider database administrator or developer as your career, this book is for you. The book covers most topics in the database field from database design, programming, administration, to data mining. All topics are well organized to keep you in track, step-by-step to build a strong foundation for your database career.

With more than five years of working as a DBA and developer, this book is still helpful to me every day. Your every penny counts in this book.
Thank you Dr. Chao for such great work.

They say, how high you get to build or you will go with anything depends on the foundation you are able to establish.

and that we all sit on the shoulders of giants

well, if you want to develop and manage database systems professionally (ie: conceive database design blueprints, develop, implement/produce or bring the blueprint into the physical, and deliver with articulate proficiency any relational database system -(for database applications at the enterprise level ie:client/server-based applications and web-based applications)

then, you are going to need a thorough mastery of the core underpinnings eventually, before you can commandingly build brilliantly the way you like ie:

You need to permit yourself a
1.) Thorough mastery of relational theory in order to have the flexibility & adaptability to consistently produce solid database design blueprints; this implies knowing how to make the right design decisions/design selections & the ability to see the whole picture ie:(how everything will fit together beforehand)+ the ability to then work-inwards & outwards in the detail levels, in order to forge the database you want.

2.) Thorough mastery of putting out a conceptual design to meet, answer/respond to your users business needs.

3.)concrete knowledge of the steps to take to verify the accuracy of your design proposal(logically), checking it for correctness & adequecy, regardless of the design methodology u adopt before you give the green light to implementation.

4.)knowledge of database implementation & how to manipulate the data to retrieve whatever u and the boss require or want out of it.

5.)knowledge of how to fit/hook-up your implementated database as part of a complete system solution and make it belong; eg: as a client/server-based applications & web-based application in the context of an enterprise ie: as an accessible enterprise application residing on a network-share.

6.) knowledge of how to keep historic data , classify these away, organise and set them apart for future purposes ; ie: for future reporting or querying . in short, expertise in building yourself an OLAP side to your design blueprint , a data warehouse et cetera, in order to set up/satisfy a clients data-mining & future decison-analyses ambitions/prospects for the database system.

These are the things you will need. This is the professional know-how which can help you become a highly-paid, consulted professional or a senior developer/designer.

This is the secret most newbee's stuck on the outside looking in on the inside, not knowing how to navigate the tide or where to begin from to get to the heart of the profession, seek.

This is clarity.

Thus, If you have any gaps in your database development know-how, which requires filling -(you'll know this in yourself), then i would recommend 2 primordial books for it:

(1.)"Database Development and Management (foundations of Database Design)" isbn 0849333180
&
(2.)"Database Design and Development a visual approach" isbn 0130351229

Now with regards each book :
Note: (due to review real estate constraints, i shall limit this review to Book 1, the current book in question.
you'll find my Book 2 review on Book 2's customer review page under :"Database Design and Development a visual approach" ISBN: 0130351229)

Book 1:"Database Development and Management (foundations of Database Design)" isbn 0849333180

is your cement/concrete foundation book.

the book does show favor for implementation in SQL SERVER & MS Visual Studio.Net, but the central database design foundation/tenets is sound for ORACLE,DB2,SQL SERVER,MS Access.

Basically, this one book answers questions like: what is a database, the component parts & pieces that make one up , how do the pieces all fit together, what does each one do, what do they each bring to the picture of a database blueprint solution

From the book you will learn all about :
(A.)Database Implementation & Design elements
(B.)The Database Application Development aspect ie: creating database applications with Visual Studio.Net, Developing a Web Application
(C.)Database Administration elements
(D.)Data Analysis Services (OLAP, data-ware housing)
(E.)Data mining

the long & short of it is that,
If database design, development and management appears to be one big convoluted puzzle, well, this book puts it all together for you and tells you how & where everthing fits.

this is the power of this book. and as such, it is brilliant!

This is a book you'll want to keep, its of great value and accessible to the very green beginner, intermediate or pro person.

these 2 books will bring you something most Developers and DBA spend half their careers trying to figure out ;which is, d complete skill-set of how to handle a database project from point A to Z all by yourself. For most people, theory only ever meets hands-on practise in the proverbial 2-3years work experience context , from on the job experience.

However,the db design foundation which this book delivers to one features the core staple a fledging database developer or DBA would go through a
-MCSD -(Micorsoft Certified Solutions Developer) or -MCDBA -(Microsoft Certified Database Administrator) I.T certification/ accreditation in order to obtain.

this applies in a lot of ways too to ORACLE

This staple constitutes the core skill-set,profile/credentials, employers in the real world generally seek to hire onto db management projects despite the hard won bachelors degree in computing.

cheers :-)