Product Description
Even bad code can function. But if code isn’t clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn’t have to be that way.

Noted software expert Robert C. Martin presents a revolutionary paradigm with Clean Code: A Handbook of Agile Software Craftsmanship. Martin has teamed up with his colleagues from Object Mentor to distill their best agile practice of cleaning code “on the fly” into a book that will instill within you the values of a software craftsman and make you a better programmer—but only if you work at it.

What kind of work will you be doing? You’ll be reading code—lots of code. And you will be challenged to think about what’s right about that code, and what’s wrong with it. More importantly, you will be challenged to reassess your professional values and your commitment to your craft.

Clean Code is divided into three parts. The first describes the principles, patterns, and practices of writing clean code. The second part consists of several case studies of increasing complexity. Each case study is an exercise in cleaning up code—of transforming a code base that has some problems into one that is sound and efficient. The third part is the payoff: a single chapter containing a list of heuristics and “smells” gathered while creating the case studies. The result is a knowledge base that describes the way we think when we write, read, and clean code.

Readers will come away from this book understanding

• How to tell the difference between good and bad code
• How to write good code and how to transform bad code into good code
• How to create good names, good functions, good objects, and good classes
• How to format code for maximum readability
• How to implement complete error handling without obscuring code logic
• How to unit test and practice test-driven development

Customer Reviews (76)

a Must read!
This book has a deep impact on how I write or even think about code. I you care about your craft you should really read this!

A must read!Fantastic!
This is a fantastic book about writing clean code and test driven development.Robert dedicated an entire chapter, 14, to refactoring code and included why he refactored the way he did.Thats not all, the way Robert wrote this book is from one coder to another meaning you are his audience; very refreshing.He doesn't hold your hand, but gives you enough information to get you literally on the same page as him with every line.The patterns and "smell tests" included here are worth the cost of this book alone.

This book got me passionate about coding again and about unit testing.If you are a programmer, it doesn't matter what language, (I write python mostly) this book deserves a place on your bookshelf.

Complete Awesomeness
Given the Author is Uncle Bob Martin, I have to admit that I had very high expectations for this book and they were exceeded.Uncle Bob Martin's writing style will keep you engaged and eager to read on.This book will help arm you in tuning your craft as a software developer striving for clean and beautiful code.

If your not sure how good your code is read this!
I have been a Java programmer for a couple of years now and while I know I have a good appreciation for OO concepts and their application I wasn't sure whether my code was actually very good - from the perspective of being efficient, easy to read, extendable, manageable etc. This book, written by seasoned, well-respected programmers gave me confidence in some of things I had already being doing, but mostly helped me improve alot of things and learn't quite a few tips for things I wasn't doing in my code.

Not too thick, very readable - I rarely recommend books to colleagues since I find its a bit subjective, but this is probably the 1 programming book that I have read so far that I always recommend.

You won't be sorry you read it, even if you don't learn anything you will perhaps gain confidence in what you are doing.

A book about how to produce quality code
One of the best books I've read about how to design and produce quality code. Being a professional software developer/craftsman is more than just being able to solve hard technical problems (among other things). It's being able to solve them with elegance and style, and this book helps you develop the knowledge and skills to do just that.

... Read more

Product Description
Building on seven strong editions, the eighth edition maintains the organization and approach for which Object-Oriented and Classical Software Engineering is known while making significant improvements and additions to content as well as problems and projects. The revisions for the eighth edition make the text easier to use in a one-semester course.

Integrating case studies to show the object oriented approach to software engineering, Object-Oriented and Classical Software Engineering, 8/e presents an excellent introduction to software engineering fundamentals, covering both traditional and object-oriented techniques.

While maintaining a unique organization with Part I covering underlying software engineering theory, and Part II presenting the more practical life cycle, the eighth edition includes significant revision to problems, new content, as well as a new chapter to enable instructors to better-utilize the book in a one-semester course. Complementing this well-balanced approach is the straightforward, student-friendly writing style, through which difficult concepts are presented in a clear, understandable manner. ... Read more

Customer Reviews (12)

Object-Oriented and Classical Software Engineering
the book was perfect almost like new and the shipping was quite good as well....

UML and Software Design
This book detailed the different methods of attacking software design and introduces UML diagrams, statecharts, and organization. A wonderful book for those who will be working in the field dealing with the structure and methods that real business' use for software design.

Pick a Methodology, Any Methodology
Stephen R. Schach's "Object-Oriented & Classical Software Engineering" (7ed) is an OK book:it's not bad, but it could certainly be better.

First, some minor quibbles:even though the typography and editing is good, I'm not all that enamored with the color scheme:the orange and black theme is too much like a pumpkin.I know it's trivial, but I thought I'd just pass it along.A little more meaningful is that Schach seems to place too much emphasis on definitions.I don't need multiple reminders of the differences between things like corrective, perfective and adaptive maintenance.It would be better if he just focused on the function and not on the definition.For university use, I suppose this is OK.But, I found it a bit irritating.

The medium-level problem with the book is that there's a lot of temporal shift in the presentation:he would talk about some model or methodology in terms that implied it was the latest and greatest thing.Yet, it had been around for decades. This is probably a function of the overall age of the book:this is the 7th edition.

Most importantly, Schach needs to pick a methodology and stick with it:either talk about the classical methodology or the object-oriented one.Not both. Nowadays, most people probably work with, and are interested in, an object-oriented methodology.Having 1/3 of a book filled with the classical methodology is useless to them.Ditto for those people still working in a classical environment:they won't care about 2/3 of the book.And, for those people who are in a classical environment and want to move to an object-oriented one, there's really nothing in the book that will help them with the transition.If he removed the classical material from the book and published a "how to transition" book instead, that would be great.

Again, it's not a bad book.But, it's not that great.I rate it at an OK 3 stars out of 5.

Good reference material
I had to buy this for my software engineering course at school, and I have found it very useful in explaining software design models and reqs and spec documentation.What I didn't expect were great anecdotes and the chapters on coding practices improved my code-writing skills more than any other source.

I also like the fact that the author strayed away from language-specifics, relying more on the theory and design than the actual impementation.

Great software engineering book, not aimed at programming
I took Professor Schach's course with the last edition of this book two years ago, and it has been very useful for me now that I work at a big corporation. It is a common misconception to think of it as a UML or OOP programming book, because many people confuse software engineering with the areas of software development and programming. They are quite different. This book is best aimed at programmers that want to understand the processes that exist for writing well-planned code in a large organizations. Think of this book as focusing on the overarching _process_ of writing software. This is especially important from the perspective of a project leader or a manager in a software company. It also offers important business perspectives for software development that you should be aware of. If you want to understand why your customers are unhappy with your results, why things are over budget, or why your project keeps missing deadlines, for example. There's alot more in there as well. I really liked it, and Schach knows what he's doing. He owns a software consulting company if I remember correctly. ... 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 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
Competitive Engineering documents Tom Gilb's unique, ground-breaking approach to communicating management objectives and systems engineering requirements, clearly and unambiguously.

