Product Description

Software engineering requires specialized knowledge of a broad spectrum of topics, including the construction of software; the platforms, applications and environments in which the software operates; as well as an understanding of the people who build and use the software.

Offering an authoritative and up-to-date perspective, the two volumes of the Encyclopedia of Software Engineering cover the entire multidisciplinary scope of this important field. More than 200 expert contributors and reviewers from industry and academia across 21 countries provide easy-to-read entries that cover software requirements, design, construction, testing, maintenance, configuration management, quality control, and software engineering management tools and methods.

Editor Phillip A. Laplante uses the most universally recognized definition of the areas of relevance to software engineering, the Software Engineering Body of Knowledge (SWEBOK^®), as a template for organizing the material. Also available in an electronic format, this encyclopedia supplies software engineering students, IT professionals, researchers, managers, and scholars with unrivaled coverage of the topics that encompass this ever-changing field.

ALSO AVAILABLE ONLINE

This Taylor & Francis encyclopedia is also available through online subscription, offering a variety of extra benefits for both researchers, students, and librarians, including:

For more information, visit www.informaworld/refworks.com. Or contact us to inquire about subscription options and print/online combination packages. US: (Tel) 1.888.318.2367 / (E-mail) e-reference@taylorandfrancis.com International: (Tel) +44 (0) 20 7017 6062 / (E-mail) online.sales@tandf.co.uk

Product Description

Software Systems Architecture is a practitioner-oriented guide to designing and implementing effective architectures for information systems. It is both a readily accessible introduction to software architecture and an invaluable handbook of well-established best practices. It shows why the role of the architect is central to any successful information-systems development project, and, by presenting a set of architectural viewpoints and perspectives, provides specific direction for improving your own and your organization's approach to software systems architecture.

With this book you will learn how to

• Design an architecture that reflects and balances the different needs of its stakeholders
• Communicate the architecture to stakeholders and demonstrate that it has met their requirements
• Focus on architecturally significant aspects of design, including frequently overlooked areas such as performance,resilience, and location
• Use scenarios and patterns to drive the creation and validation of your architecture
• Document your architecture as a set of related views
• Use perspectives to ensure that your architecture exhibits important qualities such as performance, scalability, and security

The architectural viewpoints and perspectives presented in the book also provide a valuable long-term reference source for new and experienced architects alike.

Whether you are an aspiring or practicing software architect, you will find yourself referring repeatedly to the practical advice in this book throughout the lifecycle of your projects.

A supporting Web site containing further information can be found at www.viewpoints-and-perspectives.info

Customer Reviews (21)

THE book on software architecture
I'm impressed. Rarely do the IT related books are written so concisely and clearly but at the same time providing extensive coverage of the subjects. I will surely keep it on my desk for future reference when working on different software projects.

Pragmatic Software Architecture
As the title indicates this book is one on software architecture. What sets it apart from many books in that area is that it presents a pragmatic approach to architecture. The basic premise introduced is splitting the architecture into different views, which each address a specific set of concerns, such as information, concurrency, deployment, development etc. The concept of views is not a new one, however what the authors introduce is the concept of viewpoint which is the concrete representation of the view through templates, and artifacts. These artifacts include questions and checkpoints one should go through to describe the architecture.

The above view and viewpoints cover more or less the functional requirements. Perspectives on the other hand cover the quality attributes such as availability, scalability, usability etc. The authors then show how perspectives and viewpoints work together to represent the overall architecture. This includes showing the areas of overlap of these viewpoints/perspectives and how they are to be addressed.The book is supplemented with materials (templates, cheat sheets, questionnaires) on the following website:[...].

This is a great software architecture reference and one that you will keep on your desk to refer to on an ongoing basis, particularly because of its pragmatic approach. A must read for any software architect. It will also help developers anticipate the questions that will be asked during an architectural review, and things to consider throughout the life-cycle of a software project.

Review
I bought this book for my Software System Architecture Class..Book has good examples and explanation is very clear and understandable..Hope it works for me in future..:)

The Missing Manual for Software Architecture
I was lent this book by a mentor and very soon realised this was something I had to have my own copy of as it brought together many aspects of the software architect's job which I had not seen covered so well before.It is easy to read and understand, which belies the underlying complexity of the material and is a testament to the skills of the authors.Not only is the content itself good but I have also found the guided bibliography invaluable.

excellent book
This book is much better than I expected.It is practical and very informative, with good, simple examples to reinforce the points made.It covers pretty much everything you will need to consider when designing or evaluating a large IT system.This book is not outdated either.It is as useful today as when it first went to print.I highly recommend it. ... Read more

Product Description

• UML (the Unified Modeling Language), design patterns, and software component technologies are three new advances that help software engineers create more efficient and effective software designs
• A helpful project threaded throughout the book enables readers to apply what they are learning
• Presents a modern and applied approach to software design
• Numerous design patterns with detailed explanations provide essential tools for technical and professional growth
• Includes extensive discussion of UML with many UML examples

Customer Reviews (2)

Very good book
This book is extremely useful.
First time I found book where UML and source code is coupled together.
A lot of examples, exercises, very clear description and good portion of hints.
I would recommend this book for every developer and architect.

The engineering context of individual practice
Prof. Braude wrote this book specifically for his students - to clarify and unify a number of concepts.

It has three main centers of attention: design patterns, component software, and software engineering (SWEng). This last is Prof. Braude's specialty. He addresses industrial SWEng directly in another book, in far more detail than this book attempts.

This is not "SWEng-lite" though. It presents SWEng as the context in which software is designed - the environment in which design patterns are applied. Other design pattern books seem to address design as an isolated event, with no context and no further concerns than design. That, in my opinion, is how other books fail. Design is just a fraction, typically 10% down to 1% of a program's lifetime cost. SWEng addresses the whole of a software project's life.

This book exists to place design, in terms of design patterns, in its proper place in a software system's time line. In part, it's a commentary on the "Design Patterns" book by Gamma et al. In part, it's a summary of SWEng process. Other books do each job better. This book unifies the two fields, though, and may be unique in taking on that unification as its main goal.

