| Featured List | Simple List |
Go to bottom to see all images
Click image to enlarge
|
Business Modeling With UML:Business Patterns at Work by Magnus Penker, MagnusPenker, Hans-Erik Eriksson Average Customer Review:  Hardcover (January, 2000) list price: $65.00 -- our price: $55.53 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Editorial Review Until now, the Unified Modeling Language (UML) has been primarily used to design software, but should you use it to model your entire business as well? That's the intriguing argument of Business Modeling with UML, a text that combines leading-edge enhancements to UML with some solid thinking about business. Written for any manager with some technical background, this book looks at the possibilities of UML used to model entire organizations. The book makes a strong case for the advantages of modeling businesses in UML. With models, an organization can provide better software, define and implement new goals, and even decide whether to outsource certain operations. The Erickson-Penker Business Extensions for UML, invented by the authors and presented within the text, permit UML to document the entire business enterprise. This book shows how to model businesses, from business architecture to processes, business rules, and goals. Short case studies--for Web-centric and more traditional companies--are used to illustrate key concepts here. Later sections of the book will perhaps take a little more background in software engineering to appreciate fully as the book presents a handful of business patterns, which offer reusable solutions to common problems (just like software patterns). The authors also look at how to leverage a business model to create better software. In engineering, a new car is modeled and thoroughly tested on a computer before any physical prototype is ever built. As the authors point out, a business that has accurate models can test out new ideas cheaply and then adapt to changing market conditions quickly. This title makes a case that UML--a tool traditionally used by software developers--is ready to tackle the job. Read this notably informative and intelligent book to see the possible benefits of business modeling in UML for your organization. --Richard Dragan Topics covered: Business modeling basics, UML notation and Erickson-Penker Business Extensions, class diagrams and powertypes, object diagrams, statecharts, activity diagrams and swimlanes, sequence and collaboration diagrams, collaboration and use case diagrams, component and deployment diagrams, stereotypes, business architectures, business processes, resources, goals, business rules, Object Constraint Language (OCL) and collections, business views and patterns, business goal allocation, business goal decomposition, business goal-problem, and software architectures ... Read more Reviews (12)
The examples are too simplistic and the suggested modeling diagrams are far too cluterred for a business personel to understand.(Cluttered diagrams on a simple example) The book would be better if it had a growing case study and used real world examples and diagrams.
The book covers five quite distinct topics: Each of these is quite detailed. In particular, the book contains probably the best introduction to the Object Constraint Language (OCL), and its use to model business rules, that I have read anywhere. The sections on how to do business modelling are also very good, as are the introductions to the relevant UML techniques. The "Eriksson-Penker extensions for business modelling" are important because several UML-based case tools have now implemented them as an emerging standard for business process modelling with UML. If you want to fully understand how these work, this is the book to read. The business patterns are more of a "curates egg". Some are extremely useful, and others innovative which could easily solve your problems where there is an accurate match. That said, some are less good and seem to state the obvious, although with patterns it is always difficult to know if you are judging some harshly simply because you are so familiar with them and other readers will get more value. Some of the pattern explanations are a bit repetitive, and the "examples" often sound very artificial, but overall they are useful, and a single one which solves a real business modelling problem for you will justify the rest. At over 400 pages, some of which is occasionally slightly slow and ponderous this is not an ideal book to read from cover to cover. But it is definitely one to study, focusing on whichever topic is most relevant to you at any time, and I can happily recommend it.
Processes are generally modeled using UML activity diagrams.A "process" is shown as an Activity stereotyped as < One thing that is bothering me about the process diagrams it that they do not show object collaboration very well.I think that the contractual message passing between objects needs to be shown with informational interface objects rather than parameter lists.I'm withholding judgement at this point.After all, the business models they are describing will never be translated into code, but rather business forms and process documentation and executed by people and not computers.They do however, give a method for creating software system models for automating part of the business system. All mistakes, misconceptions and missuse of terminolgy in the above description of Eriksson and Penker's book are my own. Adios, Isbn: 0471295515 |
$55.53 |
Not particularly useful
Excellent ideas, excellent read!
|
Analysis Patterns : Reusable Object Models (Addison-Wesley Object Technology: Addison-Wesley Object Technology Series) by Martin Fowler Average Customer Review:  Hardcover (09 October, 1996) list price: $54.99 -- our price: $43.14 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Editorial Review Patterns are higher-order designs that can be reused across projects and types of computer systems. Analysis Patterns: Reusable Object Models defines over 70 patterns, beginning with some from the business world, such as the Party and Accountability patterns, which define the players in organizations and whom they report to. Many of the other patterns are drawn from the health care industry and mainly show patterns of doctor-patient interactions. The patterns for financial markets will probably be accessible for the majority of readers. Author Martin Fowler defines a Transaction pattern (and related patterns) as well as several patterns for the Accounting of Objects. He moves on to modeling stock markets with Portfolio, Quote, and Scenario patterns, which define how a price for a stock is determined for a given moment. Interestingly, he establishes patterns for Forward Contracts (for derivatives) as well as Options, and so takes on a complicated area in today's financial markets. Fowler's considerable design experience in these fields is beneficial, as he is able to define each pattern in both text and software engineering diagrams. Only rarely does the author provide implementations of these designs and those that are furnished are done in Smalltalk, which makes this book more suitable for those who have experience in object design. ... Read more Reviews (14)
The first problem Fowler broaches is a patient's weight and he states, correctly I'm sure, that most programmers would just make weight a class property and make it be of type integer. But there are problems with that approach. First one is the issue of units. If you make it an int you are assuming that it is just a count of pounds. What happens if you want another measure? Furthermore, what happens when someone asks where the patient's weight has gone in the last month. From this point of departure, many issues are taken up. For people who have grappled with OLAP before and know something about dimensional models, it will seem as though he is trying to make an operational into an analytical model, which experience has taught us is not good. But, in fact, there is sanity to Fowler's approach. Personally, if he ever does rev this book (read on his site that he is thinking about it), I wish he would consider writing a section that attempts to hide the observation elements and seamlessly map them back into the object model. Having a separate class keeping track of what the weight of a person represented by another class is does ultimately seem to undo the objectness of the model, but that's a minor nit. Definitely a book that I've returned to many times.
As two readings of Design Patterns took my OO knowledge from infancy to adolecence, Analysis Patterns will take you from adolecence to adulthood. Fowler's work does not put together patterns from the Design Patterns book, but takes its time to decompose actual application domain concepts to applicable object models. It will then be up to you to use your knowledge from Design Patterns to create mechanisms that support properly modeled business concepts as Analysis Patterns describes. If you like OO modeling and design, but are wondering how better to apply your modeling concepts, Fowler's book is something you will definitely benefit from. However, make a pot of coffee per chapter-this book is very dense with concepts. Fowler ends Analysis Patterns with some more easily read chapters on application design on a larger scale. You've heard of "n-tier," his discussion of the concepts of "n-tier" at the end of the book are possibly worth reading first. After reading this book-and understanding it's motivations-you will never again be tempted to take "innocent" shortcuts in your application design. You will not be motivated to use "Strings" for "measurements" or "doubles" for "distances." You will look upon your peer's object designs either with a new understanding that they know that going the distance with their object model is worth it-and you won't demand they dumb down their design ever again-and you'll likewise gain intuition about where a simplistic business domain model is going to fail. ... Read more Isbn: 0201895420 |
$43.14 |
|
Pattern-Oriented Software Architecture, Volume 1: A System of Patterns by FrankBuschmann, RegineMeunier, HansRohnert, PeterSommerlad, MichaelStal, Peter Sommerlad, Michael Stal Average Customer Review: Hardcover (08 August, 1996) list price: $75.00 -- our price: $59.96 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Editorial Review Pattern-Oriented Software Architecture: A System of Patterns looks at how patterns occur on three different levels--in software architecture, in everyday design, and in idioms (which describe how a particular design pattern is implemented in a programming language like C++). This synthetic approach is a little theoretical at times, but the authors also present over a dozen patterns and provide real-world examples wherever possible. For architectural patterns, the authors look at the Layers pattern, used in operating systems such as Windows NT and virtual machines. They also consider Pipes and Filters, which process streams of data. (This pattern, the authors point out, is a lynchpin of Unix.) Their Blackboard pattern shows how a complex problem, such as image or speech recognition can be broken up into smaller, specialized subsystems that work together to solve a problem. (For recognizing words from a raw waveform input, a Blackboard approach might have separate processes to find phonemes, then words, then sentences.) This book also looks at today's distributed systems in considering the Broker pattern, which is used on the Internet and in Microsoft's OLE technology.This section also presents several powerful patterns for building effective graphical user interfaces, such as Model-View-Controller. The authors define several well-known design patterns, such as the Proxy and Command patterns, and also basic, far-reaching patterns, such as Whole-Part and Master-Slave, which are widely used throughout computing. Their survey ends with a discussion on the way objects can communicate (using such patterns as Forwarder-Receiver, Client-Dispatcher-Server, and Publisher-Subscriber), which many developers will recognize as familiar patterns, but are codified here as "official" patterns. The book then discusses some idioms in C++ and a more far-reaching role for patterns in software design and architecture.By fitting patterns into traditional software engineering practices, the authors of Pattern-Oriented Software Architecture successfully argue that the role for patterns will only continue to diversify and enrich tomorrow's software engineering tools and methodologies. --Richard Dragan ... Read more Reviews (12)
Only chapter 2 really addresses patterns for the strategic, architectural level of a software system. It does a very adequate job, using a variety of notations, examples, and analysis steps. This book is from 1996, so time has changed our view of some patterns. "Reflection," for example, has become pervasive in applications based on plugins and software components. It is also a fundamental API in the major langauges (Java and C#) released since this book was published - perhaps reflection should be downgraded to an "idiom". That's just nitpicking, though, since reflection is even more important now than when the book was written. For contrast, the authors present additional design patterns (including some from Gamma's book) for use at tactical design levels. They also discuss idioms patterns that typically involve just a few lines of code within on function. The contrast between the three different levels of implementation and design gives a useful discussion. The authors also present a weak chapter on "systems" or "langauges" of patterns The discussion is OK as far as it goes. The weakness is in what it omits. After reading this brief chapter, the programmer has very little practical information about choosing patterns from some library for some task. The poor programmer has no information at all about how to link patterns together, and that's a real stumbling block for beginning pattern users. The final section of the book is really sociology. It's about the pattern community, what that community is for, and how to be a working member. I find the discussion un-helpful, but I expect opinions to differ. Even today, this is a good second book (after Gamma's 'Design Patterns') on patterns and pattern usage. It lack the depth and precision of Gamma's book, and tends to add words without adding meaning. On the positive side, it's broader than Gamma's, and addresses a wider range of implementation levels.
Check out Eric Newcomer's book on Web Services as a great companion.
Isbn: 0471958697 |
$59.96 |
|
Pattern-Oriented Software Architecture, Volume 2, Patterns for Concurrent and Networked Objects by DouglasSchmidt, MichaelStal, HansRohnert, FrankBuschmann Average Customer Review: Hardcover (14 September, 2000) list price: $70.00 -- our price: $55.30 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Reviews (19)
Isbn: 0471606952 |
$55.30 |
|
Design Patterns by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides Average Customer Review: Hardcover (15 January, 1995) list price: $54.99 -- our price: $47.04 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Editorial Review 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. ... Read more Reviews (187)
Isbn: 0201633612 |
$47.04 |
|
Design Patterns for Object-Oriented Software Development by Wolfgang Pree Average Customer Review:  Hardcover (01 August, 1994) list price: $49.99 US | Canada | United Kingdom | Germany | France Reviews (3)
Pree's whole concept of metapatterns seems to have been dropped from the literature. It's not that the ideas were bad, or even obscure. Quite the opposite, they were so pervasive that they mostly seem to represent language primitives. For example, creating a variable of type X and letting it reference an object of some X subtype is incredibly basic. Yes, it needs to be handled in introductory programming courses, and subtle cases can cause real confusion. On the whole, though, it's about like calling a "for" loop a meta-pattern. Still, some of the OO advice was sound, and still worthwhile today. For example, the "principle of testability" says that a module should be testable independently, without regard to its environment. The whole discussion of frameworks is interesting, but more recent writing is more informative. The book does discuss design patterns, as we generally use the term now. The DP literature has matured, though, and settled into a fairly predictable way of describing patterns. This book predates those descriptive conventions, so comes across as scattered or hard to read. I can't fault a book for being written at some particular time. Back in the 90s, I would probably have four stars, maybe more. Literature and common practice have moved on, though. This book's ideas have been developed, extended, and cast in modern terms by more recent writers. Other writings now present the same material, more clearly, and in more current terms. This book gives an interesting look at the debates and developments that were current back when it was written, but is no longer on, or even near, the wave of current practice.
Second, this book has little in it that is of practical use to the There are a few parts of the book that are harmless:the "hot
Isbn: 0201422948 |
|
Wannabe
|
Applying UML and Patterns by Craig Larman Average Customer Review: Hardcover (30 October, 1997) list price: $69.33 US | Canada | United Kingdom | Germany | France Editorial Review Written for the developer with previous programming and design experience, Applying UML and Patterns combines UML, software patterns, and Java to illustrate the author's own design strategy. Though author Craig Larman sometimes relies heavily on the jargon of software engineering, there's no doubt that his book contains some immediately useful ideas on software design, using the latest and greatest in software-engineering research. This book begins by outlining a basic process of software design using iterative, object-oriented techniques. The case study used for this text is a point-of-sale (POS) system, a helpful real-world example. The book constructs use case diagrams and basic conceptual and class models for this system. The author then adds sequence diagrams to show how the POS system will do its processing and collaboration diagrams to show how objects will interact with one another. The author uses standard UML diagrams to document the design. When it comes to refining class design, the author's experience with patterns really shines. His General Responsibility Assignment Software Patterns (GRASP) suggest guidelines for designing classes that work together effectively. Larman believes that the ability to assign responsibilities to classes effectively is one of the most important aspects of good object-oriented design. His patterns allow this to happen and provide an interesting contribution to the design process. (The author also introduces more widely used software patterns to enhance the design process.) When it comes to coding the design, Java is the programming language of choice for this text. Further chapters discuss how to refine an initial design using an iterative process of software engineering. While it's unlikely that readers will adopt Larman's approach to software design in its entirety, his guidelines--and application of patterns to class design, all documented using UML--make this a worthwhile text for the more experienced reader. --Richard Dragan ... Read more Reviews (63)
good grief...UML is simple enough to learn in 30 minutes Only Larner, Booch, or Fowler could expand the subject into many pages using padding. If you liked the book, you are one of:
It is an excellent primer on using UML and patterns in the context of an agile unified process, with examples in Java.Even as an experienced architect/developer, I found the book enlightening -- it's definitely not your standard "intro for dummies" book.Although I'm a big Fowler fan, I found its treatment of UML to be much more applicable (love the examples) than UML Distilled.It's also a great introduction to why and how to implement an agile process.A particular favorite of mine is its laundry list of things that indicate you AREN'T following an agile process, which should be a checklist for software development companies everywhere. I just wish I could give this book more stars! ... Read more Isbn: 0137488807 |
|
|
Refactoring: Improving the Design of Existing Code by Martin Fowler, Kent Beck, John Brant, William Opdyke, Don Roberts Average Customer Review: Hardcover (28 June, 1999) list price: $54.99 -- our price: $47.14 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Editorial Review 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. ... Read more Reviews (103)
Isbn: 0201485672 |
$47.14 |
|
AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis by William J.Brown, Raphael C.Malveau, Hays W. "Skip"McCormick, Thomas J.Mowbray Average Customer Review:  Hardcover (20 March, 1998) list price: $44.99 -- our price: $30.59 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Editorial Review If patterns are good ideas that can be re-applied to new situations, AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis looks at what goes wrong in software development, time and time again. This entertaining and often enlightening text defines what seasoned developers have long suspected: despite advances in software engineering, most software projects still fail to meet expectations--and about a third are cancelled altogether. The authors of AntiPatterns draw on extensive industry experience, their own and others, to help define what's wrong with software development today. They outline reasons why problem patterns develop (such as sloth, avarice, and greed) and proceed to outline several dozen patterns that can give you headaches or worse. Their deadliest hit list begins with the Blob, where one object does most of the work in a project, and Continuous Obsolescence, where technology changes so quickly that developers can't keep up. Some of the more entertaining antipatterns include the Poltergeist (where do-nothing classes add unnecessary overhead), the Boat Anchor (a white elephant piece of hardware or software bought at great cost) and the Golden Hammer (a single technology that is used for every conceivable programming problem). The authors then proceed to define antipatterns oriented toward management problems with software (including Death by Planning and Project Mismanagement, along with several miniature antipatterns, that help define why so many software projects are late and overbudget). The authors use several big vendors' technologies as examples of today's antipatterns.Luckily, they suggest ways to overcome antipatterns and improve software productivity in "refactored solutions" that can overcome some of these obstacles. However, this is a realistic book, a mix of "Dilbert" and software engineering. A clever antidote to getting too optimistic about software development, AntiPatterns should be required reading for any manager facing a large-scale development project. --Richard Dragan ... Read more Reviews (38)
So far, that trio hasn't been put together in a systematic way. This book is a fair first stab at the list of common offenders, though. It has an exploratory style - it distinguishes major and minor (mini) problems, while trying out different ways of expressing evils of different scales. It proposes a systematic way to diagnose each problem, identify causes, and overcome the problem that left the mess in the first place. This is all good, even if Brown et al. haven't left the study in its final form. This book may have lasting value, if only because it's the first to use the "patterns" methodology in studying what not to do. It's good for beginners who haven't seen the messes first-hand, and good for experienced developers who want to systematize their scars and war stories.
But the book...what can i say of the book? first of all, I found it quite boring and verbose. The same could have been sayed using half of the words or maybe less... In the book I've found a couple of annoying things: There are some good points on the book: Anyway, the point is: don't buy this book. You can get the same in the web for free, saving money and time
For those who want a good read on the IT profession as a whole, then I recommend it. If you enjoy Dilbert, you will enjoy this one as well. ... Read more Isbn: 0471197130 |
$30.59 |
|
Pattern Languages of Program Design (Pattern Languages of Program Design) by James O. Coplien, Douglas C. Schmidt Average Customer Review:  Paperback (02 May, 1995) list price: $44.99 -- our price: $40.09 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Editorial Review Pattern Languages of Program Design is the first of three volumes of groundbreaking research on patterns, ranging from smaller-scale design patterns to larger patterns useful for software architecture and process engineering.Early chapters look at frameworks and components for engineering solutions to particular types of problems at a higher level, such as looking at patterns as "tools and materials" that can be used to solve problems effectively.The guide also discusses how to use patterns with interpreters and client-server systems. Distributed processing is a difficult and exciting area of computing, and patterns presented in Pattern Languages of Program Design can help solve some of the problems of scalability, concurrency, and transaction management. These patterns include several business objects for managing transactions and accounts, as well as for optimizing queries across distributed systems. The middle section of this text applies patterns to the software engineering process itself and several papers (including one intriguingly called "Caterpillar's Fate") show how the pattern movement can benefit software engineers and managers. Further material looks at the process of defining and implementing patterns. (Discovering patterns is only a start; learning to reuse them effectively is another challenge.) Final chapters look at patterns that manage state and events for real-time and behavioral systems. Although the first installment of Pattern Language of Program Design offers a decidedly mixed bag of essays, it is particularly strong on distributed systems and provides a strong overview of some central thinking on pattern research, which is still relevant. --Richard Dragan ... Read more Reviews (2)
Anyway, this book has many good things in it. Anyone who is interested in Patterns should have the whole series of PLoP books.
Isbn: 0201607344 |
$40.09 |
|
Pattern Languages of Program Design 2 (Pattern Languages of Program Design) by John M. Vlissides, James O. Coplien, Norman L. Kerth, Norman Kerth, James] Coplien Average Customer Review: Paperback (14 June, 1996) list price: $42.95 -- our price: $38.07 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Editorial Review The second volume in the Pattern Languages of Program Design series offers plenty of hands-on design patterns, including examples drawn from C++ to illustrate pattern use in the real world. The book starts out with some useful programming tips (called idioms) in C++ and Smalltalk for managing memory efficiently and writing faster programs. Subsequent sections look at design patterns (perhaps the most immediately useful kind), including the Command Processor for executing commands, and the Observer Pattern for building efficient components. There's some extensive research on the Proxy pattern, which presents many extensions for a variety of network and distributed solutions. A variety of special-purpose patterns come next, offering expertise on how to organize multimedia applications and design backup redundancy into software. Further chapters in this book cover patterns and how they apply to the software-engineering process. A particular highlight is Frank Buschmann's treatment of reflection, which allows for highly customizable objects and an evaluation of a variety of patterns for managing software projects. Some of the most accessible and intriguing material are the discussions on patterns for use in the classroom, how to create effective demonstration software, and how to set up a Web site for archiving essays. The book closes with papers on concurrency and distributed systems, featuring several tried-and-true patterns for minimizing the difficulties inherent in large-scale systems and reactive systems (which must process events from users or other inputs in real-time). In all, this second compendium of pattern research has a good mix of the accessible and the arcane and is a worthwhile choice for your library. --Richard Dragan ... Read more Reviews (2)
Buy it just for Crossing Chasms, a comprehensive look at all the headaches you get when you try to marry relational databases to object systems.Or buy it just for Demo Prep, which will tell you how to achieve your goals with software demos - happy customers, happy programmers. Or maybe you need to read my article, Patterns for Classroom Education, which tells you how (and why) to design a course to teach computer programming - or any technical skill. ... Read more Isbn: 0201895277 |
$38.07 |
|
Pattern Languages of Program Design 3 by Robert C. Martin, Dirk Riehle, Frank Buschmann Average Customer Review: Paperback (07 October, 1997) list price: $41.95 -- our price: $36.30 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Editorial Review The third book in a series, Pattern Languages of Program Design 3 discusses how to catalog software patterns, which are reusable, higher-order designs. This volume presents over two dozen white papers on newly "discovered" patterns within a wide variety of contexts. The editors have grouped these patterns by topic so you can choose what interests you. Each pattern profile features a short introduction to show you what each pattern might be good for. "General purpose" design patterns include the Null Object, the Manager, and the Product Trader patterns, and another section improves on the Visitor pattern. These patterns allow classes to borrow the methods of other classes without using inheritance. Some of the most challenging patterns in this book are good for distributed processing, including Acceptor and Connector and Object Recovery. Basic research in object-oriented design (OOD) is apparent in the Serializer pattern, which implements persistence for objects, another unusually difficult aspect of object design to get right. Another useful section introduces "domain specific" patterns--or patterns that solve particular real-world problems--with several patterns for transportation systems and fire alarms. The book closes with more esoteric explorations of patterns for developers, including patterns for effectively designing in teams and using software testing patterns. Judging from the rich selection of the ordinary and the bizarre, there seems to be no end in sight for the business of discovering patterns. For those interested in expanding their collection of patterns, this volume offers a fascinating array of new specimens. ... Read more Reviews (2)
Isbn: 0201310112 |
$36.30 |
|
Pattern Languages of Program Design 4(Software Patterns Series) by Neil Harrison, Brian Foote, Hans Rohnert Average Customer Review: Paperback (17 December, 1999) list price: $42.95 US | Canada | United Kingdom | Germany | France Editorial Review Software patterns are reusable, higher-order designs that recur repeatedly across applications. Pattern Languages of Program Design 4 offers a wide variety of these forms from different areas of computing. Especially valuable to C++ or Java programmers, but useful to anyone who designs software for a living, this book is a worthy choice containing dozens of designs that you can incorporate into your own projects. Arranged in 23 chapters, each containing multiple patterns, the text contains well over 100 software setups on a wide variety of topics. Standout sections here include a compilation of C++ idioms by James Coplien, which are derived from his well-known Advanced C++ Programming Styles and Idioms, a book that helped inspire early pattern-makers. A chapter on managing limited memory provides tips for working with embedded systems on today's handheld devices. Those with a background in engineering will also appreciate the catalog of patterns for finite state machines (FSMs). Designers have the tendency to make patterns out of what is familiar to most everyone. Several chapters look at patterns used on Web sites (for example, navigation bars) and in wiring together multimedia content. The book also groups management patterns, some of which can be used for improving customer relations and managing software development. The last section, surely the most entertaining, is devoted to software management and describes why most code, over time, devolves into a "Big Ball of Mud." There is certainly a lot to take away for any designer who reads this book. It is a particularly rich collection of recently "discovered" patterns that will get you thinking about reusable design in your own software. --Richard Dragan Topics covered: Object-oriented software design patterns, C++ idioms, patterns for managing limited memory, patterns for Smalltalk prototyping, patterns for history and time, security patterns, report patterns, feature extraction patterns, finite state machine (FSM) patterns, patterns for Web sites and multimedia systems, patterns for reusable multimedia artifacts, patterns for telecommunications, patterns for choosing publishable papers for conferences, patterns from writers' workshops, customer interaction patterns, patterns for better software project management. ... Read more Reviews (1)
Isbn: 0201433044 |
|
|
A Pattern Approach to Interaction Design by Jan Borchers Average Customer Review: Hardcover (16 May, 2001) list price: $69.00 -- our price: $41.63 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Reviews (2)
I had hoped for a book dominated by a collection of patterns describing how users interact with technology, particularly computers. Instead the first 3/8 of the book is given over to an almost blow by blow account of each contribution to the development of patterns, their application to IT and finally to HCI. There is actually one important message, that patterns can aid communication not only between IT professionals, but also between professionals and users, as a way of describing both the problem domain and the proposed solution. However, this was almost buried in a detailed discussion of pattern format, which is much less important. I very nearly gave up reading at this point, which would have been a pity, since the central chapter of the book contains some interesting patterns, albeit of limited practical use. The "How to Play the Blues" pattern language is an entertaining demonstration of how to use patterns to describe a problem domain, while the patterns for interactive exhibits are a good set of HCI patterns, although focusing on the interaction of regular users with business computer software would be of more general practical use. I also really liked the pattern layout, relying on typography and styles rather than headings to standardise the structure, which definitely enhanced readability. Unfortunately the book does not sustain the interest, and after a single chapter on patterns returns to a strange and lengthy self-review, to the extent of reprinting the review comments the author received on a draft version. This is ridiculous. The book's malaise seems to be symptomatic of the whole discipline. The referenced web sites and books are not much better, with all but a few noble exceptions concentrating on academic discussions about patterns, rather than building a real pattern collection. I am convinced that patterns can be really useful in the area of human-computer interaction and user interface design, just as they have been in many other areas of IT. I also think the arguments about style and format will be won by the author of the first good book that concentrates on building a comprehensive and readable set of useful real-world HCI patterns. This isn't it.
Isbn: 0471498289 |
$41.63 |
|
Data Model Patterns: Conventions of Thought by David C. Hay Average Customer Review: Hardcover (01 November, 1995) list price: $39.95 -- our price: $39.95 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Reviews (16)
Since this book is based on ERM, it won't be ever a definitive reference.It may have other qualities. ... Read more Isbn: 0932633293 |
$39.95 |
|
Software Architecture in Practice by Len Bass, Paul Clements, Rick Kazman Average Customer Review: Hardcover (30 December, 1997) list price: $49.99 US | Canada | United Kingdom | Germany | France Reviews (18)
I particularly liked their presentation on the building blocks of an architecture as well as their discussion on tactics. My only criticism, and the students' as well, were the study cases.They threw too much at the reader about specific projects (some which were never completed).I think there should have been a better balance on the type of applications as well. I do plan on using this text again for my class next year. ... Read more Isbn: 0201199300 |
|
|
Design Patterns in Communication Software by Douglas C. Schmidt, Linda Rising, Donald G. Firesmith Average Customer Review: Hardcover (15 September, 2001) list price: $75.00 -- our price: $75.00 (price subject to change: see help) US | Canada | United Kingdom | Germany | France Reviews (3)
I will begin in that: If the book did not have the third part of The third paragraph is very good. You cannot miss a good article of Conclusion: Take the money and run.
Isbn: 0521790409 |
 |