Competitive Engineering is a revelation for anyone involved in management and risk control. Already used by thousands of project managers and systems engineers around the world, this is a handbook for initiating, controlling and delivering complex projects on time and within budget. The Competitive Engineering methodology provides a practical set of tools and techniques that enable readers to effectively design, manage and deliver results in any complex organization - in engineering, industry, systems engineering, software, IT, the service sector and beyond.

Elegant, comprehensive and accessible, the Competitive Engineering methodology provides a practical set of tools and techniques that enable readers to effectively design, manage and deliver results in any complex organization - in engineering, industry, systems engineering, software, IT, the service sector and beyond.

* Provides detailed, practical and innovative coverage of key subjects including requirements specification, design evaluation, specification quality control and evolutionary project management
* Offers a complete, proven and meaningful 'end-to-end' process for specifying, evaluating, managing and delivering high quality solutions
* Tom Gilb's clients include HP, Intel, CitiGroup, IBM, Nokia and the US Department of Defense ... Read more

Customer Reviews (14)

Looking For Requirements Development Examples
I was looking for a book on requirements development and found this book to be on topic, but not a bulls-eye.I would have liked more in-depth examples, as the provided ones just touched the surface.However, I did find the book thought provoking and thus a 4 star rating.

Specifically, I found the various requirement-development templates that were provided as a good means of collecting thoughts around requirement topics.In my attempts to apply the templates, they helped refine my thoughts as to the issues surrounding requirements development.

The book refers to the author's web site for further information and examples.I'd give that site a 2 ½ star rating, as the information there was rougher information than provided in the book.

I'd recommend this book for anyone contemplating requirement development.The reader is left to generate their own examples.

Packed with great info!
Planguage is a word and concept that combines Planning and LANGUAGE and is rooted in the author's experience since 1960. The core tenant of Competitive Engineering is that well structured specifications have a dramatic cost reduction over down-stream error correction. The defect prevention process (DPP) is used to clean up early stages specs, or preferably measure defects and motivate lower defect injection, in specifications and the attendant issues instead of relying solely on defect detection andcorrection once actual development has begun. Competitive Engineering provides focus and skills to dramatically increase how productive many of us have been in the past.

The centrality of quality specifications means significant gains for the broadest spectrum of stake-holders who stand to win with the System Of Interest (SOI). Take this specification as an example to clean up:

"The new system will use Foo language running on OS Bar and ensure top industry quality response time on web requests."

People in the field have seen specs like these. Hopefully you aren't writing them. There are what Gilb classifies as "Major defects" in this spec. Which web requests, the front page or all of them pulling from the various databases? Can the old system be incrementally upgraded instead of an entirely new development environment? Why use Foo and Bar if something else gets the job done better, faster, and with less resource utilization? Just how fast is "fast", anyway?

In Competitive Engineering you're told to get measureable quality requirements, record who requested that requirement, and exactly what "success" is defined as. That allows you to go back to the requester with notes such as "If we use OS Baz we'll get a 27% increase in CPU performance" and let them make a decision or escalate to the project funder. You're also encouraged to weed out "design constraints"; at least out of the mandatated and into the labelled area "Design Constraint". Wouldn't it be great if you got a specification that let you design the best you could without technical input from someone that can't use a web-browser?

See if you can understand my re-write of the above spec into Planguage.

Response Time on Front Page of Company Website.

Type:Performance Requirement
Version: 1.2
Status:Draft
Owner: F. Flintstone

Stakeholders: Marketing, Server Support, Corporate Intelligence, ,

Ambition: The front page of the corporate website should respond fast enough to keep the viewer's attention.

Description: Marketing research indicates the typical business website viewer makes an opinion on the website, and thus the company, within 20 seconds. Our corporate site pulls data from three different databases and a sizeable image library, taking an average of 26.87 seconds on a home DSL/Cable modem equivalent network. Marketing advantage can be gained if we can grab viewer attention noticibly faster than our two nearest competitors who average 23.43 and 26.09 seconds, respectively.

Vision:Enough accurate information provided quickly enough to keep the customer on our site.

Scale: Time, in Seconds, to a complete front page load on the equivalent of a 250K network connection.

Past [Front page, 1 Apr 07]: 26.87 seconds

Goal [1 November 07]: 19 seconds<- Marketing Director: BR

Stretch: 15 seconds

Wish:9 seconds

Design Constraint: Supportability <- Server Support Manager WFMust utilize .

Design Constraint: Security <- Corporate Intelligence BBMust meet .

------------------------ end of spec example --------------------

Probably the only thing that might confuse you about that specification is the use of text within "<...>". Planguage uses that to denote a "fuzzy requirement"; something that is defined but not with the concreteness you'd like. In this example, however, it would be relatively simple to query B. Rubble for the specific guidelines her team seeks to enforce. The use of fuzzy requirements also allows for change over time; more OS versions may become supported while others are obsolete.

When I read part of an electronic copy of the text I had a problem. My antiquated home printer could not print it and if I used the work printer I view the output as a possession of my employer. The book is written as part instruction, part reference manual; I bought my own copy because I know I'm going to use it for the next few years and several employers.

Excellent Systems Engineering Book
This is one the books which has caused a great impression on me. It helps to get away from high-level, gut-feeling, fuzzy goals and descriptions to very concrete targets, unambiguous requirements and rational decisions. This strikes a chord at the heart of systems design and architecture, which consists in maximizing a set of business goals with limited resources (time, budget, personnel). I highly recommend it.

It's a very good book.
Building software systems is not easy, this book can help you to do a better job.

Best Practices in Systems Engineering and Management
My interest in the topic of competitive engineering (CE) was piqued several years ago when I heard very favorable comments about Tom Gilb's tutorial on that subject at the INCOSE 2002 Symposium in Las Vegas.

The book's subtitle is "A Handbook for Systems Engineering, Requirements Engineering, and Software Engineering Using Planguage". The term "Planguage" is central to an understanding of the book. Planguage, which is derived from a union of "plan" and "language", is the methodology for implementing CE. Much of the book is devoted to describing the generalized processes, rules, and vocabulary of Planguage. Tom notes, "Planguage should be viewed as a powerful way to develop and implement strategies that will help your projects to deliver the required competitive results." Fundamentally, the book presents a new take on best practices in systems engineering and management.

The book is useful on several levels. For organizations without a formal or documented process, tailoring of Planguage would jump start the process at a high level of maturity. For organizations that have achieved CMMI level 3 status, Planguage by itself is not as useful. However, many of the ideas of CE-the Planguage methods-are worth considering for enhancement of existing organizational processes. Tom states that CE is "about technological management, risk control, and breakthrough improvement in complex business systems, projects, and processes." CE is a believable approach for delivering complex projects on time and within budget.