For the general reader, this book's discussion of component software may seem shallow and tangential. Perhaps it works well in Prof. Braude's classroom, but I think it adds one concept too many to an otherwise good book. The component and .NET sections may have value in his classroom, but I think they add little to an otherwise interesting approach to two important topics.

I think this book has a place in a complete software engineering library. Maybe not the highest place, or second highest. Still, it will give the knowledgeable reader a uncommon view of individual design as part of the professional software practice. ... Read more

Product Description
Corporate and commercial software-development teams allwant solutions for one important problem--how to get theirhigh-pressure development schedules under control. In RAPIDDEVELOPMENT, author Steve McConnell addresses that concern head-onwith overall strategies, specific best practices, and valuable tipsthat help shrink and control development schedules and keep projectsmoving. Inside, you'll find:• A rapid-development strategy that canbe applied to any project and the best practices to make that strategywork• Candid discussions of great and not-so-greatrapid-development practices--estimation, prototyping, forced overtime,motivation, teamwork, rapid-development languages, risk management,and many others• A list of classic mistakes to avoid forrapid-development projects, including creeping requirements,shortchanged quality, and silver-bullet syndrome• Case studies thatvividly illustrate what can go wrong, what can go right, and how totell which direction your project is goingRAPID DEVELOPMENT is thereal-world guide to more efficient applications development.Amazon.com Review
I can hear some of you exclaiming, "How can you possiblyrecommend a book about software scheduling published by MicrosoftPress and written by a consultant to Microsoft?!" Well, put aside anypreconceived biases. This is a tremendous book on effective schedulingsoftware development, and it drinks deeply from the wisdom of all theclassics in the field such as Brook's MythicalMan Month -- and is likely well-informed by McConnell'sexperiences, good and bad, in Redmond.

The nine page section entitled "Classic Mistakes Enumerated" is aloneworth the price of admission and should be required reading for alldevelopers, leads, and managers. Here are some types of the 36 classicmistakes that McConnell describes in detail:

• People Related Mistakes
  • Heroics
  • Adding people to a late project
  • Politics placed over substance (etc.)
  
  
• Process Related Mistakes
  • Abandonment of planning under pressure
  • Planning to catch up later
  • "Code-like-hell" programming (etc.)
  
  
• Technology Related Mistakes
  • Silver-Bullet syndrome
  • Overestimating savings from new tools or methods
  • Switching tools in the middle of a project (etc.)

I suspect that if you've ever been involved in software development,you winced after reading each of these nine points. And you will learna great deal from the remaining 640 pages about concrete solutions.

My only substantive gripe: cheesy Powerpoint graphics. Nonetheless,this book is Very Highly Recommended. ... Read more

Customer Reviews (114)

The 98th 5 star review
This book ranks at the same level with MMM, Code Complete & Pragmatic Programmer.
Another Software Engineering classic

The most complete and difinitive tome on software development.
I can't write enough about this book. Everything you want to know about software development is covered, from project management to estimating to team models to lifecycle methodologies, and tons more. I've read through the entire book, re-read many of the chapters, and I still use it regularly as a reference, ten years after I first purchased it. You should see my book - coffee stains, dog-eared, post-it tags hanging out all over. Anyone who has a substantial amount of software development experience will recognize McConnell's recommendations and his examples of "classical mistakes".

It would be nice if there were an updated edition that discussed some of the more current agile methodologies. However, this book is still right on target 15 years after its publication. Don't let the Microsoft Press scare you off, there is nothing "Microsoft" about it. Its theories and real life nuts and bolts recommendations apply to all current development platforms.

If you can avoid classic mistakes and apply development fundamentals, this is THE book to take you to the next level.
To take advantage of the pearls & jewels of wisdom packed into this book, you have to already have the discipline to avoid making the classic mistakes (which McConnell conveniently lists) and know & apply software development fundamentals (which McConnell also conveniently lists).

A must read for Software development
This is one of the key books to read for software development.This book provides the needed background for becoming a team lead/architect.The book is well written.I have had mine for years and I use it as a constant reference.

Applies today as much as it ever did...
While this book may be old, it is one of the tried and true books of project management.I recall this book being standard material for my IT classes as far back as 2000!I still keep it on my bookshelf and read occasionally.A must have for any developer or those who interact with developers in some way... ... Read more

Product Description
Designed for beginning and intermediate C programmers, this bestselling book has received much acclaim for its highly readable presentation. While focusing on the C programming language, the book emphasizes stylistic issues and software engineering principles that can be applied to developing programs that are readable, maintainable, portable, and efficient. 64 illus. ... Read more

Customer Reviews (13)

Good at C language, average on Software Engineering
This book works fine as a textbook for use in class or for self study, but not as a reference. I transitioned from Fortran to C using this book more than a decade ago, and it worked well. Pretty soon, however, I was looking for more information on the C libraries elsewhere. While it gives an overall picture of the language and of what one can call "best programming practices" (which is good), it leaves out many details so important for the practicing programmer (wich is bad). Some of this is arguably outside the scope of the book, though.

The part on SW engineering gives a nice overview of the waterfall model of SW development, discusses each main phase of development, emphasizes the importance of the planning and the test phases of the project, and presents a case study in the final chapter. However, for an aspiring SW engineer it is a little thin in details, so you will have to look elsewhere for more "dirty"---and practical and modern---examples.

My rating: five stars for the very well, didactically written book with many examples and a consideration for SW engineering, and minus one star for the light treatment of some delicate topics, lack of more information on libraries other than the ANSI standard runtime, and the typos---many typos, of the annoying type (++i instead of i++, example programs with "example executions" that prints out different names and strings, etc.), but mostly harmless.

There are better...
Ther are better books available for learning C.This 1996 edition may have been great for the time, but frankly, I don't see how.While it's true that it does cover a lot of information, and does provide helpful tips to using C, it's also true that the book itself is poorly written (or poorly edited, which amounts to the same thing).Its only somewhat better than a collection of ideas that have been collected, collated, and dumped onto the press for publication.I finally got tired of trying to glean the nuggets from the dross and gave up reading it about 2/3 the way through.(I would have quit sooner, but I hoped I'd eventually get a feel for the authors style.)So..get 'C Primer +', or anything else.(K&R 2 is an essential read sooner or later..so why not now).But before buying this, try to find a copy to evaluate..who knows, you might be like the others who gushed over this book..on the other hand, it'd be sad if you found it to be like I did, but too late.

