Design Patterns is a modern classic in the literature of object-oriented development, offering timeless and elegant solutions to common problems in software design. It describes patterns for managing object creation, composing objects into larger structures, and coordinating control flow between objects. The book provides numerous examples where using composition rather than inheritance can improve the reusability and flexibility of code. Note, though, that it's not a tutorial but a catalog that you can use to find an object-oriented design pattern that's appropriate for the needs of your particular application--a selection for virtuoso programmers who appreciate (or require) consistent, well-engineered object-oriented designs.
Book Description
Now on CD, this internationally acclaimed bestseller is more valuable than ever!
Use the contents of the CD to create your own design documents and reusable components. The CD contains: 23 patterns you can cut and paste into your own design documents; sample code demonstrating pattern implementation; complete Design Patterns content in standard HTML format, with numerous hyperlinked cross-references; accessed through a standard web browser; Java-based dynamic search mechanism, enhancing online seach capabilities; graphical user environment, allowing ease of navigation.
First published in 1995, this landmark work on object-oriented software design presents a catalog of simple and succinct solutions to common design problems. Created by four experienced designers, the 23 patterns contained herein have become an essential resource for anyone developing reusable object-oriented software. In response to reader demand, the complete text and pattern catalog are now available on CD-ROM. This electronic version of Design Patterns enables programmers to install the book directly onto a computer or network for use as an online reference for creating reusable object-oriented software.
The authors first describe what patterns are and how they can help you in the design process. They then systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. All patterns are compiled from real-world examples and include code that demonstrates how they may be implemented in object-oriented programming languages such as C++ and Smalltalk. Readers who already own the book will want the CD to take advantage of its dynamic search mechanism and ready-to-install patterns.
Customer Reviews:
WOW!!!.......2007-09-13
Being a total noob to programming, my friend got me into learning about Objective-C and Cocoa. I have bought many books on the subject and I'd like to say that this book helped me with my understanding of objective-c programming language.
Thanks to the authors
Wonderful but it is difficult.......2007-09-05
The book is wonderful and samples are very exciting and meaningful.But book is difficult,if you don't have any idea about design patterns,you cannot learn easily from his book.But If you are not new about Design patterns,this book is very useful.
Fantastic Book.......2007-08-12
I would recommend this book to any software developer, architect, or designer. Fit for all levels of experience. It is clear why this is so often referenced in other development literature.
A Thorough Introduction.......2007-08-12
I have read this book many times over. I purchased
this book many years ago and I still reference it today. For those
who are interested in OO design this is the best book I have read,
followed by John Lakos "Large Scale C++ Design". This book will
have you thinking about how to design software, and if you are
diligent, eventually you will be designing your own patterns.
This book is a definite must for any language, since it will
change the way you view software.
Great book.......2007-08-05
I found the case study very helpfull. The patterns explained in a very clean way, so I recomand every developer that is interesting in design patterns, refactoring etc to read it.
Average customer rating:
Good state machine methodology
Useful, but mostly as a historical document
Concepts are incredibly valid and useful
Too old
Excellent Presentation of OO for Embedded Development
General
| Artificial Intelligence
| Computer Science
| Computers & Internet
| Subjects
| Books
Object-Oriented Design
| Software Design, Testing & Engineering
| Programming
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
Real-Time Data Processing
| Algorithms
| Programming
| Computers & Internet
| Subjects
| Books
General
| Computers & Internet
| Subjects
| Books
General
| Software
| Computers & Internet
| Subjects
| Books
Mathematics
| Professional Science
| Professional & Technical
| Subjects
| Books
| Applied
| Chaos & Systems
| Geometry & Topology
| Mathematical Analysis
| Mathematical Physics
| Number Systems
| Pure Mathematics
| Transformations
| Trigonometry
Programming Languages
| Computer Science & Information Systems
| New & Used Textbooks
| Stores
| Books
Look Inside Computer Books
| Trip
| Specialty Stores
| Books
ASIN: 0471599174
Book Description
Are you looking for a more effective approach to real-time systems development? Real-Time Object-Oriented Modeling The development of real-time distributed systems is one of the most difficult engineering problems ever faced, taxing the capabilities of traditional real-time software development approaches. Real-Time Object-Oriented Modeling is the first book that brings together, in a single harmonious approach, the power of object-oriented concepts tailored specifically for real-time systems, with an iterative and incremental process based on the use of executable models. Developed by practitioners, the proven methodology described here is becoming a leader in the industry. Using a learn-by-example approach, this book offers:
* A single consistent set of graphical modeling concepts, chosen to improve developer effectiveness, which apply uniformly to analysis, design, and implementation. This reduces the learning curve to master the entire method and eliminates expensive discontinuities across different stages of development.
* An approach to the object paradigm that is easy to learn and that applies to the construction of reusable architectural design components, not just low-level language elements. This unleashes the true power of the object paradigm.
* Techniques for constructing executable models to gain early confidence in specifications and design decisions.
* Approaches to project management that deliver the benefits of the object paradigm and executable models.
Customer Reviews:
Good state machine methodology.......2007-02-10
ROOM is a great methodology, but I rarely encounter it in my work. I do mostly SOA and BPM work, and I think there are aspects of ROOM (particular its state machine language) that are well suited to that domain. I wonder how popular ROOM is these days in the real-time and embedded systems development community?
If you're into state machines, you'll enjoy this book. ROOM is influenced by the work of David Harel, supporting hierachical states, group transitions and transitions to history, choice points, and the ability to associate actions with both transitions and states. In contrast with Harel, ROOM does not support orthogonal states, although its concurrency model is quite powerful. I prefer ROOM to the UML for the modeling of state.
Useful, but mostly as a historical document.......2004-03-05
First, remember that this book was published in 1994 - it was probably written in the 1992-3 era. The OO design world was still in the "warring states" period before unification under UML. The company that created ROOM tools, if I understand correctly, was absorbed by another company that was absorbed by another company - I'm not sure how much of ROOM in its pure form is still left.
That doesn't matter. In its time, ROOM was wild, innovative, and a topic of heated debate. It created a visual, highly abstracted language (back then, a questionable novelty) around an intensely parallelized model of computing (also a questionable novelty), at a time when "real-time" often meant lots of assembly programming in command-line environments. I was doing embedded development back about then - based on the mind-set of the time, I'm surprised that ROOM had the success and influence that it did.
Surprised but pleased. Lots of the ROOM techniques and notations survive in UML and other development tools. Modern component programming environments, JavaBeans included, show many signs of direct descent from the ROOM techniques. Still, there's a long way to go. ROOM may have been way ahead of its time, and languages still haven't caught up fully to its models of communication and parallelism.
As impressive an achievement as ROOM was (and is), I have some reservations about it. It relies pretty heavily of state machines for modelling the interacting components. State machines are a good tool, but quite unfamiliar to most software developers these days. I'm not sure whether that's a fault of the methodology or of today's programmers. I also have reservations about any methodology that requires me to buy someone's tools. The authors state that the design methodology can be used without their tools - based on ROOM's complexity, I doubt it. Also, I have a serious distrust of any programming environment that takes over so much of the process. Such tool sets tend to leave me feeling cramped, with little way to express my ideas in different terms. Finally, I'm sure it does all it says it does. Even so, the moment always comes when the tool-generated subsystems need to be opened up for debugging, or when the system has to be open to interaction with other development tools. Real-time and embedded systems tend to be so idiosyncratic and demanding that both kinds of openness in an IDE are compulsory. I just don't see the way out of the closed ROOM.
My present interest is not so much in the ROOM methodology itself, although I'm interested in methodology in general. Instead, I'm studying the visual notation it developed for expressing complex computations. Whatever ROOM's faults and whatever its later history, it's still worth attention.
Concepts are incredibly valid and useful.......2003-11-05
The eminently practical, usable, powerful, elegant and - once understood - simple concepts behind ROOM deserve the broadest audience amongst real-time and even non-real-time developers. It has been a couple of years since I cracked the cover and I recall the reading being dry. Nonetheless, if you are considering a move to Rational Rose RealTime as a development tool (into which ObjecTime evolved), then this book is truly helpful as a reference for the modeling concepts. The example used throughout is simple enough that it is easy to grasp allowing you to dedicate your time to conceptual understanding rather than getting your head around some obtuse example. At the same time, the example is a natural vehicle for the inclusion of advanced concepts as each is intoduced.
The concepts of ROOM are finding/have found their way into the UML and the "it's not UML" darts of years ago are a little tired at this juncture.
ROOM is brilliant.
(from a former ObjecTime/Rational type though with no association for a few years)
Too old.......2003-04-03
This book doesn't even mention UML. It may be good if you want to use author's modeling.
Excellent Presentation of OO for Embedded Development.......2002-12-07
I have used ROOM since 1993 - it is a very useful and flexible methodology. The authors present it in a very clear and well thought out manner. The examples also show that this is not a "toy" methodology. ROOM comes out of the author's years of experience in developing real solutions; I can only say that it has been very successful for myself and teams I've been on as well. That it has evolved into the real-time representation of UML only shows that these authors were ahead of their time.
This book covers the most common, and usefull design patterns. Each patter is presented in plain egnlish, with full examples.
In addition to patterns this book covers the principles surounding patterns that make them truely usefull.
Super Book - The best of them all.......2006-11-10
In my role as an architect and a J2EE evangelist, I have to teach a lot about OOAD principles, the Java language and Agile techniques. There are lots of books in my armour that capture the gist of many of these practices and techniques. But none in my opinion better than this book.
Robert Martin is a master at explaining OOAD concepts and applying them to the Agile methodology. For instance, the Agile practices mandate certain practices that need to be implemented in the upfront design and conception of the project. This is in contrast to the methodologies that were hitherto used that emphaisized methodology over design.
This book provides that point of fusion. A great achievement indeed! Concepts such as dependency injection and the Single Responsibility Principle were explained before they became mainstream design tenets.
Industrial strength book.......2005-04-13
Many OO/Patterns books are written as an introduction to the concepts and gloss over the nuances of building software in the real world. This book takes on the nitty gritty of what most developers face day to day. While it does include the gratuitous "student registration" example, this book actually delves into issues such as integrating legacy code. It also actually implements bad design choices before moving on to better solutions, and even these solutions are described in terms of trade-offs between competing forces. Also, by discussing specific Design Patterns in more depth than the cannonical format, I had a few "a-ha" moments when patterns I never quite understood emerged. I would/should have given this book 5 stars, but I had problems with the layout (oversized pages/no margins), the inconsitencies of diagrams (clouds and UML), and the disjoint feeling that the book was a collection of separately written articles, although the author does tie them nicely together. All in all, this is a must have.
Brian
brian_x7@yahoo.com
Required Reading - none better.......2005-02-11
Absolutely no one writes as well, knows as much, or has as much to say about designing world class programs as Robert Martin. This book should be on every serious programmer's shelf; whatever language you happen to be programming in.
Excellent book on principled software development.......2005-01-26
If you always wondered how to find the "right" abstractions - which are nowadays called objects - in your programming. This book gives you an idea what the guiding principles should be.
Don't expect it to be a silver bullet. It is neither the best book on agile software development practices nor the best book on design patterns, but it is the best book on sound principles behind software development. So I believe that some of the content will still be valid in the post OOD-world, whatever it is going to be.
So if you ever wondered, why sometimes programms look good, and most of the times they are just outright ugly, this book gives you a couple of pointers where to look for the problems.
Two more things: a) it is actually fun to read, b) from my experience in project management and software development I don't believe the radical XP approach will establish itself - it doesn't give managers the feeling they are in control. Not that they are with the classic waterfall, but they think they do. Some practices such as pair programming and test-driven development will become best practices - or are they already? The rest will probably be dropped once the fad is over.
Average customer rating:
Most Useful for People engaged in Post Imp Environments
Your class library works, but could it be better? Refactoring: Improving the Design of Existing Code shows how refactoring can make object-oriented code simpler and easier to maintain. Today refactoring requires considerable design know-how, but once tools become available, all programmers should be able to improve their code using refactoring techniques.
Besides an introduction to refactoring, this handbook provides a catalog of dozens of tips for improving code. The best thing about Refactoring is its remarkably clear presentation, along with excellent nuts-and-bolts advice, from object expert Martin Fowler. The author is also an authority on software patterns and UML, and this experience helps make this a better book, one that should be immediately accessible to any intermediate or advanced object-oriented developer. (Just like patterns, each refactoring tip is presented with a simple name, a "motivation," and examples using Java and UML.)
Early chapters stress the importance of testing in successful refactoring. (When you improve code, you have to test to verify that it still works.) After the discussion on how to detect the "smell" of bad code, readers get to the heart of the book, its catalog of over 70 "refactorings"--tips for better and simpler class design. Each tip is illustrated with "before" and "after" code, along with an explanation. Later chapters provide a quick look at refactoring research.
Like software patterns, refactoring may be an idea whose time has come. This groundbreaking title will surely help bring refactoring to the programming mainstream. With its clear advice on a hot new topic, Refactoring is sure to be essential reading for anyone who writes or maintains object-oriented software. --Richard Dragan
Topics Covered: Refactoring, improving software code, redesign, design tips, patterns, unit testing, refactoring research, and tools.
Book Description
As the application of object technology-particularly the Java programming language-has become commonplace, a new problem has emerged to confront the software development community. Significant numbers of poorly designed programs have been created by less-experienced developers, resulting in applications that are inefficient and hard to maintain and extend. Increasingly, software system professionals are discovering just how difficult it is to work with these inherited, "non-optimal" applications. For several years, expert-level object programmers have employed a growing collection of techniques to improve the structural integrity and performance of such existing software programs. Referred to as "refactoring," these practices have remained in the domain of experts because no attempt has been made to transcribe the lore into a form that all developers could use. . .until now. In Refactoring: Improving the Design of Existing Software, renowned object technology mentor Martin Fowler breaks new ground, demystifying these master practices and demonstrating how software practitioners can realize the significant benefits of this new process.
With proper training a skilled system designer can take a bad design and rework it into well-designed, robust code. In this book, Martin Fowler shows you where opportunities for refactoring typically can be found, and how to go about reworking a bad design into a good one. Each refactoring step is simple-seemingly too simple to be worth doing. Refactoring may involve moving a field from one class to another, or pulling some code out of a method to turn it into its own method, or even pushing some code up or down a hierarchy. While these individual steps may seem elementary, the cumulative effect of such small changes can radically improve the design. Refactoring is a proven way to prevent software decay.
In addition to discussing the various techniques of refactoring, the author provides a detailed catalog of more than seventy proven refactorings with helpful pointers that teach you when to apply them; step-by-step instructions for applying each refactoring; and an example illustrating how the refactoring works. The illustrative examples are written in Java, but the ideas are applicable to any object-oriented programming language.
Customer Reviews:
Most Useful for People engaged in Post Imp Environments.......2007-04-26
This is the most practical book for people involved in Post release / production support projects still reporting bugs and in dire need of refactoring. Project with bad Code albeit working code are toughest to refactor, even peers are scared to touch anything which has been working. Martin Fowler's insight gives all that there is to know about refactoring. Thanks Martin for your insights. Keep up the good work.
Anirudh Vyas
By far the best Tech book I have purchased.......2007-04-05
This is one of the best books that sit in my office desk. I really enjoyed reading this book & implementing lot of the refactorings.
Good ideas, bad book.......2007-02-26
Fowler's book is has a lot of very good ideas, but it is poorly written, hard to follow, and incredibly disorganized. I think it would have benefited immensely from the services of a good editor.
My two major complaints: First, Fowler tries so hard to be clever and witty that at times his point is completely lost in his misguided attempts at humor. Second, he constantly refers ahead to material not yet covered, so that it's impossible to understand Chapter N without already having read Chapter N+1, which of course presupposes that you have read and understood Chapter N.
If you are going to read this book (and I concede that you probably should) then you should at the same time buy a copy of Joshua Kerievsky's "Refactoring to Patterns." Kerievsky brings far more organization and explanation to the subject than does Fowler. Read Kerievsky first, and refer to Fowler when he directs you there (which he very frequently does). But don't try to read Fowler by himself.
Great Book! .......2007-02-19
I am working on an a C# agile project for the first time. The word "Refactoring" comes up a lot. This book will provide the true meaning of what refactoring is all about! Great examples will show you when and how to refactor your code. There is a handy list of Refactoring rules or guidleines that will tell you what page in the book to go to to learn about that type of refactoring technique. Make sure you put your name on the book because your co-workers will try to take it!
One of the few truly MUST HAVE books.......2007-02-17
Refactoring: Improving the Design of Existing Code is one of those amazing books that every professional developer should have on their book shelf. The bulk of this book is a catalog of refactorings, but there is more to it as I will explain below.
In case you aren't aware of what refactoring is, I'll give you Fowlers definition.
"Refactoring is the process of changing a software system in such a way that it does not alter the external behavior of the code yet improves its internal structure." For the most part this means cleaning up your existing - yet working - code. It involves anything from renaming a method to be more concise with the purpose of that method, to breaking up switch statements into a polymorphic structure. There are many different techniques used to refactor your code, which is what you learn in this book.
Right off the bat Fowler throws you into a small sample application that is poorly designed. He then takes you through a few different refactoring techniques that improve the design of this simple application. Right from the start you see how effective refactoring can be. From there he goes into topics such as how to detect "bad smells" in code. This chapter is particularly informative and entertaining. You also learn a little bit about testing. After the introductory chapters you begin to dig into a deep catalog of refactorings. Each one is named. Like design patterns - naming the refactoring and building a vocabulary really helps in communicating thoughts and ideas.
The catalog of refactorings is extremely useful. They are structured so that each refactoring has a name, a motivation, the mechanics and a simple example. This is very effective. As I said earlier, the name is useful because it helps build your programming vocabulary and it helps in communicating thoughts and ideas. The motivation explains why the refactoring should be done and when it should/shouldn't be used. The mechanics provide a step-by-step description of how to carry out the refactoring and the example shows a small example of the refactoring in use. All examples are written in Java 1.1.
Although the examples are written in Java the book is still very good for any developer. Developers that have never written a line of code in Java, C++, C#, or anything similar may have a little bit of a tougher time working through this book. Luckily most examples are very small and simple so even if you fall into this category you shouldn't have too much of a learning curve. Some of the code is a bit outdated and can be done a bit better now-a-days but what do you expect? This book was written 8+ years ago! Times have changed. The ideas are still very relevant though, which is what makes this book so timeless.
Martin Fowler books are always a joy to read. His writing style is humorous, yet often very blunt and to the point. Just like UML Distilled, he is able to communicate a lot of ideas into a very short amount of space - the book is a bit dense in other words, which is very good in my opinion. Martin Fowler does not beat around the bush and he has very strong opinions on certain topics. Unlike a lot of books you read, he actually writes with personality. I have a hard time putting his books down. Here is an example of the type of verbiage he uses...
On how comments can be a "bad smell":
"Don't worry; we aren't saying that people shouldn't write comments. In our olfactory analogy, comments aren't a bad smell; indeed they are a sweet smell. The reason we mention comments here is that comments often are used as a deodorant." - Martin Fowler. Here he is talking about how people use comments to hide bad code, or "bad smells".
I highly recommend this book. If you are a professional developer or plan on becoming one then click the "Buy Now" button without second thought. This is one of those rare books worth its weight in gold - I would spend $100.00 on a book like this if I had to.
Rockford Lhotka started writing his Business Objects books in 1996, and over the years, he's become one of the world's foremost authorities on building distributed object-oriented systems. His industry-standard VB .NET Business Objects book not only addresses changes in .NET 2.0 and Visual Studio 2005, but also reflects substantial enhancements and improvements to the CSLA .NET Framework and how it can be used to create enterprise-level .NET applications.
Expert C# Business Objects is for developers who want to see Lhotka's ideas applied in the C# idiom. The book takes you from an opening discussion of logical architectures to detailed n-tier deployment options using the CSLA .NET Framework.
The depth of Rockford's thinking now influences developers across language boundaries. With this book, you can learn directly from the expert whose framework has become universally accepted and respected.
Download Description
This book is a translation of Lhotka's industry-standard title, Visual Basic.NET Business Objects, into the language of C#. Rockford Lhotka's ideas continue to be extremely influential in all programmer circles of any language, but most naturally it will be C# developers over the next couple of years at least who will most likely be involved in the kinds of programming projects and architectures that Lhotka discusses. This book will benefit you! Therefore, while the VB.NET book proves its punch, the new C# version will find a more natural audience than the VB version. C# Business Objects will show C# developers the kinds of opportunities that .NET makes available. It will allow them to make clear, informed decisions about the right way to develop their enterprise C# projects, and show them how the trade-off between performance and flexibility can be made successfully. This book contains the author's Component-based, Scalable, Logical Architecture (CSLA .NET), an object-oriented framework that can act as the foundation for a diverse range of enterprise applications, and which readers are free to examine, use, and modify.
Customer Reviews:
Nice work.......2007-08-25
A good written book, it's a step by step trip in the author's mind: from idea through design to coding of his framework. You may not agree with all choices (such as heavy reflection use) but you always know why he did. A good start point to build your own businnes objects and a rich bag for your developer's toolbox.
Somehow outdated.......2007-06-13
The book itself is somehow disappointing. Sounds like the old vb6 bo book, rather outdated.
The main concept involved as a guideline on design is the fat table module object arbitrarily called business objects by the author, when the market is more oriented to model domains. Why should we choose fat objects instead of other solutions? It is not discussed on the book.
A big issue is the way the book is written. He assumes you are a vb6 person. The author is not fully aware of the asp.net architecture. Look at this paragraph about keeping state on the page:
"There's no automatic
mechanism that puts all state data into each page; you must do that by hand. Often this means creating
hidden fields on each page in which you can store state data that's required, but which the user
shouldn't see. The pages can quickly become very complex as you add these extra fields.
This can also be a security problem. When state data is sent to the client, that data becomes
potentially available to the end user."
So he's completely unaware of viewstate object which address all these issues. I think asp.net has gone a long way now and this guy don't even know one of the basic revolutionary concepts brought up by as.net.
I have constantly the sensation that he is addressing a vb6 developer, but vb6 is long gone.
Very frustrating.......2007-03-26
Author spends too much time in theory and less time showing real examples. Author wants you to down load code and spends time discussing bits and pieces of each section. Very, very, very steep learning curve. Not a good investment - wish I could find a CSLA book that teaches you step by step....
GOOD INFORMATION, ARCHITECTURE SO/SO.......2007-02-14
This book has a very good discussion of frameworks and includes the details of the CSLA (Component Scalable Logical Architecture) framework. However, I don't believe the book is worthwhile for the discussion of frameworks alone. If you're required to use CSLA, then this is the book for you.
I give the book three stars because its contents can't be separated from the design of CSLA. The problem with CSLA is the layers. The use of "fat", fully encapsulated business objects has fallen out of favor recently and is not the best architecture for enterprise applications. Despite what the author says, I don't believe CSLA is truly a layered architecture, either.
The book lacks a discussion of when CSLA is a good choice and when another architecture is better. Choosing to use CSLA pre-determines your architecture (the "A" stands for "Architecture", after all). You should always choose your architecture based on your requirements and never select an architecture in advance.
That said, CSLA can be a good architecture for smaller projects. New developers often have issues understanding true multi-tiered architectures. Because CSLA uses an encapsulated architecture that's similar to the OOP training they had in school, those developers may find CSLA a good choice because it's easier for them to understand.
The best of the best.......2007-01-11
This is an exceptional book. It provides both the examples of how-to use the framework and how it is built. This internal view of the framework provides invaluable insight into the internal workings of reflection and gives real world perspectives to using objects consistently in a distributed architechture. I like the book!
Average customer rating:
Excellent!!!!
Good book
Excellent C# 2.0 Resource
Vital reference for solving problems and learning C#
The O'Reilly Cookbook series, with its to-the-point but illuminating coverage of programming subjects, meets the challenge of explaining how to write software as well as anything else on the market. When you're facing a coding problem--particularly in a language you're new to or haven't used in a while--and know there must be a proven way to solve it, the right Cookbook can often get you going in a hurry. C# Cookbook applies the formula to the language of Microsoft .NET, and is an addition to the line that more than a few programmers will appreciate.
Don't count on this book to solve big tasks for you. "I need some C# software that integrates with Avaya telephone switches and Siemens databases...:" No. Rather, this book shows you how to do the little jobs (converting an array to a delimited string, monitoring the event log, creating a bounded hashtable, and so on) that can stand in the way of prompt completion of a project. What's more, the coverage isn't limited to code samples. Stephen Teilhet and Jay Hilyard take advantage of the Cookbook series' Problem-Solution-Discussion format to teach you a thing or two about C#. You'll refer to this book often for quick answers and explanations. --David Wall
Topics covered: How to solve small but non-trivial problems in the C# programming language. Each of 17 chapters covers a major area of C# functionality--networking, regular expressions, filesystem, security, and so on--and contains a dozen or two entries on how best to solve programming problems.
Book Description
With C# Cookbook, 2nd Edition, you'll be able to learn and improve your mastery of both the C# language and the .NET platform. This updated bestseller has been completely revised to account for C# 2.0, the latest version of this popular object-oriented programming language. It also includes more than 100 new code solutions (over 300 overall) to common problems and tasks that you're sure to face as a C# programmer.
Nearly every solution, or "recipe," contains a complete, documented code sample showing you how to solve the specific problem, as well as a detailed discussion of how and why the underling technology works. This question-solution-discussion format is a proven teaching method, as any fan of O'Reilly's "Cookbook" series can attest to. In fact, no other source offers a learn-as-you-go format quite like this.
C# Cookbook, 2nd Edition is organized into 20 chapters, each of which focuses on a particular topic in creating C# solutions. Here are just some of what's covered:
Numeric data types
Strings and characters
Classes and structures
Generics
Exception handling
Delegates, events, and anonymous methods
Filesystem interactions
Web site access
XML usage (including XPath and XSLT)
Networking
Threading
Unsafe code
Best of all, you don't have to be an experienced C# or .NET developer to use C# Cookbook, 2nd Edition. You just have to be someone who wants to solve a problem now, without having to learn all the related theory first.
Customer Reviews:
Excellent!!!!.......2007-09-05
If you are just coming into C# or have been doing it for a while - it doesn't matter - BUY THIS BOOK!!! Oreilly as we all know, makes very good tech/programming books and this one is one of the best I've had so far. This will be a book that will spend much less time on my shelf and much more time next to me on my desk.
Good book.......2007-08-10
Being an advanced programmer I was looking for books to use as references or to further my skills. This book has proven a valuable asset.
Excellent C# 2.0 Resource.......2007-07-12
The C# Cookbook, Second Edition has been updated and revised for C# 2.0 and version 2.0 of the .NET framework, and despite the fact that version 3.5 of the .NET framework is imminent, it remains a must have book to have on hand. It is essentially a collection of examples showing how to solve specific programming problems (some of which you might not have even realised you have, such as boxing/unboxing and efficient string handling, to name just a few...)
The C# Cookbook has over 1100 pages and is arranged into 20 chapters, each of which focuses on a particular area in C#. Despite its size it is not daunting to read. Here are the topics covered:
1. Numbers and Enumerations
2. Strings and Characters
3. Classes & Structures
4. Generics
5. Collections
6. Iterators and Partial Types
7. Exception Handling
8. Diagnostics
9. Delegates, Events and Anonymous methods
10. Regular Expressions
11. Data Structures and Algorithms
12. Filesystem I/O
13. Reflection
14. Web
15. XML
16. Networking
17. Security
18. Threading and Synchronisation
19. Unsafe Code
20. Toolbox
This book is in O'Reilly's `cookbook' series Problem-Solution-Discussion format, and like other books in the series can either be read from cover to cover, or be used as a reference to shed light on a particular problem. Each `recipe' starts with a description of the problem, followed by a complete, documented code sample showing you how to solve it, along with a detailed discussion of how and why it works, and any drawbacks. This format can also serve as an excellent way of mastering aspects of C#.
Like the other O'Reilly cookbooks, this book manages to strike a perfect balance between reference and instruction on real problems developers encounter every day. Hats off to Jay and Stephen for creating such a useful resource.
If you are a developer who writes C# code for a living, I would be surprised if you do not find something useful the first time you pick this book up. If you are thinking of buying just one book on C# 2.0, make it this one. Highly recommended for beginners and experts alike.
[...]
Vital reference for solving problems and learning C#.......2007-04-14
Another book that's great as the occasional reference. This is another huge tome and it's chock full of topics from generics to security to XML.
Each topic is a recipe in a Problem/Solution/Discussion/See Also format. The solution is a snippet or set of snippets to solve the specific problem and the discussion is s walkthrough of the ins and outs of both the problem and how the solution fits the bill. Occasionally there's a good discussion of the pros and cons of solutions.
This isn't a book for reading cover to cover, but there's a lot to be learned browsing through the recipes, and you're sure to get answers on a wide range of topics including solid use of generics, exception handling, I/O, web bits, and networking. The chapters on security and reflection are particularly useful because they offer up good insights on approaching secure coding correctly and good techniques for dealing with reflection.
Highly Useful.......2007-02-19
This is exactly the sort of book one needs when beginning a new programming language, and still useful later. It is a large comprehensive set of examples.
should be called "Design Explained".......2007-07-14
This book is great. It goes way beyond patterns. It starts with what design patterns are and the main principles behind them (coupling, cohesion, testability, ...). It does this in an interesting manner. We first solve a problem in the way we most likely would. The book then takes us through patterns and shows us a couple of better solutions using patterns and other techniques discussed in the book that are consistent with patterns.
The book also discusses the motivations of the GoF patterns - they manage variation in our problem domain. Variations in our problem domain (i.e., changes) is what makes our life as programmers difficult.
Then the killer- the authors talk about two techniques they use (one in analysis - the analysis matrix; and one in design - commonality - variability analysis) which are awesome. These techniques go way beyond patterns but relate to patterns which is why I guess they are in this book and not in a general design book (which is where they could very well be).
What's also interesting is throughout the book they talk about how patterns relate to eXtreme Programming which gives insights into both.
A must buy!
Recommended for anyone new to patterns.......2007-01-18
Although usable as a reference, this book has immense value to anyone new to patterns willing to give a cover to cover read. This book is a great complement to the original Gang Of Four book (which is in need of some touching up). The authors try to offer some insight into places where GOF was lacking. The sections on modular decomposition and principles of applying patterns provide a gateway into the world of effectively applying patterns in your projects.
Finally, I appreciate the authors' use of a uniform case study throughout the book to solidify the intent of a pattern through useful application.
Best introduction to patterns by far!!.......2006-11-27
Whilst the 'GoF Book'(Design Patterns: Elements of Reusable Object-Oriented Software) is the bible of patterns, this is undoubtably the Magna Carta of patterns. It should rather be called 'Design Patterns for mere mortals'.
I found this book a true pleasure to read, and recommend it above the original GOF book. It really makes patterns incredibly easy to understand and apply in the right context, instead of just blindly using them because they are the next cool thing in Software Engineering.
Whilst the 'GoF book' is still a vital book, it is more of reference than something that should be read cover-to-cover. Buy this book first, and then get the 'GoF Book', once you have read this book.
A valuable resource for developers and architects.......2006-09-28
For any developer or architect, this book is a great reference guide for strong object-oriented programming design. The solutions described in this book are applicable for numerous business problems today, as they should be leveraged in enterprise applications.
I read this book with no design pattern knowledge, but any developer who has strong OO skills should be able to pick the concepts up quickly.
describes a few key patterns for beginners .......2006-09-20
Design patterns are a key concept for much of programming design. Here, Shalloway focuses on when you want to implement object oriented code. Many useful design patterns are given. Including such well known ones as the Strategy Pattern and the Bridge Pattern. Typically, each explained pattern gets a chapter of its own. To provide a detailed walkthrough. Handy if you're still new to the overall concept of patterns. This does mean that there really aren't that many patterns covered in depth. Less than 20. But these are the main ones for beginners to appreciate and use.
There are more advanced books that describe a fuller list of patterns. These can be deferred for many readers.
Simply the best treatment of object oriented design, patterns and practices I have ever read. Extremely well organized and easy to read. Should be in every software engineer's library.
Well done, with one exception.......2007-04-19
First, this book is well written and presents information in a constructive manner. It is well thought out, and is not just another C#/OOP/XP book.
Now for the bad news. One unnecessary oversight is the use of casts and "object" in some examples. Any author writing any C# book since 2005 must know that these idioms should no longer be encouraged. It is unacceptable for a book published in February 2007 to possess this flaw.
Generics, used in moderation, result in cleaner code that is also type-safe, and usually performs better due to the absence of boxing/unboxing. The authors should consider posting alternative examples that favor Generic types and collections on their errata web page. If you purchase this book, you would be well-advised to review the examples with a bias against the use of casts and the word "object".
To be entirely frank, I don't see how other reviewers can justify a five star rating.
Great title for OOP and Agile Methods.......2007-01-16
This book teaches both OOP and agile methods. The two are independent! The authors provide a brief introduction to UML as well. Some prior knowledge of fundamental OOP concepts such as inheritance and polymorphism are assumed. This is not a critical analysis of Agile or OOP. The book does not explain how agile methods can scale. That may be deficiency of agile methods. The book is blunt about Use Case Diagrams: useless (pardon the pun); with which I cannot agree more.
Except for one twenty-person project I worked on, I would advocate Agile for all the smaller projects I have done in recent years. I would highly recommend the book for all C# developers. Java developers would be better of with the previous Java version of the book.
Critical work on design and development.......2006-12-13
This book is amazingly great from start to finish. All the basics of good agile development are covered clearly and sensibly in the first section: what agile is, how to go about it, why testing and planning are so critical, and where refactoring fits in all of this. Design and general patters are hit in the second section, again in a clear, concise, and sensible fashion -- and with common sense thrown in.
The final two sections cover a real-world case study implementation of a payroll system. Here the rubber meets the asphalt: walking through use cases, building transactions based on smartly-chosen patterns, discussion of what patterns make sense where and why, implementation, packaging, and evolution.
I found myself shaking my head in wonder as I read this book and stumbled across one nugget of gold after another. Some bits of goodness pop out in the middle of nowhere simply because the authors are so well-versed in their domain that they're letting fly wisdom even when discussing other topics. An example of this is in the XP pairing session episode where some discussion of increment operator side effects is tossed in the middle of another discussion stream. You read that section once and pass over it, only to do a head check, bounce back and re-read it while nodding your head and saying "Yeah, that's absolutely right and I might not have caught that otherwise."
Another bit of greatness is the chapter on UML. The authors are emphatic about keeping UML tightly in check and using it only in specific cases where it makes clear sense. Mountains of UML diagrams are not the answer; the authors show where a few concise diagrams make perfect sense.
More goodness can be found throughout the book in the gems relating to any number of design issues such as a small example of a problem the authors put forth to students of their various design/patterns courses: build a coffee maker. The authors go through the most common result they see and show the specific problem areas of that solution -- and then show a solution that is amazing in its simplicity, elegance, and maintainability.
This book is a critical read for folks at any level of experience. I'm going to do my best to make sure it gets on the required reading list for developers at my company.
Absolutely required reading for every[...].......2006-11-22
Robert Martin is one of the smartest people I've ever talked with, and he is one of the best technical writers I've ever read.
This book is *the* most comprehensive and most valuable introduction and guide to Agile programming, with a full discussion of Agile principles, the "fourteen practices of eXtreme programming," full discussion of "spiking, splitting, velocity, iteration, test-driven development, refactoring, pair programming, five types of UML diagrams," and how to use all of this in real world .NET development.
There is no doubt in my mind that this book will make you a better programmer, will challenge you, will teach you, will take you beyond what you already know, and will entertain you along the way. Robert is as good as it gets.
This book is required reading. Do not hesitate.
Average customer rating:
no source code
A must read book for learning COM
Buy this book FIRST when you want to learn Microsoft's Common Object Model
[in, unique] IBindCtx *pbc
good COM book
Essential COM Don Box Manufacturer: Addison-Wesley Professional
ProductGroup: Book
Binding: Paperback
Computer Design
| Microprocessors & System Design
| Hardware
| Computers & Internet
| Subjects
| Books
COM & DCOM
| Networks, Protocols & APIs
| Networking
| Computers & Internet
| Subjects
| Books
General
| C
| Programming
| Computers & Internet
| Subjects
| Books
Object-Oriented Design
| Software Design, Testing & Engineering
| Programming
| Computers & Internet
| Subjects
| Books
COM, DCOM & ATL
| APIs & Operating Environments
| Programming
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
General
| Languages & Tools
| Programming
| Computers & Internet
| Subjects
| Books
Windows - General
| Operating Systems
| Microsoft
| Computers & Internet
| Subjects
| Books
General
| Operating Systems
| Computers & Internet
| Subjects
| Books
General
| Software
| Computers & Internet
| Subjects
| Books
Mathematics
| Professional Science
| Professional & Technical
| Subjects
| Books
| Applied
| Chaos & Systems
| Geometry & Topology
| Mathematical Analysis
| Mathematical Physics
| Number Systems
| Pure Mathematics
| Transformations
| Trigonometry
Look Inside Computer Books
| Trip
| Specialty Stores
| Books
All Titles
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Computers & Internet
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Professional
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Similar Items:
The Component Object Model (COM) is deep and extremely difficult, making it impossible to grasp the ideas behind this specification quickly or easily. Don Box, the author of Essential COM concedes that it took him six months of reading documentation, writing programs, and experiencing general puzzlement before he had his personal COM epiphany. Nonetheless, if you're a C++ programmer and you want your skills to continue to be relevant in a PC market dominated by Windows 95 and Windows NT, you need to get going down the path toward your own COM enlightenment. COM is the tool of choice for creating distributed and concurrent systems for modern Microsoft operating systems. If there's a book that will help you get a handle on the COM phenomenon, Essential COM is it.
Endorsed by object-orientation guru Grady Booch and Microsoft COM expert Charlie Kindel, Box's book takes the reader from an elucidating discussion of why a demand exists for COM and how it fits into the progression of C++ technology to a cool exhibition of some COM programs he's written. Along the way, Box covers the four corners of COM interfaces, classes, apartments, and security--all explained in developer's detail. He also gives attention to access control, marshaling, and Distributed COM (DCOM). Essential COM isn't an application programming interface (API) reference; it is an exploration of the Tao of COM. As the author says in his preface, you will figure out the how of COM programming quickly, as soon as you grasp the why.
Book Description
Written by a leading COM authority, this unique book reveals the essence of COM, helping developers to truly understand the why, not just the how, of COM. Understanding the motivation for the design of COM and its distributed aspects is critical for developers who wish to go beyond simplistic applications of COM and become truly effective COM programmers. As the COM programming model continues to evolve, such insight also becomes essential to remaining current with extensions, such as Microsoft Transaction Server and COM+. By showing you why Distributed COM works as it does, Don Box enables you to apply the model creatively and effectively to everyday programming problems.
This book examines COM from the perspective of a C++ developer, offering a familiar frame of reference to ease you into the topic. You will also find comprehensive coverage of the core concepts of Distributed COM (interfaces, classes, apartments, and applications), including detailed descriptions of COM theory, the C++ language mapping, COM IDL (Interface Definition Language), the remoting architecture, IUnknown, monikers, threads, marshalers, security, and more. In addition, the book offers a thorough explanation of COM's basic vocabulary, provides a complete Distributed COM application to illustrate programming techniques, and includes the author's tested library of COM utility code.
Customer Reviews:
no source code.......2007-07-27
I read Essential COM almost 10 years ago, and revisited it recently, out of curiosity. It's tough sledding, but if you *must* know this stuff, this is probably it.
However, throughout the book the phrase "the source code that accompanies this book" occurs repeatedly. As far as I could ascertain after an hour or so of googling and searching, there *is* no such source. I assume it stopped working 5 years ago or something, and rather than continuing to provide it somewhere on the web with a disclaimer -- which I assume would be embarrassing to Mr. Box -- it has been silently "disappeared". I consider this mildly unethical, and certainly annoying, since many perhaps minor points are supposedly demonstrated by this non-existent source.
A must read book for learning COM.......2007-06-16
I have learned a lot with this book. I would not qualify the book an introduction book because unless you have some background knowledge and practice, you are going to find the last chapters hard to digest. What the book does is to covers the essential principles of COM with great details. This will make the first reading very interesting and it will make you come back from time to time to seek back specific detail.
Buy this book FIRST when you want to learn Microsoft's Common Object Model.......2007-03-21
All vetran C++ programmers should learn this along side MFC, it assumes a minimal knowledge of COM so it is easy to pick up, and gets you familiar with the common elements of this widely used standard (CLSIDs, IIDs, COM Functions, etc) Shell programmers will want to read this first. See my other reviews for more good books in COM.
[in, unique] IBindCtx *pbc.......2007-01-12
The basic idea of COM as a binary standard that supports querying for supported interfaces and object lifetime through reference counting could hardly be simpler: five pages, End of book! So why does it turn out to be so complicated in practice? Evil enters in various ways and threatens to become overwhelming: the need to work efficiently with remote servers across a long wire, to implement effective security, handle various threading models (those wretched apartments!), marshaling (ugh!), proxies and stubs (yuck!), the need to just plain find things such as class ID's in the registry (another palpable evil), global interface tables, problems of COM identity, and so on and so on. Control of object lifetime through reference counting turns out to be a quagmire -- which references should be counted, external or internal or both, or does it just depend? Thanks to smart pointers retrofitted to legacy applications, aggregation, and the niceties of internal and external QI, it can be a nightmare to find and remove reference counting bugs. To top it all off, COM doesn't even accurately report reference counts -- only zero and nonzero can be trusted. Because of all this, no hard and fast rules for good COM programming can be given, just general guidelines that won't always apply.
What started out as simple and elegant gets twisted all out of shape. Nevertheless, although what we have now is truly disgusting, it either works or can be made to work, more or less. It's not Box's fault that modern software development has become a can of worms, and although it would be an interesting exercise to reexamine Windows, say, -- or Unix, or whatever -- from the ground up and rebuild it "optimally" with no regard for back-compatibility, no one is likely to do this.
Box starts out with a beautiful discussion, the best I have seen, of the underlying rationale behind COM. You can think
of Chapter One as COM before the Fall. The rest of the book deals with COM after the Fall -- that is, how COM is forced to deal with the actual world into which it was born through no fault of its own. He gives an advanced, top-down view of the subject. To understand the book you will need a solid grasp of multiple inheritance and of C++ in general and should have had some prior experience with COM, otherwise you'll find the more advanced topics unmotivated and undigestible. As with any nontrivial programming paradigm, if you already have the kind of first-hand experience that's been gained the hard way by running afoul of a variety of pitfalls, you will be ripe and ready for a treatment at the level of Box's book.
If you are not ready for this book there are other places to start, such as Grimes' book called DCOM Programming (Wrox Press). For instance, Box assumes the reader knows what marshaling does; he never explains what goes on inside the wire. The closest he comes is in the listing on p. 222 for the IRpcChannelBuffer, where the comment "payload goes here" appears after a void *Buffer. Yes! Yes! We want to see the payload! Grimes' book will fill these gaps. But Box is very strong on programming techniques and strategies that may save your butt in certain urgent, if limited, circumstances.
This is a book for advanced programmers that describes COM in the real world, probably as well as it can be described, warts and all. Given that programmers, not excluding the best ones, are known for their struggles with their native language ("so that the user can click *their* mouse on ..."), the excellence of the writing comes as a pleasant surprise. Probably the editors at Addison-Wesley did a really crack job cleaning up Box's manuscript and making everything shipshape. But conceivably Box was able to do this on his own, too. That would be really impressive given his superb job in organizing and explaining the technical material.
good COM book.......2006-11-08
If you have good understanding of C++ concepts and Windows programming, this is a great book for learning COM technology. Currently, I am on Chapter 3 and I liked the approach with which Don teaches you all the pieces of COM.
I really enjoyed reading the book, and I would recommend it to all serious software architects. The book discuss the practical aspects of OO techniques as they apply to real world applications. It goes beyond the "identify the words and nouns" approach of identifying objects and methods, into entities, value objects and aggregates. I also found the book to have a refreshing approach regarding XP methods, and the tight interdependence between modeling and design (and how each one feeds into the other in a closed loop).
Heavy on ideas, light on implementation.......2007-08-22
This book presents some interesting ideas for data modeling and lifecycle management, but does not provide enough implementation details to turn those ideas into reality. Many people are attempting to do so, and their ideas turn up in the dozens with a Google search, but no one seems to have figured out a real-world implementation yet. I may have given this 4 or 5 stars if I was convinced that the ideas were practical. I assume Evans has implemented his own ideas before, so I'm left wondering why he's not sharing the code.
In particular, the Repository and Aggregate patterns interests me, but there are many problems that arise when trying to implement a Repository that can handle saving and updating entire Aggregates while keeping the Entities isolated from the persistence mechanism. This is a topic for a tech blog, and in searching the 'net, plenty of them are discussing it. No one seems to have answered the implementation question, though.
The book is also a bit repetitive and verbose. I didn't find the sections on ubiquitous language very helpful. Engineers and non-engineers don't approach problems the same way, common language or not. I didn't feel that added much to the technical design discussions that followed.
If I ever figure out a practical implementation of the ideas, I may come back and give the book another star.
You must have one.......2007-06-21
This book was produced in 2004 but is already a classic. It is one of the most important books for people interested in object-oriented programming. Every programmer should read it.
Domain Driven Design.......2007-03-15
Domain Driven Design is about naming and assigning responsibilities to your classes according to the real concepts in the real world and let them collaborate with each other to fulfill certain task, like you and your coworkers doing everyday. If you grasp this, your system will be much fun to work with. I have read the book once and I completely agree with what the author said in his book.
If you think it is difficult to understand the book, probably you need some prerequisite, for example, read
<
Object-Oriented Design
| Software Design, Testing & Engineering
| Programming
| Computers & Internet
| Subjects
| Books
Refactoring: Improving the Design of Existing Code
Head First Design Patterns (Head First)
Code Complete, Second Edition
The Pragmatic Programmer: From Journeyman to Master
UML Distilled: A Brief Guide to the Standard Object Modeling Language (3rd Edition) (The Addison-Wesley Object Technology Series)
WOW!!!.......2007-09-13
Great book.......2007-08-05
Too old.......2003-04-03
Good ideas, bad book.......2007-02-26
GOOD INFORMATION, ARCHITECTURE SO/SO.......2007-02-14