The book passed my value-added test, when I realized that I was photocopying several pages for future reference, to be part of my "toolkit" of helpful tips and techniques. I particularly enjoyed reading the 10 often witty, summary principles in each chapter. Two examples are:

* The Principle of `Storage of Wisdom':"If your people are not all experienced or geniuses, You need to store their hard-earned wisdom in your defined process. Capture wisdom for reuse, Fail to write it, that's abuse!"

* The Principle of `The early bird catches the worm':"Your customers will be happier with an early long-term stream of their priority improvements, than years of promises, culminating in late disaster."

About 30% of the book is the Planguage Concept Glossary, which Tom views as a central contribution of the book. I focused my attention on the other, more interesting, parts of the book, which describe the main CE/Planguage methods of Requirement Specification (RS), Design Engineering (DE), Impact Estimation (IE), Specification Quality Control (SQC), and Evolutionary Project Management (EVO, also known as Evo). RS describes an approach for identifying all types of requirements while avoiding ambiguity and also planning for change. Functional and performance requirements are distinguished. DE deals with identifying, choosing, and prioritizing the order in which design ideas are implemented and delivered. In conjunction with Evo, DE selects the design ideas most likely to provide a significant benefit for early delivery.

SQC is an eminently practical approach for evaluating the quality of any technical document via sampling measurements. An hour of SQC early in a project can save almost 10 hours of rework. SQC also provides a means to assess the success of process improvement efforts. IE provides a realistic method for evaluating-in quantitative terms-the effectiveness of designs in meeting both the requirements, especially critical performance attributes, and the resource budgets.

Evo focuses on early, frequent delivery of project results via a series of high-value, small evolutionary steps. An ideal Evo approach would divide the project into a series of cycles. Each cycle would consume 2-5% of the total financial budget and 2-5% of the total project time-while delivering some measurable, required results to the stakeholders. The next cycle is selected to deliver the best stakeholder value for its cost (highest ratio of value to cost, or highest ratio of performance to cost). Although an ideal approach can't always be realized, Tom provides some convincing examples to argue that there is always a solution to making a project evolutionary (small steps with critical deliveries first).

Perseverance pays off with Competitive Engineering. The book is not a quick read, which Tom acknowledges. You have to carefully study some of the pages to understand the concepts being presented. The reward occurs when you glean the nuggets of wisdom from the numerous practical examples, case studies, and Planguage examples. Tom's way of presenting the CE concepts makes the book a useful addition to the systems engineer's library.
... Read more

Product Description
This book focuses on metamodelling as a discipline, exploring its foundations, techniques and results. It presents a comprehensive metamodel that covers process, product and quality issues under a common framework.

Issues covered include:

• An explanation of what metamodelling is and why it is necessary in the context of software engineering.
• Basic concepts and principles of traditional metamodelling, and some existing results of this approach.
• Problems associated with traditional approaches to Metamodelling are discussed, alongside an exploration of possible solutions and alternative approaches.
• Advanced topics such as the extension of the object-oriented paradigm for metamodelling purposes or the foundations of powertype-based tool development will be studied.
• Finally, a comprehensive case study is introduced and developed, showing how to use many of the concepts explained in the previous chapters.

This book provides a comprehensive conceptual framework for metamodelling and includes case studies and exercises which will demonstrate practical uses of metamodelling. For lecturers and educators, the book provides a layered repository of contents, starting from the basics of metamodelling in the first chapters, through specific issues such as trans-layer control or non-strict approaches, up to advanced topics such as universal powertyping or extensions to the object-oriented paradigm. The book also serves as an in-depth reference guide to features and technologies to consider when developing in-house software development methods or customising and adopting off-the-shelf ones. Software tool developers and vendors can benefit from the book by finding in it a comprehensive guide to the implementation of frameworks and toolsets for computer-aided software modelling and development. ... 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

Managing Humans is a selection of the best essays from Michael Lopps web site, Rands In Repose.Drawing on Lopp's management experiences at Apple, Netscape, Symantec, and Borland, this book is full of stories based on companies in the Silicon Valley where people have been known to yell at each other. It is a place full of dysfunctional bright people who are in an incredible hurry to find the next big thing so they can strike it rich and then do it all over again. Among these people are managers, a strange breed of people who through a mystical organizational ritual have been given power over your future and your bank account. Whether you're an aspiring manager, a current manager, or just wondering what the heck a manager does all day, there is a story in this book that will speak to you.You will learn:

• What to do when people start yelling at each other

• How to perform a diving save when the best engineer insists on resigning

• How to say "No" to the person who signs your paycheck

Among fans of Michael Lopp is the incomparable Joel Spolsky, cofounder and CEO of Fog Creek Software:

"What you're holding in your hands in by far the most brilliant book about managing software teams you're ever going to find".

This book is designed for managers and would-be managers staring at the role of a manager wondering why they would ever leave the safe world of bits and bites for the messy world of managing humans.The book covers handling conflict, managing wildly differing personality types, infusing innovation into insane product schedules, and figuring out how to build a lasting and useful engineering culture.

Customer Reviews (41)

Content OK, book unreadable
The pages in Packt book look AWFUL -- it appears to have been printed from a JPEG, with artifacts everywhere.Really a shame.

Pretty easy read, and something to learn from it too.
This book is not your atypical text book style or instructional book.It really reads much more like a blog or fictional short story.I found it to be light, easy to read and laugh-out-loud funny at times.It also had a Dilbert-esq feel at times.I caught myself nodding in agreement and wondering when he had been employed at my office.The catch is, hidden in all the funny stories and apparent wanderings, are actually a lot of valuable tidbits of information.If you are a beginning tester or manager this probably isn't going to help you much, except to entertain you (or scare you as you contemplate your new career).For those of us with more than a few years under our belts, they are in there if you pay attention.Personally, I have to say it was nice to be learning something without it being done in a lecture or preachy style for a change.It was a breath of fresh air from the usual textbooks available.

Entertaining, but pointless
This book is somewhat entertaining to read and it has some good points for people looking to better understand management, however the style is too informal (not in a good way I think) and it reads more like someone's blog rather than a book. The author may be a good storyteller and a manager (or at least that's what he's trying to convey), but he isn't very good teacher. This work's sub-title is "Biting and Humorous Tales...", and that's what it is - not much more. There are lots of observations from the field, but overall result lacks coherence and at the end, you don't really learn anything new.
If you're looking for solid advice on the subject, look elsewhere.

Nice book cover, but nothing on the subject of managing people
At the very beginning of the first chapter, the author states, that the wonder of writing for the web is, that there is no real time schedule and apart from the fact that he always wanted to write a book, he really has no subject, that he want to mediate to the potential reader. That there are some recurring themes in the articles but no leading theme. Who the hell is this "manager of people" who is proud of having no schedule and theme?

After reading first five chapters of this book, it became clear, the author has next to nothing to say about the subject of managing people.

It's just random rants (that's the name of author's blog, from where most of the chapters in the book come), missing any structure and editing.