Great for learning or reference
Where the K&R book is terrible for learning C, this book makes it a snap.
It provides an organized and complete tutorial for the novice C programmer as well as a useful reference for the more experienced C user.

Its sad that this book is not world famous
As some one who took an unguided path into C programming, I can really appreciate how much of a difference this book would have made if I came across it earlier.

This book elegantly lays down the structure and parts of the C language. It presents the reasons behind various features of the language.

This is the book that will teach you to think about programming in an intuitive way.

Best single reference for using C - period.
The perfect balance of complete, useful information on ANSI C.All technical information (data types, operators, declarations, pointers, arrays) is there. It it all explained in sufficient, readable but not wordy detail.It is remarkable in its efficiency.

It's all in there - the preprocessor, railroad diagrams showing the syntax of each statement, code snippets where they useful.Data structures, starting with the bit datatype, then defining and explaining more advanced concepts of unions, structures, and the user-defined types using _typedef_.Then full examples tieing it together with linked lists, then doubly linked lists.

A brief section on software engineering concepts showing the importance ofdesign and test, and finally a complete working C interpreter.

What really sets it apart though is its complete reference of the most-used standard library functions - formatted and file I/O, string and memory manipulation functions.Effective use of the proven library functions is one of the marks of the software professional, and the outer framework of most useful real-life programs is getting data in and out.

The book begins with a very high-level overview of programs to establish its context, but this is NOT a how-to-program book. If you already understand the fundamental concepts (arithmetic and logical operations, looping) and you need a comprehensive book on how to use C, this is the one.There are lots of books in the "this is a reference, not a tutorial" class (e.g. K&R) and lots of wordy tutorials that never get to the difficult parts (like 'how do I pass a pointer to a multidimensional array.').This is one book that is sufficiently organized to be a reference, with enough clear explanation that you'll learn how and why things work.

I've had my 2nd edition of this book since it was new in 1991 and recently purchased a copy of the reviewed edition for a friend.It's still excellent, with improved coverage of new features and extensions, and removal of the obsolete adjective "new" when referencing the ANSI standard that's been ratified for a good long while now.

There is no mention of C++ - this is a C book.Good ol' ANSI C is still the language of choice for many if not most embedded projects, even new design.I believe a solid foundation in C will serve any C++ programmer well - under the 'object' layer of C++ lie member functions that actually do the work, and those functions look a lot like C...

Like most good technical books, this one's not cheap, but it's a quality Springer-Verlag binding on acid-free paper that will last a career if not a lifetime.And considering the depth, breadth, and clarity of the content, it is a bargain.

A must-have. ... Read more

Product Description
This book is a comprehensive introduction to the systematic design of real-time and embedded software systems. It is written in an accessible style and complemented by numerous diagrams, the reader is guided through the steps of a total design approach, from the initial definition of the task all the way through to documentation.The text provides arguments, examples, techniques, and methodologies to demonstrate what software engineering can offer a real-time software developer.Both the fundamentals of software design and modern design methodologies are covered throughout the text.Any software engineer looking to develop skills working with real-time systems. ... Read more

Customer Reviews (3)

Software Engineering Foundations for Memory Dump Analysis
Sometimes I'm asked about a broad software engineering book to recommend for general memory dump analysis that covers software architecture, design methods and diagramming languages like UML, programming languages, concurrency, real-time issues and many other topics you need to know to have systems understanding that helps in problem identification and debugging. Here's the book that I was fortunate to buy 4-5 years ago in a book shop and is a sheer pleasure to read. Today I found that there even exists an OMG certification based on it.

Thanks,
Dmitry Vostokov
Founder of DumpAnalysis Portal
Editor-in-Chief of Debugged! MZ/PE magazine

A must have for embedded software with EE background
I have read numerous RTOS books which includes books from Labrose and Qing Li. I think this book delivers the best explanation on RTOS concept. Unlike Labrose and Qing Li's book that throw you every details of a full working RTOS components, this books take an alternative to slowly and clearly explain why should we have this features in RTOS, and take you through slowly from real life problem to code implementation.

Yet, RTOS is only 2 chapters in this book. This book has many more to offer which include software requirement analysis, design, modeling, documentation, safety critical system and so on. This is especially valuable to people like me whom had not receive any formal training in software engineering.

EE engineers, if you have already mastered embedded C/C++ for small project, this is the book that can help you to move on to building larger embedded software project.

One of a Kind, Superb Book
One problem I have found in embedded area is that almost everybody uses procedural language to code i.e. C but nobody trains you (atleast no body does in Computer Engineering/Computer science undergrad) how to design large scale software in C. You read books about C and advanced C but how do you actually go about designing an embedded system from scratch. You go to the bookstores and everywhere you find "Object Oriented Analysis and Design". I haven't found even a single book on Structured Design anywhere except in the company library.

And one fine day I happen to see this book in a Borders bookstore.

The only book you will find about software engineering/design for real-time systems that covers as many topics and with the depth (in some areas) that I haven't found anywhere else. It covers methods/design based on Structured, data flow and Object Oriented.

Every software engineer/computer engineer working on embedded systems must atleast have a look at this book. I haveread and looked at a lot of other books but I keep on coming back to this book for one thing or another that I find only in this book.

Here are MAJOR areas in which this book shines:
1. Very good coverage of software design. Must for beginners in the field.
2. RTOS fundamentals with detailed analysis and review of scheduling policies.
3. Superb programming languages overview and list of what are the pluses and minuses of each major language being used today for embedded development. I haven't found discussion of this sort in any other book.
4. Extensive coverage of diagrams to help in design.
5. Coverage of Mission-critical and safety-critical systems PLUS performance engineering.

Again, a must to look at atleast once in your embedded career. If you are a beginner, I think you would want to buy it. ... Read more

