What do you think?
Rate this book
Object-Oriented Software Engineering Using UML, Patterns, and Java: Pearson New International Edition
Title: Object-oriented Software Engineering Using UML, Patterns, an Binding: Paperback Author: Bernd Bruegge & Allen Dutoit Publisher: Pearson Higher Education
728 pages, Paperback
First published January 1, 2000
10 people are currently reading
216 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 6 of 6 reviews
August 24, 2012
Bruegge have assembled a comprehensive book on software engineering that covers most aspects of the lifecycle. Not all parts are equally good and some parts are slightly outdated. Overall a decent book that can service as basis for introducing software engineering and the complexity around large systems and organisations.
September 29, 2017
A book well worth considering as the supporting textbook for an introductory, undergraduate two-semester course on Software Engineering. Bruegge and Dutoit also claim it can be used for an introductory 16 week long course by covering the first three sections of each of its sixteen chapters. By omitting the chapter on rationale management and compacting the five chapters on design, it may be possible to squeeze it, with some reservations, into twelve weeks.
It is a tighter, more cohesive book than Ian Sommerville´s or Roger Pressman´s well known textbooks. It manages this cohesion by focusing on object-oriented software engineering, introducing Unified Modeling Language (UML) models very early on (chapter 2) and using them exhaustively thoughout the book, and by working on different facets of the same case study, the development of a game tournament framework in all chapters. The constant use of UML is in fact, the book´s greatest strength and, possibly its greatest weakness -its greatest strength because not only does it continually reinforce the use of UML but it provides a consistent definitory framework for such disparate topics as analysis, design, testing, configuration management and project management; its greatest weakness, because in order to model such topics its has had to adjust and introduce some non-standard terminology and skirt some real-life conceptual ambiguity. However, it also does its best to refer to IEEE standards whenever possible.
Taking into account that this is an introductory book, its best chapters are on analysis and design, particularly detailed design. Of course, if you want to delve more deeply into requirements elicitation and analysis, turn to Sommerville. As for design, there is little on software architecture (quite rightly in my opinion, given the introductory nature of the book) and object-oriented design patterns. The impedance problem beween object-oriented software and (relational) database management systems is touched upon and skirted around in a very practical way.
The chapter on testing is barely adequate for an introductory course and rather confusingly, rewords some key definitions, such as that of structural testing, several times, shifting their meaning as the authors attempt to distinguish between different categories of (overlapping) categories such as structural and system testing. It briefly introduces U2TP, a UML profile for testing, that does not add much value in such an introductory course, and does not even mention random testing techniques (for an excellent introduction to such techniques see John Regehr and Sean Bennet´s e-course on testing at https://www.udacity.com/course/cs258 ), while its section on automated testing focuses on JUnit, a unit testing tool, leaving out other important tools.
The chapter on configuration management is, as most general books on software engineering, long on definitions (and in this chapter is where the authors most rework terminology) and short on practice. It focuses exclusively on centralized configuration managers and thus needs to be updated as regards so-called third generation distributed configuration managers, such as Git. The key trade-off in configuration management practice between parallel work and merging complexity is not touched upon.
The most idiosyncratic chapter in the book is on Rationale Management, which I found interesting but which I do not consider mainstream enough for an introductory course. Rationale Management applies Knowledge Management techniques to software development, but, as the authors admit, maintaining this knowledge up to date in a changing system is heavy going. I would suggest the authors add a chapter on software maintenance and downgrade rationale management to a section in it.
Although Bruegge and Dutoit provide explanations of agile methodologies and show in their final two chapters how processes and methodologies can be put together, their textbook can be said to reflect a medium-weight software development process and represents an interesting and intelligent compromise.
It is very hard to write an introductory textbook on software engineering: there is simply too much material to cover. If you follow the classic development stages you will find that key practical topics like configuration management and testing tend to get pushed into the last part of the course and are skimped on. In this sense, Bruegge and Dutoit have made an interesting contribution to the literature by placing a general overview of process and methodologies at the end of the book -however, in spite of the fact that the changes between the third and second edition of the book focus on the chapters on testing, configuration management and project management, in my opinion, the first two are still not quite up to scratch. In short, this is an honest, intelligent, focused and cohesive book on object-oriented software engineering, well-worth basing introductory software engineering courses on.
It is a tighter, more cohesive book than Ian Sommerville´s or Roger Pressman´s well known textbooks. It manages this cohesion by focusing on object-oriented software engineering, introducing Unified Modeling Language (UML) models very early on (chapter 2) and using them exhaustively thoughout the book, and by working on different facets of the same case study, the development of a game tournament framework in all chapters. The constant use of UML is in fact, the book´s greatest strength and, possibly its greatest weakness -its greatest strength because not only does it continually reinforce the use of UML but it provides a consistent definitory framework for such disparate topics as analysis, design, testing, configuration management and project management; its greatest weakness, because in order to model such topics its has had to adjust and introduce some non-standard terminology and skirt some real-life conceptual ambiguity. However, it also does its best to refer to IEEE standards whenever possible.
Taking into account that this is an introductory book, its best chapters are on analysis and design, particularly detailed design. Of course, if you want to delve more deeply into requirements elicitation and analysis, turn to Sommerville. As for design, there is little on software architecture (quite rightly in my opinion, given the introductory nature of the book) and object-oriented design patterns. The impedance problem beween object-oriented software and (relational) database management systems is touched upon and skirted around in a very practical way.
The chapter on testing is barely adequate for an introductory course and rather confusingly, rewords some key definitions, such as that of structural testing, several times, shifting their meaning as the authors attempt to distinguish between different categories of (overlapping) categories such as structural and system testing. It briefly introduces U2TP, a UML profile for testing, that does not add much value in such an introductory course, and does not even mention random testing techniques (for an excellent introduction to such techniques see John Regehr and Sean Bennet´s e-course on testing at https://www.udacity.com/course/cs258 ), while its section on automated testing focuses on JUnit, a unit testing tool, leaving out other important tools.
The chapter on configuration management is, as most general books on software engineering, long on definitions (and in this chapter is where the authors most rework terminology) and short on practice. It focuses exclusively on centralized configuration managers and thus needs to be updated as regards so-called third generation distributed configuration managers, such as Git. The key trade-off in configuration management practice between parallel work and merging complexity is not touched upon.
The most idiosyncratic chapter in the book is on Rationale Management, which I found interesting but which I do not consider mainstream enough for an introductory course. Rationale Management applies Knowledge Management techniques to software development, but, as the authors admit, maintaining this knowledge up to date in a changing system is heavy going. I would suggest the authors add a chapter on software maintenance and downgrade rationale management to a section in it.
Although Bruegge and Dutoit provide explanations of agile methodologies and show in their final two chapters how processes and methodologies can be put together, their textbook can be said to reflect a medium-weight software development process and represents an interesting and intelligent compromise.
It is very hard to write an introductory textbook on software engineering: there is simply too much material to cover. If you follow the classic development stages you will find that key practical topics like configuration management and testing tend to get pushed into the last part of the course and are skimped on. In this sense, Bruegge and Dutoit have made an interesting contribution to the literature by placing a general overview of process and methodologies at the end of the book -however, in spite of the fact that the changes between the third and second edition of the book focus on the chapters on testing, configuration management and project management, in my opinion, the first two are still not quite up to scratch. In short, this is an honest, intelligent, focused and cohesive book on object-oriented software engineering, well-worth basing introductory software engineering courses on.
December 30, 2020
Bruegge is one of the nicest and most caring professors I had and the book is full of easily understandable examples but I personally wasn't a great fan of his writing. He gave his best to make examples entertaining but it honestly wasn't for me most of time. hahaha. While lectures (based on the book) were super fun the book itself was not really in my modest opinion. Guess that's just preference.
Nevertheless, may Prof. (the Legend) Bruegge remain with us for a long time to come.
Nevertheless, may Prof. (the Legend) Bruegge remain with us for a long time to come.
March 19, 2020
Inżynieria oprogramowania w ujęciu obiektowym, wzorce projektowe. Przyjrzyj się nieco bliżej cyklowi życia wymagań - aż do poziomu implementacji w języku programowania Java.
June 20, 2021
5.0 out of 5 stars
Excellent Book for Programmers Entering Software Development
June 8, 2005
This is NOT a book on Unified Modeling Language (UML). It's not a book on Object Constraint Language (OCL). It's also not a book on Capability Maturity Models (CMM), Class-Responsibilities-Collaborators (CRC) cards, Decision Representation Language (DRL), Extreme Programming (XP), Gantt charts, Issue-Based Information Systems (IBIS), Joint Appication Design (JAD), Key Process Areas (KPA), the Liskov Substitution Principle, Model-View-Controller (MVC) architectural styles, Nonfunctional Requirements (NFR) Frameworks, Object Design Documents (ODD), PERT charts, the Questions-Options-Criteria (QOC) model, Requirements Analysis Documents (RAD), Royce's methodology, Software Configuration Management Plans (SCMP), System Design Documents (SDD), Software Project Management Plans (SPMP), the Unified Software Development Process, User Manuals, V-Models, Work Breakdown Structures (WBS), or any of the myriad other tools introduced in the book.
This IS a book to introduce newly-minted programmers to the kind of things, tools, and processes they can look forward to (with either anticipation or dread) in the real world of software development. As the authors state on page viii of the Preface:
"We have observed that students are taught programming and software engineering techniques in isolation, often using small problems as examples. As a result, they are able to solve well-defined problems efficiently, but are overwhelmed by the complexity of their first real development experience, when many different techniques and tools need to be used and different people need to collaborate."
It's been many years since I was involved in major software development projects (and those were all in the military). But, this book seems to have covered everything that all new programmers need to know so that they aren't simply lost when they enter their first software project. The readers certainly won't be experts in the things covered, but they'll at least have a good grounding and be able to bootstrap themselves from there (especially since the authors provide "Further Readings" and a Bibliography at the end of each chapter). For instance, on page 71, under Further Readings, they list three works on UML: one of which is the 566 page official specification, "OMG Unified Modeling Language Specification."
Overall, this is an excellent book for anyone who is just entering the software development world. I rate it at 5 stars out of 5.
As a side note, Florida State University (FSU) uses this book in its COP 3331: "Object-Oriented Analysis and Design" course.
Excellent Book for Programmers Entering Software Development
June 8, 2005
This is NOT a book on Unified Modeling Language (UML). It's not a book on Object Constraint Language (OCL). It's also not a book on Capability Maturity Models (CMM), Class-Responsibilities-Collaborators (CRC) cards, Decision Representation Language (DRL), Extreme Programming (XP), Gantt charts, Issue-Based Information Systems (IBIS), Joint Appication Design (JAD), Key Process Areas (KPA), the Liskov Substitution Principle, Model-View-Controller (MVC) architectural styles, Nonfunctional Requirements (NFR) Frameworks, Object Design Documents (ODD), PERT charts, the Questions-Options-Criteria (QOC) model, Requirements Analysis Documents (RAD), Royce's methodology, Software Configuration Management Plans (SCMP), System Design Documents (SDD), Software Project Management Plans (SPMP), the Unified Software Development Process, User Manuals, V-Models, Work Breakdown Structures (WBS), or any of the myriad other tools introduced in the book.
This IS a book to introduce newly-minted programmers to the kind of things, tools, and processes they can look forward to (with either anticipation or dread) in the real world of software development. As the authors state on page viii of the Preface:
"We have observed that students are taught programming and software engineering techniques in isolation, often using small problems as examples. As a result, they are able to solve well-defined problems efficiently, but are overwhelmed by the complexity of their first real development experience, when many different techniques and tools need to be used and different people need to collaborate."
It's been many years since I was involved in major software development projects (and those were all in the military). But, this book seems to have covered everything that all new programmers need to know so that they aren't simply lost when they enter their first software project. The readers certainly won't be experts in the things covered, but they'll at least have a good grounding and be able to bootstrap themselves from there (especially since the authors provide "Further Readings" and a Bibliography at the end of each chapter). For instance, on page 71, under Further Readings, they list three works on UML: one of which is the 566 page official specification, "OMG Unified Modeling Language Specification."
Overall, this is an excellent book for anyone who is just entering the software development world. I rate it at 5 stars out of 5.
As a side note, Florida State University (FSU) uses this book in its COP 3331: "Object-Oriented Analysis and Design" course.
April 14, 2013
Książka kompleksowo traktuje temat inżynierii oprogramowania. Na jej dobrą ocenę, z mojej strony, na pewno wpływają ciekawe anegdoty na początku rozdziałów, duża ilość „studiów przypadku”, a ponadto genialne podejście do bibliografii. Po każdym rozdziale autorzy zadali sobie trud dokładnego skomentowania większości pozycji po które warto sięgnąć, aby zgłębić poszczególne tematy.
Z drugiej strony w tej pozycji znajdziemy mankament większości pozycji wydanych przez Helion. Nagminne błędy w kodzie(literówki, błędna kolejność parametrów, etc.) powstałe w wyniku tłumaczenia, ponadto zaginione elementy w diagramach. Do tego jeszcze wielokrotne reklamowanie innych książek wydawnictwa w przypisach.
Z drugiej strony w tej pozycji znajdziemy mankament większości pozycji wydanych przez Helion. Nagminne błędy w kodzie(literówki, błędna kolejność parametrów, etc.) powstałe w wyniku tłumaczenia, ponadto zaginione elementy w diagramach. Do tego jeszcze wielokrotne reklamowanie innych książek wydawnictwa w przypisach.
Displaying 1 - 6 of 6 reviews