If you are totally new and trying to comprehend the role of your boss, this book is somewhat OK.
But if you are already in some kind of managing position, this book won't give you any clue on how to advance the relations with your subordinates.

After reading through the rest of the book in futile hope to discover some gems, which would be worth my effort, I can safely conclude that there are none.

If this is all the author has to say after being manager for 15 years, I'm afraid, he'd have done himself and the people he managed a favor, had he continued to pursue career in coding.

And yes, as some other reviews have noted, the tales are neither gripping nor funny.

A different kind of management book
Managing Humans is Michael Lopp's entree into blog-turned-book style that seems to be increasingly popular these days.And while the content from [...] has been edited and tweaked, a few reviewers have mentioned that it needs a bit more polish; I would agree.

While it has an amazing amount of insight into relevant issues delivered with surprising certainty, there isn't research, a philosophical premise, or numbers to back it up, only anecdotes that, while believable, are admittedly created for purpose.Lopp doesn't equivocate, and he doesn't present his views within the context of a greater argument or philosophy.As such, the book reads like a monologue about software companies from a drunk friend who you don't always see eye-to-eye with.

In this regard, the book is simultaneously annoying and stimulating.If you can stomach a point of view not frequently written in, and a blatantly unapologetic tone, it's worth the read.There are nuggets of wisdom to be found, but they are buried so deeply within the anecdotes, I found myself forgetting them after a few chapters.

I really wanted to like this book more, but it lacked a coherence that I may have mistakenly been expecting.Too bad there aren't half star ratings - 3 is a little short, but will have to do. ... Read more

Product Description

The art, craft, discipline, logic, practice and science of developing large scale software products is in increasing need of a trustworthy, believable and professional base. This book is one of a series of three volumes, devoted to fill this need. This series of strongly related text books combine informal, engineeringly sound approaches with the rigour of formal, mathematics based approaches.

Emphasis in the coverage of domain and requirements engineering is on ... Read more

Product Description

Although many software books highlight open problems in secure software development, few provide easily actionable, ground-level solutions. Breaking the mold, Secure and Resilient Software Development teaches you how to apply best practices and standards for consistent and secure software development. It details specific quality software development strategies and practices that stress resilience requirements with precise, actionable, and ground-level inputs.

Providing comprehensive coverage, the book illustrates all phases of the secure software development life cycle. It shows developers how to master non-functional requirements including reliability, security, and resilience. The authors provide expert-level guidance through all phases of the process and supply many best practices, principles, testing practices, and design methodologies.

For updates to this book and ongoing activities of interest to the secure and resilient software community, please visit: www.srsdlc.com

"Secure and Resilient Software Development provides a strong foundation for anyone getting started in application security. Most application security books fall into two categories: business-oriented and vague or ridiculously super technical. Mark and Laksh draw on their extensive experience to bridge this gap effectively. The book consistently links important technical concepts back to the business reasons for application security with interesting stories about real companies dealing with application security issues."

—Jeff Williams, Chair, The OWASP Foundation

Customer Reviews (2)

Secure Development and enterprise assurance programs
In the interests of full disclosure, I should start by noting that I am slightly biased.Both of the two authors, Mark Merkow and Laksh Raghavan, work on my team.

They are a perhaps an ideal pair of book authors because they have such complementary viewpoints and skills.I have known Mark for - good grief! - about twenty years.There is a great deal of solid theory that underpins information security, and Mark is one of few practitioners who both understand this theory, as well as know how to put it into practice.This is surprisingly rare.Laksh, on the other hand, is one of the best application security guys you'll ever meet.He knows the theory and the practice of both how to defend and attack applications.(They're both really nice people too, although that might be less relevant to their writing skills.)

Individually, they're both very strong.In combination, they and - therefore this book - are very, very good.The book builds from a firm theoretical foundation, and works up into a detailed explanation of the various ways in which applications and systems can be attacked, and how these attacks can be defeated by careful system design, coding and testing.It takes that and then moves into the ways in which enterprises can build full-blown programs to secure their applications, and finally into emerging industry standards such as BSIMM & OWASP.

I have a bunch of security books on my bookshelf, and the majority of the ones on secure / resilient software practices are not great.This, on the other hand is one of those rare books that is both interesting and informative on the first read, and very helpful as a reference work on subsequent reads.Strongly recommended.

Legal disclaimer - Please note that nothing in the above should be construed as anything other than the personal / professional opinion of this reviewer, and certainly not as the formal view of our employer.

The Quest for Secure and Resilient Software
"Secure and Resilient Software Development" by Mark Merkow and Laksh Raghavan is a really good book. It addresses a key security area that is generally given short shrift, even though purportedly more than 70 percent of breaches result from attacks on the application layer. The book is one of only a handful of texts about information security written by practitioners for practitioners.Even fewer practitioner books address software security ... and most of those have been written or co-authored by Mark Merkow! The majority of publications in the field of software security are written by academics or vendors' employees, both of whom have their own agenda. The former group is dominated by publishing or perishing; whereas the latter generally promote particular products or methodologies supplied by their employers. The true value of Mark and Laksh's book is that it is both impartial and extremely informative.

The book is comprehensive. It covers areas with which most infosec professionals and software developers are not likely to be familiar. For example, the authors recount the history of application security testing as far back as the Orange Book and Common Criteria (CC). Incidentally, Mark co-authored an excellent book on the CC, namely "Computer Security Assurance Using the Common Criteria" (Thomson, 2005). In the current book, issues with the CC approach are raised ... and by someone who should know!

Among the many useful chapters, I personally derived the most from Chapters 8 and 9, which are about testing custom applications and commercial-off-the-shelf software respectively. I also was interested in reading Chapter 11 on metrics and maturity models. I found the coverage of these topics to be extensive, although I have my own opinion regarding the lack of meaningful metrics for security in general and application security in particular.

I suspect, however, that many readers will be more interested in the design and coding phases of the SDLC (software development life cycle), rather than the testing phase. And these readers will not be disappointed. It was encouraging to see that resiliency is given top billing, as it is often neglected by developers, although software engineers might well see the importance of building resilient systems.

Having given the reader a taste of what he or she needs to know in order to produce or acquire secure and resilient software, the authors point the reader to sources of further education, including the various certifications that can be earned.

The book is rounded out with a very helpful glossary of terms, and a couple of appendices. The first covers the top 25 most dangerous programming errors (according to CWE/SANS), and the second describes OWASP's Enterprise Security API project.

All in all this is a book packed with valuable information for those designing, developing or supporting secure and resilient software. It is full of useful and actionable suggestions. And it fills a gap that really needed filling. It gives the reader a sound grounding and good understanding of the issues relating to the development of secure and resilient software and points the reader in the right direction for building further upon the base established by the book.

[This review was excerpted from a column published on [...] on July 19, 2010]
... Read more