Product Description
Provides an introduction to the software development process in a general manner, but shows real-world application using the Unified Process for Education, a modified version of Rational's Unified Process, to facilitate learning.The book starts with the basic aspects of a software process that are the methods, tools, and concepts of software life cycle and software process. The second part emphasizes the engineering and management disciplines that is core of any software engineering process. The third part presents the aspects of software process assessment and measurementProfessionals who want to learn about software engineering, especially using a commercial process. ... Read more

Product Description
ARTIFICIAL INTELLIGENCE AND SOFTWARE ENGINEERING Understanding the Promise of the Future

The computer is a surprisingly seductive device. It tempts us with the promise of its great power, but also entices the unwary to overstep the bounds of manageable complexity. Managers, business owners, computer literate individuals, and software developers alike are all seeking an understanding of artificial intelligence (AI) and wondering how it might be used.

In this easy-to-read discussion, Derek Partridge helps us understand what AI can and can not do. The topics discussed include:

** strengths and weaknesses of software development and engineering ** the promises and problems of machine learning ** expert systems and success stories ** practical software through artificial intelligence--This text refers to the hardcover edition of this title ... Read more

Customer Reviews (1)

The future isn't what it used to be...
After seeing the 1998 copyright date I confess I was intrigued. AI, in any form, hasn't gotten much press lately. If you're looking for an update on the state of AI since 1990, however, this isn't it.

The book's materials are almost exclusively from 1991 and earlier. Only 3 references are given to sources later than 1991 and two of those sources are from the author himself. That said, the book still has some interesting things to say and some lasting value.

The author's approach is unique: compare standard methods in traditional software engineering to the development approaches necessary for AI work. Partridge spends a great deal of time in the book discussingthe state-of-the-art (in 1990) for software engineering while making occasional comparisons to similar strategies for successful AI application development. As Partridge puts it "in attempting to engineer AI- software we subject the standard procedures of software design and development to close scrutiny--our attempts to build robust and reliable AI-software provides a magnifying glass on the conventional procedures." The author continues this scrutiny throughout the book.

One of the things that makes the book interesting is a view back at what computer science thought AI would have to solve (since traditional engineering practices would fall short). Automatic programming would be needed to help write all these new programs. Having humans do all that would introduce too many defects. Instead, we have "wizards", vast class libraries, and a much stronger set of powerful tools that significantly limit theamount of code that is written. Similarly, the need forreport generators has lessened because the pervasive useof relational databases and the powerful report generation tools.

My favorite was "the problem of decompiling" when discussing reverse engineering. "decompilers are somewhere between scarce and nonexistent..." Consider the modern day UML tools such as Together/J which can take a JAR file (with only code) and reverse engineer an entire UML class hierarchy!

Because the book is not really updated from the early 1990's, there is no mention of genetic programming, no mention of speech software on desktops, and no machine vision advances are discussed, just to name a few shortcomings.

It is an interesting trip down memory lane, and has some interesting things to say about AI and SE and may be worth reading on that front. However, if you want an overview of AI, you will need to look elsewhere. ... Read more

Product Description
Watts S. Humphrey, author of Managing the Software Process, broadens his disciplined approach to software engineering. In this book, Humphrey helps software practitioners develop the skills and the habits they will need in order to plan, track, and analyze large and complex projects more carefully and successfully. Clear examples and sample forms of projects are included. ... Read more

Customer Reviews (10)

Valuable method, that works
I have now been using PSP for over a year now, and as it says on the tin, it has improved how I develop software. My estimates are better, my code has fewer bugs and the others take less time to remove. I recommend following his instructions and don't worry about the theories. His instructions work and deserve 6 stars.

A word or warning, TSP is not an optional extra for most people. PSP is hard to learn and most people give up without the support of a team.

Of doubtful practical value
This is not a software engineering text. The author does not talk about how to write better programs. Instead he addresses how engineers might produce better numerical data to give management more control over the software development process.

The book readily admits that the methods only work well when an identifiable customer is able to provide an accurate and detailed problem statement. Perhaps in some isolated cases this may be so.

The author relies heavily on statistical methods. This may be comforting to management schooled in 6 sigma methodology. However it is bound to make an experienced engineer feel like a production unit on a software manufacturing line.

The book is extremely dry and tedious. The author does not know how to hold the reader's attention. He tends to ramble on for many pages before getting around to making a very small point.

The material may be useful in some isolated cases, but for most, the evidence isn't abundant that the benefit justifies the effort.

Not for the developer that thinks he/she is good.
I have read the book and implemented the processes both in and out of a school envirnoment. I have seen measurable positive results in my skills. I recently learned that an instructor I had over 7 years ago still refers to me as the best programmer he has ever met, and I owe this entirely to this book.

If you think you are already good, then chances are are that the book won't change you. If you want to find out how good you are, or more importantly become the best you can be you will most likely be enthralled by it.

A Textbook for Software Engineering
This is an excellent textbook for software developers with sufficient experience and discipline to produce professional software.It is not a philosophical treatise or a book on skills.It is not to be read casually before bedtime.In order to get something out of it, you must carry out the assignments.

The PSP training is an iterative process, slowly enhancing your process.The PSP is all about gathering data, devising improvements, and seeing the improvements through.The assignments in the book are challenging enough to require some design and have enough lines of code that you can gather data.

Over the course of the book, you'll make up to six enhancements to your proces, to the point that you have the experience to develop your own processes.If you carry out the book assignments, you'll also have some basic tools for measuring your software (lines of code counters) and process (statistical software).

In order to be effective with the PSP (or software in general), you need to follow good software design practices.The PSP enables you to capture the data that show this.Good design, though, is outside the scope of this book.

This book was the textbook for a PSP course for engineers I just completed.The course was a lot of work.In order to get something out of it, I had to be disciplined.In order to get something out of the book, you'll need to be very disciplined because you won't have the structure of a class to ensure you carry out your assignments.The PSP does not work without discipline to capture good time and defect data and to follow the process improvements.