Product Description
Teaches C++ by applying the best software engineering practices and methodologies to programming in C++. Shows the user how to build code that is more robust, easier to maintain and modify, and more valuable. Softcover. DLC: C++ (Computer programming language).Amazon.com Review
Aimed at the Visual C++ newcomer, Core C++: A Software Engineering Approach provides a rich and sometimes densely packed tour of the language, with plenty of advice on the best ways to use this powerful programming language effectively. It's full to the brim with useful advice for creating and using classes effectively, and gaining an expert's understanding of the language.

The writing style and presentation of C++ in this book are outstanding. The explanations of key C++ concepts, from basic language features to class design to advanced C++ whistles and bells, are by turns colloquial, garrulous, and almost always enjoyable and understandable. While it's not uncommon for today's computer book to weigh in at over 1,000 pages, the raw word count here is quite exceptional. You're challenged repeatedly to think for yourself, and the intricacies of C++ are exposed thoroughly, from language features that are indispensable to what to avoid in your code.

You'll get pretty much everything that you need to learn C++ effectively, starting with basic keywords, data types, flow-control statements, and arrays. The guide to understanding object-oriented concepts, like coupling and cohesion, will help you design better classes. Even experienced programmers will appreciate the thorough coverage of memory-management techniques in C++ (including the five kinds of scopes for variables).

An important middle section provides a blueprint for the methods and functions that most C++ code should offer, including such methods as default and copy constructors, destructors, and overloaded assignment operators. (By following this idiom, you'll be able to write reusable C++ classes.) The book also illustrates class design with basic UML notation, excels at presenting the details of how to overload C++ operators to provide easier syntax for custom C++ classes, and provides excellent explanations of the pros and cons of composition and inheritance for getting classes to work together. A look at more advanced C++ features, like templates and exception handling, wraps things up. Along the way, you get a taste of UML notation and a thorough introduction to some of the best practices for writing C++ code effectively.

Core C++ is certainly no quick read, and, if you're in a rush to learn quickly, there are plenty of more concise treatments that are available. But, if you're ambitious and want to master the intricacies of C++ class design with some of its underlying design principles, this is an original and thorough package that offers unique strengths. --Richard Dragan

Topics covered:

The software crisis Software project-management techniques Design-quality principles Introduction to the C++ language A minimum C++ application explained C++ data types Operators and flow control Arrays C/C++ structures Unions Enumerations and bit fields Memory-management techniques (including stack and heap allocation, dynamic allocation, avoiding memory leaks) File I/O with and without stream classes Basic C++ class design Parameter passing in C++ (options and best practices) Creating custom programmer-defined data types

Cohesion Coupling Data encapsulation and information hiding Guidelines for C++ class design: constructors (default, conversion, and copy constructors), overloading the assignment operator, destructors In-depth guide to overloading C++ operators Introduction to UML class diagrams Aggregation and inheritance C++ class syntax Inheritance vs. composition Virtual methods and late binding Multiple inheritance Advanced operator overloading techniques C++ templates and exceptions Standard C++ type cast operators Review of material covered

... Read more

Customer Reviews (27)

Very thorough
Recommended for anyone wanting to learn C++ and having experience programming in at least one other OO programming language.
The book is very thorough, sometimes excessively so. Yet it does a tremendous job explaining the inner workings of the language. I thought the memory management section was phenomenal. If it was up to me however, I would make a lot of chapters a bit shorter by eliminating less important features. Instead I would let the reader find out about those features via exercises.

Classic and Thorough
I picked this book up when it was first published in 2000, and thought it was one of the most thorough books on the subject of C++, to explain all the intricacies, the next best thing to having a professor standing next to you and explaining. Eight years later, I still think this is one of the best books. If you take the time to read it, you will walk away with deeper knowledge of C++.

Outstanding!
I can't praise this book enough for its style and clarity. Dr. Shtern has an unusual talent for speaking in terms that a beginning C++ user can understand and an experienced C++ user can appreciate. Far more than a "how to" book, it's also a "why to," a "when to," and a "why this is important (or not)" book. I won't try to say it all here; read the Amazon.com editorial review--it's right on the money. "Core C++" has been a real pleasure to read. Highly recommended!

C++ In-Depth
The author does an excellent job in explaing the details of how C++ works and its syntax. This book was the definite kickstart in me programming in C++. The only thing you must know is how to use a compiler. The author doesn't talk about compiling or setting up a compiler.

I highly recommend this book if what your looking for is understanding C++ at the smallest level.

Goran Ekstrom
As almost all of the reviewers state, very good book. It's not just an abstract syntax and "Fruit->Berry->Blueberry inheritance" paper like so many other C++ books out there. This book deals with the real world of software problem solving, something I as an active professional, not student, was searching desperately for when I found this book. ... Read more

Product Description

The essentials of UML 2.0 and how to use it in one concise volume.

Customer Reviews (4)

Good basic and quick book for UML
If you have a general idea of SDLC, this is a perfect book for you. It doesn't bring you into detail but good enough to give you a general idea of all the static and dynamic diagrams. This is also a great book for students who do not want to dig too deep into a concept and not knowing how to apply them.

EQ.

Indepth, but hard to follow
I found this book very hard to read at times, and tedious at other times. If you can stick with it long enough, it starts to make sense, and there as a ton of very good information to be found. It is well written and logically organised, I just wish it were a bit more enjoyable to read.

Very good for STUDENTS
This book touches on all the right subjects but does not go -in my opinion- deep into any. I like the sequence in which the information is organised and presented. It is nice to include case studies, but I am not sure about the completeness of the case studies or if, in fact, these can be implemented from the design provided. It is a novelty to provide discussion topics very often throughout the text, but it would have been better, if not essential, to discuss the issues in the text or direct us to some other resource where the discussions take place. All in all, there are other books that do the job better of introducing UML or discussing advanced issues, but this text is probably the best to be used on an undergraduate course. Its value to software engineers in the industry, though, is questionable.

Informative, question and answer style.
The book is written in an Question/Answer format (i.e., FAQ).Very different from the rest of the UML topics, narrative or reference styles provided in most UML books.Unfortunately, the price seems a little steep,until you consider that there are some valuable bits of information in thisbook that seem to be missing from most UML books.Mostly the"why?" of UML.That makes the book worth every penny.If youare deep into UML and want answers to some of the more obscure issues, thisis a good book to read through. ... Read more

Product Description

Software development is a complex problem-solving activity with a high level of uncertainty. There are many technical challenges concerning scheduling, cost estimation, reliability, performance, etc, which are further aggravated by weaknesses such as changing requirements, team dynamics, and high staff turnover. Thus the management of knowledge and experience is a key means of systematic software development and process improvement. "Managing Software Engineering Knowledge" illustrates several theoretical examples of this vision and solutions applied to industrial practice. It is structured in four parts addressing the motives for knowledge management, the concepts and models used in knowledge management for software engineering, their application to software engineering, and practical guidelines for managing software engineering knowledge.

This book provides a comprehensive overview of the state of the art and best practice in knowledge management applied to software engineering. While researchers and graduate students will benefit from the interdisciplinary approach leading to basic frameworks and methodologies, professional software developers and project managers will also profit from industrial experience reports and practical guidelines.

Customer Reviews (2)

Probably the most important software title I own
We used this book in the class that introduced me to software engineering.I shared it with co-workers at my job, and we literally rebuilt the way the company handled software from the ground up.Primarily in FORTRAN, noless.It covers pretty much all phases of the project lifecycle, fromrequirements to delivery.It's not a course by itself, but the principlesare crucial.Although a few things are now out of date (such as thewaterfall model) it's still an important book.Yourdon doesn't take sides,either - he includes the papers both for and against the GOTO statement. Hardly politically correct, and therefore the icing on the cake.If youcan possibly get your hands on this book, do so.

Where Software Engineering (and more) began
Really, Ed Yourdon titled his book perfectly: this volume brings togethermany of the most vital articles from the early days of what wasn't yetcalled software engineering, making a book that no serious programmershould be without.Yourdon's introductory remarks that set each article inits context are thoughtful and brief.They do their job and then get outof the way of what is, of course, the soul of the book: the articles.Notonly Dijkstra's notorious _Go To Statement Considered Harmful_, but alsohis _Programming Considered as a Human Activity_, arguably the opening shotof the structured programming movement.And so much more: Parnas ondecomposing systems into modules, as relevant today as when it was written;the early paper by Stevens, Myers, and Constantine on structured design;papers by Baker, Mills, Kernighan & Plauger; and Knuth's wonderful,provocatively titled _Structured Programming with go to statements_.Ifyou don't recognize any of these names you've missed out on the very basisof modern software practice; if you haven't read all of the articles inthis volume, you could stand to improve your familiarity with thatfoundation.If you haven't read any of these in years - why, isn't it timeto refresh your acquaintance?

GET THIS BOOK BACK IN PRINT!Not leastbecasue I want to replace my copy that's literally falling apart. ... Read more

Product Description
From the SEI, a practical roadmap that allows readers to deliver improved business value through modernizing legacy software systems. Softcover. ... Read more

Customer Reviews (3)

Excellent Overview
This book describes the process and technologies involved in updating a legacy system.Chapters 1 through 4 do a very good job of describing the problems inherent in working with legacy systems, which the authors define simply as having "code that was written yesterday." I couldn't agree more with their perspective. Once code is written, it needs to be maintained, updated, and managed, whether it is COBOL, Fortran, PowerBuilder or Java; all code becomes legacy code once it is written.

Early in the book, the authors present a Unified Modeling Language (UML) activity diagram to describe their proposed process for updating legacy systems. They then open each chapter by depicting where they are in the process -- from Portfolio analysis completed (modernization candidates selected) to Modernization plan defined.The book defines ten main steps and two checkpoints for completing this process, including decision points to determine whether modernization is the correct choice.

To describe the process in detail, the authors follow a legacy system modernization project over the course of the book. As process experts from the Software Engineering Institute (SEI), they consulted on this project, which was to update and Web-enable a primarily COBOL retail supply system. The case study helps readers understand the flow of the process the authors recommend and brings reality to their suggestions, although at times they abandon the "story" and go into overly minute detail, discussing every process option they could have chosen. I would have liked them to focus more deeply on the option they did choose, and to discuss at greater length how to be successful with that option (or any other).A good example of this is the discussion in Chapter 4 around requirements.The authors do a good job of describing where to get requirements from, but never discuss good processes and techniques for gathering those requirements.In most situations I have been involved in around requirements, knowing where to go wasn't much of a challenge, but knowing how to elicit them was.

The book does a good job of describing the different technologies the project used as well as others available for modernization efforts -- Java/J2EE, Web Services, wrapper code, and different packaged systems -- providing an overview of each technology as well as customized ways to write integrations from the legacy systems to modern ones.They discuss screen scrape technologies as well as screen rewrites, but focus mainly on modernizing the software. This was a little disappointing: Based on the title, I expected to see discussions of all the hardware, software, development processes and additional technologies involved in modernizing systems.

Overall, however, I learned a lot from the book, and it confirmed many of my beliefs about the importance of modernizing legacy systems and the best approaches to use. The authors provided good strategies for understanding systems that are already in place starting with the workflow they follow throughout the book.They then go into examples which include modeling, requirements management and the process they followed.What was a bit lacking is the actual process for implementation. The book focuses primarily on understanding what you have, designing for change, and planning how to get where you want to go, but it doesn't go far enough into what you actually have to do to get there.I would recommend this book for people who need a better understanding of the processes and technology decisions you must make made when building software systems. For most of us in the industry, no matter what we are working on, there's probably a legacy system involved in some way.

A Legacy Migration Classic
If you have ever had the task of migrating legacy code and data to a new system you know how complex that task can be."Modernizing Legacy Systems" covers all the bases of migrating a legacy system in wonderful detail without being overly wordy or obscure.System and software engineers will recognize and appreciate the fact that this book bases its advice on real world experience - the kind you get only from working on complex projects.

A well-defined plan of migration is presented early on for a complex retail supply system migration.Each phase of the plan is presented and explained in detail - covering both management and development perspectives equally well.For those of us who spend our days in a developer's world, the additional information on managing the migration effort contributes the right mix of information for what we are tasked to accomplish.I appreciated the technical specifics that were included throughout (i.e., utilizing Enterprise Java Beans) so that I didn't need to use my imagination as to how this plan would fit into my current project.Everything you need to know about legacy migration and then some is covered in this book.I knew that when I started to agree with what I was reading (aka Been There Done That) and could relate what was in the book to my own experience that I had found a winner.

This book is a good read and a great reference guide to help you get through a large, complex legacy migration.When you finally finish the book, take another look to capture all the detail you missed on your first read-through.

Methodical Resolution of Pivotal Issues
Addressing a timely and vital topic, 'Modernizing Legacy Systems' is an excellent book from the standpoints of both content and presentation. The advocated approach, which is termed the Risk-Managed Modernization (RMM) Approach, is synopsized on page 28 in UML activity diagram form. The exposition in the subsequent chapters is keyed to corresponding activities in this diagram. This key makes it quite easy to situate and interrelate the coverage of the respective chapters in the context of the RMM Approach. I found this recurring orientation feature to be very helpful in understanding and integrating the book's content.

The book describes, rationalizes, and selectively illustrates the RMM Approach, where the continued availability of the legacy system capabilities is necessary over the sequence of modernization increments.While the approach is illustrated through an incremental transformation of a legacy COBOL-based system to a Java-based derivative, the RMM Approach is nevertheless applicable to other modernization problems or technologies. Moreover, the book does an exceptionally good job of interweaving explanations with examples. These examples are modest but salient and revealing, thereby avoiding unwarranted detail or distractions.

The advocated approach is at once both architecture-centric and component-centric. Architecture centricity captures and sustains a rather specific vision of the as-desired system, and the associated target architecture provides a stable reference over the various modernization activities. Component centricity enables the identification, analysis, grouping, and ultimate realization of system elements that are allocated to the respective modernization increments. Overall then, the target architecture establishes the initial and termination points of a modernization project, and the componentization installments determine the actual redevelopment trajectory connecting the project end points.

For me, the most intriguing, innovative, and vital parts of the approach appear under the RMM activities labeled Define Modernization Strategy and Reconcile Strategy with Stakeholder Needs (Chapters 13-15 and Chapter 16, respectively). Basically, the modernization strategy provides a systematic approach to delineating, analyzing, and grouping modernization elements through an examination of the legacy system implementation, subject to project constraints and certain prior higher-level technical decisions. Then, the finalization of element groupings into sequential increments is determined using programmatic preferences of the various stakeholders. This two-stage definition of modernization increments is driven prominently by cost and risk considerations, as well as by programmatic and technical factors. Ultimately, the designated increments establish waypoints on the aforementioned redevelopment trajectory, thereby identifying interim architectural configurations that facilitate closure on the target architecture, while simultaneously maintaining user capabilities during the modernization effort.

In all, 'Modernizing Legacy Systems' is a readable, coherent, illuminating, and surprisingly broad treatment of a vital topic. Hopefully, the RMM Approach or variants thereof will see widespread use in industry, thereby exploiting "a systematic and fact-based method that avoids arbitrary, intuitive decision making..." ... Read more

Product Description
For over 20 years, "Software Engineering: A Practitioner's Approach" has been the best selling guide to software engineering for students and industry professionals alike. The sixth edition continues to lead the way in software engineering. A new Part 4 on Web Engineering presents a complete engineering approach for the analysis, design, and testing of Web Applications, increasingly important for today's students. Additionally, the UML coverage has been enhanced and signficantly increased in this new edition. The pedagogy has also been improved in the new edition to include sidebars. They provide information on relevant softare tools, specific work flow for specific kinds of projects, and additional information on various topics. Additionally, Pressman provides a running case study called "Safe Home" throughout the book, which provides the application of software engineering to an industry project.New additions to the book also include chapters on the Agile Process Models, Requirements Engineering, and Design Engineering. The book has been completely updated and contains hundreds of new references to software tools that address all important topics in the book.The ancillary material for the book includes an expansion of the case study, which illustrates it with UML diagrams. The On-Line Learning Center includes resources for both instructors and students such as checklists, 700 categorized web references, Powerpoints, a test bank, and a software engineering library-containing over 500 software engineering papers. ... Read more

Customer Reviews (3)

An excellent SE text
This tome of Dr. Pressman's was used as the primary text for several of my graduate-level software engineering classes.As such, it does its job quite well, providing a comprehensive overview of the SE process and its related practices and tools.Well-written (and at times humorous) fictional case studies make the book enjoyable to read.All phases of the software design lifecycle - requirements engineering, analysis modeling, design modeling, unit testing, regression testing, QA, SCM, V&V, etc. - are covered in sufficient depth.Modern SE methodologies, such as Agile, XP, and Scrum, are also introduced.

One strength of this text is its detailed exposition of the usage of formal mathematical methods in the specification and verification of software (the section on "cleanroom" SE is especially thought-stimulating).However - to its discredit - the text gives a little too much credence to highly-questionable metrics-analysis methods such as LOC (lines-of-code) and FP (function point) metrics.As anyone who has spent a considerable portion of his/her career writing complex software can tell you, the LOC of a routine, or the number of inputs it accepts, often has little to do with the difficulty/complexity of the routine in question.For example, a 100-line, four-input routine that performs a complex mathematical calculation will be incomparably more work-intensive than, say, a 500-line, eight-input routine that displays database records on a user-interface window.

Despite this small idiosyncrasy (keep in mind that no textbook is perfect), I wholeheartedly recommend this text to graduate CS/IT students as well as to working professionals who want to implement process-driven paradigms into their workplaces.

Not practical at all.
When your interest fall in software engineering, there are *lots* of books on the subject but only a few of them cover the principles in an almost exhaustive way. One of the main errors that authors do is having the claim that all about software engineering can be covered in a single book. And this book is no exception. When you're reading a textbook, this isn't always bad: one of the main purposes of a textbook is introducing the concepts gradually, without much details and in the clearest way possible. A student doesn't need to know all. He/she just need to understand the fundamentals of the discipline. So, while this book is intended for a professional audience, it is structured like a textbook. The problem here is that it gives probably too much informations for students and too few informations for professionals. It gives a nice introduction on the subject, explaining why the software is a product, its features, its lacks and its myths (very interesting). Problems start with chapter 2: the process. While something is covered about some development models like waterfall, win-win model, RAD, concurrent, etc., it lacks any detail needed to really understand these development models and bring them in practice. One of the things I hate the most about this book are repetitions: the author repeat the same concepts many times during the exposition and this can be irritating. It covers many subjects, like user interface construction, project planning, temporal planning, quality assurance in software development, software architectures, component based engineering, conceptual modeling, etc. Each chapter is a small introduction to these subjects but the book gives small or no details at all on how to use these concepts in practice. You won't find code here. You won't find design patterns, UML diagrams, state charts, refactoring methods. While this is not necessarily bad, it makes clear this book is better used as a textbook and not as a practical (for practitioners) manual to learn software engineering methodologies directly on the field. So, if you're interested in software engineering and you want a solid introduction to it, buy this book. If you're a professional who want a practical exposition of the discipline to apply concepts on real projects, skip this book. I give it 3 stars because explanations are good and the book is well written but the title is a bit misleading: professionals generally needs other kinds of books.

Good Book
Very good book. I am enjoying reading it (not complete yet, it is really very big book). The topics are covered at length. Very good coverage of important concepts with amazing knack of not making the subject boring or dull. Very nice suggestions / references / advices for further study. A A very good read for software engineering professionals. ... Read more

Product Description
Showing Xbox owners how to increase the value and utility of their system, Hacking the Xbox features step-by-step tutorials on hardware modification that teach basic hacking techniques as well as essential reverse engineering skills. Full discussions of the Xbox security mechanisms and other advanced hacking topics are here, along with practical pointers from hacking gear resources to soldering techniques. The book also covers the social and political implications of hacking and profiles the humans behind the hacks in candid interviews.Amazon.com Review
This--this being the attitude encapsulated in Andrew "bunnie" Huang's Hacking the Xbox--is why a lot of people got into the computer industry in the first place. These people liked taking things apart and figuring out how they worked, then making them serve purposes they weren't originally designed for and sharing the new discoveries with others of like mind. Sure, Huang's book is about how to how to turn Microsoft's game console into a high-performance, general-purpose personal computer with a small price tag, and it contains lots of details about the how the heavily advertised gizmo is put together. But you can get the technical material on the Web. What's valuable about Huang's work is that he communicates the pure joy of taking the Xbox apart, figuring out how it works--despite its many designed-in anti-hacking features--and making it do new things. This book reads like the journal of a seventeenth-century voyage of discovery.

There's a wealth of information in these pages about how to disassemble and reverse-engineer electronics, and Huang is careful to show you what tools you need, and how to use them (don't worry if you don't know how to use a soldering iron--that's covered here). There also are step-by-step guides (complete with photos) to a couple of projects, and interviews with key figures in the Xbox-hacking community. --David Wall