If you have successfully learned the PSP process, be it in a formal classrom setting or through this book, you will be able to give estimates of size and time that are +/- 10% with a confidence of 70%.Of course large projects require larger processes than the Personal Software Process--those are outside the scope of this book.For an industry that is plagued by over-estimates, this is an excellent first step for engineering at the individual level.

Boooooring
When I flipped thru it at the book store it looked interesting.When I started to read it at home my eyes glazed over.The subject is very interesting, too bad the book is so boring. ... Read more

Product Description
This fifth edition is used as a standard reference for software engineers. This book provides explanations of all the important topics in software engineering and enhances them with diagrams, examples, exercises, and references. ... Read more

Customer Reviews (2)

Confusing Book-Enless lists
The book does little explaining and does a lot of quoting of other sources (this person says this way, that person thinks it should be done that way....) Every attempt at an explanation is really just another list. The book is list upon list, and doesn't connect the dots in any meaningful way! Hardly a way to get to know the subject. The overwhelming use of abbreviations (BAA, BPE, SCI, CAA, SCM, etc., etc.) makes understanding even worse because you have to try to remember what the initials stand for, sometimes chapters later. Probably Ok if you have already done software engineering for years.

It has covered every aspectin software engineering
It is a good work that covers every aspect in software engineering. Even I have been 12 years in software engineering line, but this is still a good book for you to know what you did wrong in the past! ... Read more

Product Description
This book constitutes the thoroughly refereed post-proceedings of the 4th International Workshop on Product Family Engineering, PFE 2001, held in Bilbao, Spain, in October 2001. The 31 revised full papers presented together with an introduction and six session reports were carefully reviewed and selected for inclusion in the book. The papers are organized in topical sections on product issues, process issues, community issues, platform and quality solutions, diversity solutions, product validation, and process validation. ... Read more

Product Description
Definitive guide to software engineering with B. Using tutorial examples, this practical guide can be applied to the whole software engineering life cycle. Paper. 3 1/2 inch disk included. ... Read more

Customer Reviews (1)

A quick glance at formal methods...
The B method is a formal methodology for the development of software components as state machines. Basically you write a formal description of each component in a variant of Hoare-logic, submit it to the B tool, animate it to try it out, and when satisfied, use the B tool to generate proof obligations and semi-automatically prove it's partial correctness. Depending on the tool you use, it will also generate code, but that might be less important to you.

The limititations of B are quite obvious, it cannot be used to represent e.g. concurrent processes, but it might be helpful to you anyway, as surprisingly many tasks can be modelled as simple state-machines, and with good tool-support, it might even be an advantage to do so.

The book is short, and to the point. It will not work as a textbook for formal methods, being far too short, and not covering enough material (but it can be used as a starter text). It contains just enough to get you started using the B tool. The book is written in simple language, and can be understood by any reasonably intelligent programmer or software engineer. In particular, it does not require training in formal logic.

For people new to formal methods, this is the ideal starter text, but those that already know some would want to look elsewhere. ... Read more

Product Description

This book covers research into the most important practices in product line organization. Contributors offer experience-based knowledge on the domain and application engineering, the modeling and management of variability, and the design and use of tools to support the management of product line-related knowledge.

Product Description
This book contains both relevant real-world research, as well as reviews of different areas of interest in the software engineering literature, such as clone identification. The contents of the various sections will provide a better understanding of known problems and detailed treatment of advanced topics. Consequently, the book consolidates the work and findings from leading researchers in the software research community in key areas such as maintainability, architectural recovery, code analysis, software migration, and tool support. ... Read more

Product Description
"A comprehensive solution to the requirements challenges faced by every development team. Full of insight and ideas all developers can learn from." --Ivar Jacobson

"Many projects fail for the simple reason that the developers fail to build the right thing: They either deliver a system that does not meet the expectations of its intended users, or they deliver a system that focuses on secondary functions at the expense of its primary use. Drawing on their extensive experience, Dean and Don demonstrate how to employ an industrial-strength requirements process, one that helps ensure you will build the right thing. Developers of any kind of application should read this book." --Grady Booch

Despite the wealth of development knowledge, experience, and tools generally available today, a substantial percentage of software projects continue to fail, often because requirements are not correctly determined and defined at the outset, or are not managed correctly as the project unfolds. Clients do not always know or express their needs precisely, and too often designers and developers do not ask the right questions at the right times. As a result, projects often spin out of control as "feature bloat" and shifting priorities cause budgets and schedules to exceed expectations. Managing Software Requirements focuses on this critical cause of failure and offers a practical, proven approach to building systems that meet customers' needs--on time and within budget.

The authors are skilled practitioners who have spent their careers in the trenches building high-quality applications, including safety-critical, real-time systems. Using an informal, approachable style, their own war stories, and a comprehensive case study they show how designers and developers can effectively identify requirements by employing the power of use cases and more traditional forms of requirements expression. The book illustrates proven techniques for determining, implementing, verifying, and validating requirements. It describes six vital Team Skills for managing requirements throughout the lifecycle of a project: Analyzing the Problem, Understanding User Needs, Defining the System, Managing Scope, Refining the System Definition, and Building the Right System. Managing Software Requirements specifically addresses the ongoing challenge of managing change and describes a process for assuring that project scope is successfully defined and agreed upon by all stakeholders.

Topics covered include:

* The five steps in problem analysis * Business modeling and system engineering * Techniques for eliciting requirements from clients, users, developers, and other stakeholders * Applying and refining use cases * Prototyping * Organizing and managing requirements information * Establishing project scope and managing customers * Using both informal and technical methods for specifying requirements * How to measure and improve the quality of your product's requirements * Moving from requirements to implementation * Verifying and validating the system * Managing change

The book concludes with a step-by-step guide to incorporating these powerful techniques into future projects. ... Read more

Customer Reviews (18)

Fails to explain the GAP between Biz Objectives & Outcomes
Software requirements begin with business objectives, definition, requirements, and expectations. Business community always looks at the bigger picture, on the other hand, systems or business analyst merely focus on specific information, result is the actual requirements get lost between the translations and the software projects fail or are delayed and exceed their budget. This book eloquently spells out six skills crucial for defining comprehensive software requirements, like analyzing the problem, understanding user needs, defining the system, managing scope, refining system definition and system validation. If you have difficulties in defining and maintaining the system requirements, this book could significantly improve the focus. However, this book fails to explain the gap between business objectives and outcome. However, linking this book to preliminary step of software development would overcome initial snag, ensuring the system design and implementation likely to be successful. By Vivek Dixit, Stanford.edu