Topics covered: How to enjoy a Microsoft Xbox game console without the mindless tedium of playing video games. This book shows you how to open an Xbox, make modifications to it (from a cosmetic LED color change, to putting in a new power supply, to adding a USB connector), and make the changes needed to get Linux running on it. In the process, readers get an education in reverse engineering electronic circuits, as well as in basic electronic techniques (soldering, crimping, etc) and in the intellectual property law that governs hacker activity. ... Read more

Customer Reviews (27)

God!! it is being cited 46 times...
Did you believe that this book is cited 46(34+12) times by academic? Just trace the Google scholar! Oh my God.

Bunnie inspires a budding computer engineer
I bought this book for my then teenage son who wanted his XBox to do more than what Mr. Gates wanted it to do. Phil astounded me with the skills he developed in soldering, mechanics, and searching for the resources he needed.

Bunnie goes into great detail to explain not just how to do the job physically, but weaves a tale of how Microsoft has attempted to secure the XBox and leads the reader along a road of computer hardware discovery.

Well it worked. Phil not only turned his XBox into a fully-functional linux box but he became inspired and this year graduated from college as a computer engineer.

Thanks, Bunnie.

Fascinating read, short on actual projects
I purchased this book because I would like to learn about reverse engineering without getting a degree.Tinkering with an Xbox, which can be purchased for less than $50, sounds like a great idea.The book, sadly, is short on actual projects to learn from.The vast majority is about hacking, reverse engineering, and legal issues related to these activities.The book is well written and the arguments for the freedom to reverse engineer and invent in your own garage beautifully argued.It made for a really great read but left me wanting regarding the original reason I purchased it.