Anyone involved with developing software - read this book
I have survived many approaches to "capturing" a system design over the last 22 years. This book, however, lays out a tactical plan that can be used to flush out design issues up front, where the seeds of larger design problems start.

There are several references to "Quality Before Design", and this book extends those ideas into a very tangible process of requirements management. The authors were working with these ideas before the Rational system was developed, and the book ties together its approach with the Capability Maturity model and the Rational Unified process at the very end of the book.

The book is very clearly written, and organized to build upon earlier concepts and help the reader take the ideas from concept to practice.

A must for anyone in software development
This is the most inspiring book I have read for years! I recommend it to *anyone* involved in software development or even those who are about to make an investment in software for own use. Stakeholders at all levels, even the guardians of the company's money bag, the users, developers, project managers etc. should all read - and then practice what the authors preach. This comprehensive book should make it easy to adopt the suggested processes.

Excellent, informative guide to requirements gathering
This is an excellent book for building a strong foundation in requirements gathering.The authors have clearly been doing requirements gathering for years and are kind of enough to share volumes of their hard fought wisdom with the rest of us.I found parts of the book, especially the beginning, a little slow to get to the point.However you can just skim any parts that might be a little drawn out and there is more than enough outstanding content to make it very worthwhile.This book provides wonderful insight, persuasive arguments, multiple views and ideas for how requirements are best gathered, a clear style of explaining concepts, and a pleasant and entertaining writing style.Requirements gathering is such a large topic that the book could not possibly teach EVERYTHING you might ever need to know about requirements gathering, but it gives an outstanding basis from which you can continue to build in whichever directions are most appropriate for you.A very expereienced requirements gatherer might find the book somewhat introductory but would certainly still gain wonderful insights from parts of the book.I think both beginners and experts will benefit from this book.

Basics
This is a good book to read and have in the bookself. It gets you started and even if you have knowledge of requirements management, you should see it what's inside.However I do software that is very complex (telecommunications) and for this kind of environment this book just isn't enough. I would have hoped for more compact text with fewer pictures and more concrete real world examples. This book resembles too much children's books.

Well anyway, as I said this book is anyway a must read, but you have to read more. I found many good ideas and could broaden my understanding by reading "Customer Centered Products" by Ivy F. Hooks and Kristin A. Farry. ... Read more

Product Description
Software Engineering

Volume 2: The Supporting Processes

Third Edition

Richard H. Thayer and Merlin Dorfman

Foreword by Leonard L. Tripp, 1999 President of the IEEE Computer Society

This second volume of the Software Engineering tutorial, Third Edition includes reprinted and newly authored papers that describe the software engineering supporting life cycle processes. This volume details the supporting life cycle processes that developers need to employ and execute in the engineering of software products. This required support plays an integral part and has a distinct purpose that affects the overall success and quality of the software project. This book helps prepare individuals to take the examination required by the IEEE Computer Society to achieve the status of Certified Software Development Professional (described at www.computer.org/certification).

This Third Edition differs from the earlier editions in that it supports both the new 2004 version as well as the older 2001 version of the Software Engineering Body of Knowledge (SWEBOK), and that many of the newly authored papers were tailored after and support the corresponding chapter from SWEBOK 2004. In fact, some of the authors of the tailored papers also wrote the corresponding SWEBOK 2004 knowledge area.

The supporting processes covered in this book include documentation, configuration management, quality assurance, verification and validation, and review and audit processes. In addition, this tutorial covers the four processes of the organizational life cycle. These are used to establish and implement an underlying structure made up of associated life cycle processes and personnel that will continuously improve upon the structure and process of the project. These organizational processes are management, infrastructure, improvement, and training.

Each chapter in this volume starts by introducing the subject, supporting papers, and standards. The backbone for this publication is IEEE/EIA Standard 12207-1997, Standard for Information Technology-Software Life Cycle Processes.

Contents:
* Software Engineering Supporting Processes
* Software Configuration Management
* Software Verification and Validation Processes
* Software Quality Assurance Process
* Software Reviews and Audits Processes
* Software Documentation Process
* Management Process
* Infrastructure Process
* Improvement and Training Processes
* Appendices ... Read more

Customer Reviews (1)

Waste of money
This is just photocopies of old published papers that your instructor could find for free on the net.What a waste of money. ... Read more

Product Description
This volume contains the proceedings of the fourth EuropeanSoftwareEngineering Conference. It contains 6 invitedpapers and 27 contributed papers selected from more than 135submissions.The volume has a mixtureof themes. Some, such as softwareengineering and computer supportedcollaborative work, areforward-looking and anticipate future developments; others,such as systems engineering, are more concerned with reportsof practical industrial applications. Some topics, such assoftware reuse, reflect the fact that some of the concernsfirst raised in 1969 whensoftware engineering was bornremain unsolved problems.The contributed papers are organized under the followingheadings: requirements specification, environments, systemsengineering, distributed softwareengineering, real-timesystems, software engineering and computer supportedcollaborative work, software reuse, software process, andformal aspects of software engineering. ... Read more

Customer Reviews (19)

great item
the item was a great deal. it was flawless. it was shipped in a timely manner. the item was exactly what i ordered. i would totally buy from this seller again. i was very satisfied.

Great book to have on your desk.
If you are a software project manager and would like additional insight into the software development life cycle (SDLC), then this is the book for you. It gives a conceptual overview on each phase of the SDLC as well as in depth knowledge that will help you determine how best to proceed with your project.

I only gave it three stars because it is formatted more like a text book, which gives it an eerie feeling, but that is of course relative.

Informative but not Practical
I used this book for an introductory course on software engineering.Although the book gives an expansive view of the field, there isn't enough detail or in-depth examples to make it anything more than an academic treatise.I don't feel that I could use much of what I've learned in an actual project - I would have to resort to more specific references.