Peerless
This is an absolute MUST BUY for everyone who likes to tinker with electronic devices - it's like porn for hardware hackers :)

Bunnie's description of how he and the XBox hacking community came to circumvent the XBox's security infrastructure is a wonderful tale in itself. The fact that Bunnie describes the methodical approach taken, with its several false-starts and failures to its eventual success is a great lesson for hackers everywhere - a systematic approach (plus a smidgen of luck and more than a little inspiration) is generally the only way to overcome significant odds.

But this book offers far more than just the story of how the XBox was hacked and the ... ahem ... wonders of the DMCA - it is an invaluable guide to anyone interested in creating their own devices. The sections on soldering techniques, board manufacturing, etc., equipment suggestions, etc., is a boon to anyone who has an urge to create something rather than just dream about it.

I have been hacking hardware ever since I was 7 and I took apart my record player trying to work out how they managed to fit all four of the Beatles into such a small space! I have obsessively dismantled practically every electronic device I've ever owned and built several electronic devices from scratch more than I can count. I have a degree in Computer Science & Microelectronics and have worked on teams building missile guidance and weapon aiming technologies. And yet, I've learned more practical skill (as opposed to theoretical knowledge) from this book than my entire 1st year at college.

So, if you're interested in tinkering with hardware or are interested in how others do it, do yourself a favor and order this book now. You won't be disappointed :)

Good Reading
Very good book if you are a beginner at computer/xbox mods.Need to have a little electrical knowledge to understand a lot of what is in the book.It is not a how-to book, but a book that will make you think and try stuff on your own.Lot of information on copyrights, DCMA and stuff like that.A great book to show how to get started, methods that can be used, and computer structure.If you are a computer wiz, then this book would seem basic, if not this would be a good book to read before you start hacking. ... Read more

Product Description
The modern field of software metrics emerged from the computer modeling and "statistical thinking" services of the 1980s. As the field evolved, metrics programs were integrated with project management, and metrics grew to be a major tool in the managerial decision-making process of software companies. Now practitioners in the software industry have a reference that validates software metrics as a crucial tool for efficient and successful project management and execution.Software Metrics: A Guide to Planning, Analysis, and Application simplifies software measurement and explains its value as a pragmatic tool for management. Ideas and techniques presented in this book are derived from best practices. The ideas are field-proven, down to earth, and straightforward, making this volume an invaluable resource for those striving for process improvement. This overview helps readers enrich their knowledge of measurements and analysis, best practices, and how ordinary analysis techniques can be applied to achieve extraordinary results. Easy-to-understand tools and methods are applied to demonstrate how metrics create models that are indispensable to decision-making in the software industry. ... Read more

Customer Reviews (2)

Solid introductory text
This is among the best introductory texts on software metrics I've read in a long time. The author carefully and meticulously leads you through the basics of measurement and metrics, including some interesting views about how measurement is an integrated activity that has three distinct phases - cognitive, semantic, and quantitative.

Key software metrics are covered, divided into simple and complex classes, and traced to quality standards and a common metrics vocabulary.This part of the book is solid and especially suited to someone who is exploring software metrics and may have been put off by the dense, overly technical approach in other books.

Like the preceding material, the chapters on designing a metrics system and data visualization are basic, but straightforward.I especially like the three chapters on data analysis that classify metrics into frequency, time and relationship domains. This is one of the clearest approaches to cutting through the complex morass of data analysis, and will put metrics into perspective instead of overwhelming.The next chapters, covering process and estimation models were adequate in my opinion.They covered the essentials.However, the chapter on defect metrics was outstanding.I liked the complete and concise coverage of this topic.

The remainder of the book ramped down and seemed to lack the detail or clarity that characterizes the preceding parts of the book.However, this material was more operational and not (in my opinion) as important as communicating the fundamentals, collection and analyses, or metrics classification that were so exceptionally well covered in this book.I highly recommend this book to anyone who wants to quickly learn the basics of software metrics.

Measuring Software
This book is written poorly and it does not provide any information about measuring software. It simply rehashes theoretical statistics taught in 101 and that too in a difficult and hard to understand way. ... Read more

Product Description
A recent survey stated that 52% of embedded projects are late by 4-5 months. This book can help get those projects in on-time with design patterns. The author carefully takes into account the special concerns found in designing and developing embedded applications specifically concurrency, communication, speed, and memory usage. Patterns are given in UML (Unified Modeling Language) with examples including ANSI C for direct and practical application to C code.

A basic C knowledge is a prerequisite for the book while UML notation and terminology is included. General C programming books do not include discussion of the contraints found within embedded system design. The practical examples give the reader an understanding of the use of UML and OO (Object Oriented) designs in a resource-limited environment. Also included are two chapters on state machines. The beauty of this book is that it can help you today. .

*Design Patterns within these pages are immediately applicable to your project
*Addresses embedded system design concerns such as concurrency, communication, and memory usage
*Examples are contain ANSI C for ease of use with C programming code ... Read more