Now, the premise of having an entire book on software engineering may be more to blame than the clarity or presentation of the material.But software engineering is a practical field, and a software engineering text that doesn't provide practical information isn't useful.For this reason, I cannot give the book a passing grade.

Shallow and not using American English
This book tries to cover way too much information in such a small space leaving topics overly vague and generic.

Further, the author does not use American English, which is fine - when you don't attend an American university.Words such a "modelling" and general sentence structure makes the text distracting and confusing in ways it shouldn't be.If I am going to have trouble reading it, let it be the material and now how the material is presented.

If the book isn't forced upon you by a university, you should consider a different software engineering book if you want details.

Of course, I won't even go into my professor who is using this book - yikes.

Worth the paper it's printed on but no more
I used this book in a 400 level college course on software engineering, and found it to be exceedingly shallow in its coverage of the topic. The work is a worthy attempt at providing a broad overview of the discipline. However, in my estimate it covers too much material in too little space and presents too few practical examples of the type that might be applicable to a "real-world" software project. Further the text only gives lip service to the wide array of tools now available. In all honesty I don't see how any one could give this book more than three starts (apologies to the other reviewers), especially considering that the book is now in its sixth edition.

I was at the used book store recently and had the good fortune of acquiring Stephen R. Schach's excellent book: "Software Engineering with Java." If you are a college professor looking for a course text, I would highly recommend taking a look at this book. ... Read more

Product Description

The second edition of this comprehensive text provides an up-to-date, coherent, and rigorous framework for controlling, managing, and predicting software development processes. With an emphasis on real-world applications, the authors apply basic ideas in measurement theory to quantify software development resources, processes, and products. They also discuss the limitations of past and current approaches used in empirical research, show how these limitations can be reduced, and provide guidelines for making decisions. In addition to worked examples and exercises, this edition features extensive case studies throughout the chapters.

Customer Reviews (3)

Complete, wide in scope and essential
I have a large number of metrics books, including everything written by Grady, Jones, and Florac & Carleton, and this is one of my personal favorites.It not only goes into measurement theory and practice, but covers nearly every key metric associated with software engineering.

Instead of writing a tome about what this book contains, I'll confine my comments to what I especially like about it and why.

First, the measurement fundamentals, the goal-based measurement framework, and information about data collection and management alone make this book worth owning. Data collection, for example, can waste resources if you try to collect everything, or worse, don't properly manage or analyze it.Follow the process given in the first part of this book and you'll have a solid basis for a metrics initiative.

Second, the scope of software engineering metrics is wide and given fairly detailed treatment. I especially like the fact that object-oriented metrics are addressed, and the multi-dimensional approach to measuring internal and external product attributes.Moreover, the scope of this book extends to productivity and resource management, which is where development projects and lifecycle costs associated with maintenance have gaps.Finally, the section on software reliability metrics was excellent and added yet another dimension to the coverage the authors give.

Overall, this book is both rigorous and practical as the title implies.The theory and practical applications of measurement and metrics are carefully balanced, and the breadth of material ensures that coverage is complete and addresses all major aspects of software engineering.

Software Metrics: A Rigorous and Practical Approach, Revised
The structure of the book makes it difficult to read. It jumps from one type of metrics to another and then back again. The motivation for some of the metrics is not explained at all.

Considering the price you should get value on all pages. This book could have been one quarter of its size and you would not have lost anything.

This is far from a Practical Approach. At some places the authors seems more interested in taking down other researchers ideas than giving an objective view on, "what metrics is, how it can be used, when it is used, what you measure on".

excellent survey and critique
(For the full text of this review, see Doctor Dobbs Journal)Software Metrics is not just a thorough, readable survey of the various proposals that have been made over the years for measuring the characteristics of programs; it is also a detailed critique of the sloppy way in which people have tried to use such measurements to predict how much effort would be required to develop and maintain software, and how reliable that software would be. The first part of Software Metrics introduces the fundamentals of measurement theory. What does it mean to measure something? What kinds of measures are there, and -- more importantly -- what kinds of conclusions can we draw from different kinds of measurements? The second part of the book looks at software measurement in particular. Popular measures (COCOMO, function points, cyclometric complexity, and the like) are all described, and their weaknesses pointed out. Again and again, the authors show that the proponents of various metrics have failed to validate their metrics in even the most basic ways...Part Three looks at implementing software measurement in the workplace, and includes an interesting discussion about the nature of empirical research in software engineering. The book closes with a comprehensive annotated bibliography. If you have ever thought about measuring the progress of a software project, or about trying to predict the effort required to develop or maintain a program, this book will tell you what is feasible, what is just hype, and how to tell the difference between the two. ... Read more

Product Description
Overcomes the challenges of teaching the concepts and practicalities of large-scale software development to beginners in the area by using case studies taken from the real world of commercial information systems development.The book is divided into four parts.Part A covers project management and the software life cycle.Part B takes the information learned in Part A and shows readers how to begin a project.Part C looks at the backbone of an information system.Part D moves the focus from the backbone to the front end, looking at designing and programming the user interface.This book is designed for readers needing a general introduction to software engineering. ... Read more

Customer Reviews (2)

Good format, but no so good content
This book is a little disappointment to me. I was looking for a book explaining software engineering with real code and this book has promised such an approach. But unfortunately, this book is weak on keeping reader's interest. The authors has made great efforts trying to cover everything but many topics are lacking what we normally call "insights". In other words, I seldom got "aha"s.

Gook work on reviewing modern software engineering
This book can provide a modern popular view and nearly thorough information on the classic software engineering. The project examples(with coding) are definitely helpful for enterprise development with any kinds of technical skills(Java, C++ etc). ... Read more

Product Description
Software architecture is foundational to the development of large, practical software-intensive applications. This brand-new text covers all facets of software architecture and how it serves as the intellectual centerpiece of software development and evolution. Critically, this text focuses on supporting creation of real implemented systems. Hence the text details not only modeling techniques, but design, implementation, deployment, and system adaptation -- as well as a host of other topics -- putting the elements in context and comparing and contrasting them with one another. Rather than focusing on one method, notation, tool, or process, this new text/reference widely surveys software architecture techniques, enabling the instructor and practitioner to choose the right tool for the job at hand. Software Architecture is intended for upper-division undergraduate and graduate courses in software architecture, software design, component-based software engineering, and distributed systems; the text may also be used in introductory as well as advanced software engineering courses. ... Read more

Customer Reviews (7)

Foundations, Theory,Practice is the order of book priorities
When I first contemplated to buy this book I thought it might be slightly... academic... After buying it... my a priori thinking proved to be somehow true... The material is solid with many valuable comments, some of which I always had in the back of my mind, but never done the final steps to "materialize" them.For instance the fact that architecture is very close to design to the point that sometimes is difficult to distinguish the two. In this sense I enjoyed the introductory chapters with general ideas. When it comes to main content I was a bit surprised by the emphasis on classifications: views, models, implementations ... the part which I thought has an academic flavour.

Modern intro to Software Architecture
I bought this book from Amazon late 2009, it has not left my side since. This book provides a modern introduction to the field of software architecture, for both students and seasoned professionals. Certainly a must if you are working in this field or aspiring to.

FYI the course slides are available from the book's website [...]

Worth the money to find out more about architecture
Excellent academic treatment of all things architecture. I've gone through just over half of this textbook. This book is good enough that I have decided to finish the rest of the content. The only reason I give it 4 stars instead of 5 is because the authors do not present real world examples of architecture. In retrospect, I have decided to give this book 5 stars, because real world examples of architecture are either competition sensitive or precluded from being revealed due to security considerations. The authors really should have found an IT shop or shops willing to reveal a number of best practice architectures, so that those interested could get a feel for how complex and interconnected best practice architectures are.

This is an excellent textbook for students, and for those IT professionals who want to learn more about the architecture specialization, it is a good reference with an impressive continuity and it is very well organized in its introduction of all of the relevant concepts.

Software Architecture text - not worth
I do not recommend this book for practitioners or as a college text

This book needs serious review and editing by decent english readers for repetition, grammer, and consistency. This book is too hasty even in defining the basic term architecture. It is quite hard to read and frustrating because of inconsitencies. Some bogus, artificial, presentations pervades the book.

Repetition are OK if they are consistent, however repeated topic contracdicts the previous discussions. The flow of sentences are too hasty even for experienced architects.

Topics are identified in a fashion that, if authors had not rushed it could have been a better book. If the same topics were presented in more concise format, this book could be lot thinner and easier to read; in addtion font used is too small, figures are not simple sketches, english is too interwinded (not simple but seems too artificial) makes it difficult to adopt the book. Some examples are good but incomplete.

A fine introduction to the discipline of software architecture
Software Architecture: Foundations, Theory, and Practice is a landmark text that will become an essental introduction to the discipline of software systems architecture. If you are a student, tester, manager, methodologist, developer, or simply an architect, and want a holistic understanding of what real software architects think software architecture is and why it matters, this is the place to start.

I bought this after Roy Fielding (of REST and HTTP fame) mentioned it on the rest-discuss mailing list. Roy is one of the industry's top architects, and I wasn't disappointed. The book is timely - architecture is coming to be accepted as an important activity, especially for distributed, and large scale systems. What many people don't realize is that drawing pictures, writing documents no-one reads, meta-modeling, and pontificating on "concerns" are not software architecture. Software architecture is about introducing constraints via principled, objective design to achieve particular system properties. Architecture is difficult and exhausting work, but done well can offer immense value to users and stakeholders. This book, along with Rozanski and Woods' "Software Systems Architecture: Working With Stakeholders Using Viewpoints and Perspectives" makes that explicit.

The book is unapologetic about software architecture's standing in the industry. SAFTAP positions architecture as the primary design activity for software - not development, not requirements analysis, not testing, not methodology, but architecture. That will make for interesting debate.

My single criticism of this book is that it does not do enough to treat user experience (Ux) and informatics as architecturally significant, but not enough to take away a star. I'm hoping a future edition will rectify that.

Some noteworthy chapters in the book (there are 17 chapters in all):

* The Big Idea: explains what architecture is and why it matters. The building metaphor (often heavily criticised in the industry, see the excellent "Software is not Bricks" by Raganwald) is dealt with calmly and then put to one side.

* Architecture in Context: explains how architecture fits into the overall lifecycle and process of software systems.

* Connectors: this is one of my favourite chapters. The concept of a connector is vital to a software system, but is rarely if ever discussed in programming or engineering texts.

* Modeling: probably not what you think. This chapter emphasizes communication, clarity and disambiguation over notations and diagrams.

* Implementation: programmers hate the quip "implementation detail", but in truth many things in a system are just that and it does not mean they are unimportant. This chapter covers those details and why they matter.

* Deployment and Mobility: good architects understand that a systems have a life well beyond initial delivery, which is where most developers, managers and stakeholders tend to focus attention. This was one of favorite sections as the running system simply doesn't get enough attention in most projects today.

* Applied architecture and Styles: covers some examples of architectural styles, notably REST and SOA, which are certainly the best known architectures in my part of the industry.

* Designing for non-functional properties: many non-functional concerns don't start to matter until the system is deployed and there isn't always agreement among technical specialists over what's truly important. If you are technical specialist this should help you articulate the cost/benefit of looking at the "unfeatures" of a system.

* Security and Trust: software is increasingly distributed, and increasingly a super-system of components interacting over the Internet and Mobile Networks. So it's good to see a text that makes security a first order concern and not just a non-functional ones.

* Domain Specific Software Engineering: I'm trained as an industrial designer where the notion of common modular components with standard interfaces acting as a platform for product development is a known Good Thing in domains such as the automotive and consumer electronics industries. This chapter gives a good overview of modular design focusing on the software product lines approach. The example given is from Philips, but it could as easily have been from Toyota.

* People, Roles and Teams: software architecture, like other architecture disciplines, has a strong social dimension. This chapter explains how the architect role fits into an organisation and where they can add value and exert influence. ... Read more