Amazon.com
Good software starts with a good design, and the subtitle of Applying UML and Patterns, "An Introduction to Object-Oriented Analysis and Design (OOA/D) and the Unified Process" reinforces that that's what this book is about.
The first edition of Applying UML and Patterns became a standard. The second edition uses the unified process (UP) as the iterative process within which OOA/D is introduced, and extends the case study used in the first edition. Other changes have been made to reflect the growing consensus on the most effective ways to work with OOA/D and patterns.
Although you will learn UML, this isn't what Applying UML and Patterns is all about. It's designed to teach you to think of software as a collection of objects with properties and to manipulate the relationships between them. This is far more profound.
The case study enables Craig Larman to carry the design through to Java code. In practice, you will need a basic understanding of OO programming to benefit from Applying UML and Patterns, though you needn't know Java--you can implement the designs in the OO language of your choice with equal facility.
When it comes right down to it, Applying UML and Patterns is all about providing you with a language in which to think about software design. This is quite different from learning a language in which to code a design.
A facility with OOA/D will enable you to design and discuss programs independent of code, to produce more elegant and maintainable software, and to take a 30,000-foot view of the way your software interacts with the world. In effect, it can shift your viewpoint from that of a mechanic to that more sophisticated viewpoint of an engineer. Recommended. --Steve Patient. Amazon.co.uk
Book Description
“People often ask me which is the best book to introduce them to the world of OO design. Ever since I came across it, `Applying UML and Patterns' has been my unreserved choice.” —Martin Fowler, author, “UML Distilled” and “Refactoring”
The first edition of “Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design” quickly emerged as the leading OOA/D introduction; translated to many languages and adopted in universities and businesses worldwide. In this second edition, well-known object technology and iterative methods leader Craig Larman refines and expands this text for developers and students new to OOA/D, the UML, patterns, use cases, iterative development, and related topics.
The book helps newcomers to OOA/D learn how to “think in objects” by presenting three iterations of a single, cohesive case study, incrementally introducing the requirements and OOA/D activities, principles, and patterns that are most critical to success. It introduces the most frequently used UML diagramming notation, while emphasizing that OOA/D is much more than knowing UML notation. All case study iterations and skills are presented in the context of an “agile” version of the Unified Process -- a popular, modern iterative approach to software development. Throughout, Larman presents the topics in a fashion designed for learning and comprehension.
Among the topics introduced in Applying UML and Patterns are: * requirements and use cases, * domain object modeling, * core UML, * designing objects with responsibilities, * “Gang of Four” and other design patterns, * mapping designs to code (using Java as an example), * layered architectures, * architectural analysis, * package design, * iterative development, * the Unified Process.Foreword by Philippe Kruchten, the lead architect of the Rational Unified Process.
“Too few people have a knack for explaining things. Fewer still have a handle on software analysis and design. Craig Larman has both.” —John Vlissides, author, “Design Patterns” and “Pattern Hatching”
“This edition contains Larman's usual accurate and thoughtful writing. It is a very good book made even better.” —Alistair Cockburn, author, “Writing Effective Use Cases” and “Surviving OO Projects”
Customer Reviews:
A great reference, had to get the UML 2.0 edition.......2007-10-06
I found the previous edition 5 years ago, and completely marked it up. This book was instrumental in passing the OOAD test certification.
I continued recommending this book to my colleagues.
Then found the UML 2.0 edition, and plan on using this book as much as I did.
First book for anyone learning to create business software.......2007-08-11
Craig Larman's classic has reach 10 years of prime position on my professional book shelf, the 1st edition now replaced with the 3rd. Whenever anyone asks for an introduction to UML, this is always my first recommendation. Though the book focusses on software construction from scratch, it still contains much brilliant guidance for enhancement work or implementation of software packages.
This book takes you in a logical, distilled process through pragmatic application of Unified Modelling Language on real projects for which people pay. Of course the examples are simple, but relevant and helpful. The book is chock full of diagrams and little text, which makes it quick to read and easy for reference.
You could do little wrong if you used only this book to guide your first application of UML to a real project.
Review of Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development (3rd Editi.......2007-07-19
I have 30 years in the industry (and in different industries in IS management) and one thing I dislike is the author's persistence do down-grade the waterfall or modified waterfall models. He should be more objective on his comments since the waterfall and modified waterfall do have their merits on projects -- refer to "Rapid Development, Training Wild Software Schedules" by Steve McConnell, Microsoft Press, ISBN 1-55615-900-5. I have used them very successfully on big programs. The key here is, with any model, in order to be successful you need quality communications with ALL stakeholders. Just like in our personal life's, communications is everything; the models can be secondary.
The author should also strictly follow the attributes of writing good requirements. On page 72, he wrote for "frequency of occurrence", "Could be nearly continuous". Now, I ask, how ambiguous is that????
The single best book for your OO development team.......2007-07-06
As others have pointed out, the content on OO analysis and design is excellent. Equally important - Larman's book is also an excellent on "process".
Unlike many books that simply focus only on "programming", Larman gives you a working examples and excellent advice on overlapping fields like "requirements", "testing", "architecture" and "project management".
Craig Larman's "Applying UML and Patterns, 3rd Ed" is a wealth of practical advise, covering *all* significant aspects of successfully defining and implementing a non-trivial software project. If your team were to choose only one book as your "Bible" - this would be that book.
Excellent Work!.......2007-04-23
As pointed out by many, this book is a very nice introduction to Object Oriented Analysis and Design. The author's explanations were very clear. This book covers agile practices, UML, many patterns including Gang of Four (GoF), and software architecture. Overall I really enjoyed reading this book. From an industry standpoint as well as an academic standpoint, I believe this book does an excellent job. This book will be part of my library for a long time to come. Highly recommended.
Book Description
The Rational Unified Process embodies the best practices of proven
software development methods, and is an optimal match to the features
of the UML.
--Grady Booch, Ivar Jacobson, and James Rumbaugh
This concise book offers a quick introduction to the concepts,
structure, content,and motivation of the Rational Unified
Process. This revolutionary software development process provides a
disciplined approach to assigning, managing, and completing tasks
within a software development organization and is the first
development process to exploit the full capabilities of the
industry-standard Unified Modeling Language. The Rational Unified
Process is unique in that it captures many of the proven best
practices in modern software development and presents them in a form
that can be tailored to a wide range of projects and organizations.
The Rational Unified Process will help software development teams
produce, within a predictable schedule and a reasonable budget, the
highest-quality software possible to meet the needs of end
users. Throughout the book, the author shares his inside knowledge of
the process, focusing his coverage on key aspects that are critical to
mastering this proven approach to software development.
In this book you will discover:
What the Rational Unified Process is--and what it is not
The concepts used in the Rational Unified Process, as well as its structure
The best practices that have been synthesized in this process
How this process can provide the guidance you need for your specific project responsibilities
Customer Reviews:
All fluff, no substance.......2005-09-16
It's an introduction, all right. The trouble is, it's such a high level introduction that there's almost no useful information whatsoever. The entire time I was reading, I was waiting for the author to get to the meat, only to discover at the end that there was none. It was like ordering a double cheeseburger, and getting two buns with ketchup and a pickle, and no beef patties.
I can only assume that Rational paid the author for his time in the hopes that people, after reading this book, would purchase their entire software suite just to find out what the RUP actually involves.
Despite my severe disappointment (and relief that I didn't have to pay for it myself), I can't rate it any lower than two stars. It's well written, and it could quite possibly be useful to managers and other business types who have no idea how software development works. The second star is for Rational's sheer chutzpah in getting a respected publisher to put out a $30 marketing pamphlet for them.
Not a book to teach you how to use RUP.......2004-06-14
This book introduces the logic behind Rational Unified Process (RUP). RUP is a novel idea. It puts several good practices in a consolidated package. What makes RUP useful is the fact that Rational provides all the necessary software tools to support this. This book does an average job in explaining the RUP. It over stresses obvious and well accepted concepts like "iterative development"; which makes the first half (6 chapters) of this book a bit boring. For a professional with software development and management experience, I found the first sixe chapters are best read at a cursory glance. The second half of the book introduces the workflows - and it is this half that I found more interesting. I finished this book as bed time readoing over the weekend - so this book is an easy reading. However this book is not about teaching how to use Rational Products. This book only gives an overview of the basis of origination of RUP. You would need another book to become an expert in using RUP.
A good overview of the entire RUP framework..........2004-05-10
Target Audience
IT professionals who need to learn about the Rational Unified Process (RUP)
Contents
This book is a relatively high-level overview of the entire RUP process.
The book is divided into the following chapters: Software Development Best Practices; The Rational Unified Process; Static Structure: Process Description; Dynamic Structure: Iterative Development; An Architecture-Centric Process; A Use-Case-Driven Process; The Project Management Discipline; The Business Modeling Discipline; The Requirements Discipline; The Analysis and Design Discipline; The Implementation Discipline; The Test Discipline; The Configuration and Change Management Discipline; The Environment Discipline; The Deployment Discipline; Typical Iteration Plans; Implementing the Rational Unified Process; Summary of Roles; Summary of Artifacts; Acronyms; Glossary; Bibliography; Index
Review
The Rational Unified Process, or RUP, is a software engineering methodology that attempts to map out and document all parts of a software development project. It's extremely comprehensive, but it's also adaptable to whatever level of effort is appropriate for your situation. This book, The Rational Unified Process - An Introduction, is a good start to begin your understanding of RUP.
First off, let me say this is not an easy read. It's a good book with all the information you need to know to start using RUP, but the information is dense and highly detail oriented. Like most developers, I'm more oriented towards coding and testing. But realistically, you need to know what the system should do before you get to the coding piece. RUP helps to put all that into a formal framework so that the necessary things will get done in the proper order.
While the entire RUP framework might feel overwhelming, the author makes sure to let you know that you can adapt the RUP to meet your situation. If you are adding a function to an existing system, you will be more focused on use cases, development, and deployment processes. The author does a good job in segmenting the information so that you can more easily focus on your needs.
You should also not consider this the end-all volume on RUP that you will ever need. Kruchten doesn't try to detail specific techniques like use cases or UML. You will learn where they fit in to RUP, but you will need additional information on how to implement use cases or UML diagrams. Consider this the volume that allows you to place everything in a mental framework so that you can figure out what you will need to know going forward.
Conclusion
If you are considering or in the process of implementing RUP, this is a book you should be studying. It's not an easy read, but it will give you the overview you need to understand the process and concepts.
If you are interested in RUP, this is the place to start........2004-05-08
The Rational Unified Process (RUP) was originally developed by Rational Software, which was recently purchased by IBM. Therefore, you now see the RUP sometimes referred to as IBM's Web-enabled software engineering process. As this name implies, it is a set of guidelines, some soft and others fairly rigid to the point of being a rule, for the creation of software. Like all useful principles of computer science, the RUP is a dynamic entity, being constantly modified to reflect the changes taking place in software creation. Therefore, if you are already familiar with the RUP and are wondering if you should read this book, the answer is an emphatic yes. If you are unfamiliar with the RUP, the answer is an even more emphatic yes.
The purpose of this book is to provide an introduction to RUP 2003, the latest iteration of the process. Like the previous books on RUP, it is written at a level suitable for managers. There is some necessary technical jargon, but nothing beyond what a software project development manager would be expected to be able to comprehend.
The book opens with a history of the RUP, what it is used for and the overall structure of the RUP. This is followed by a very brief introduction to fundamental concepts such as iterative development, architecture-centric processes and use cases. Necessary for beginners, most of this material can be skipped by those having experience in those areas.
Part II covers the various areas, referred to as disciplines. They are:
* The project management discipline.
* The business-modeling discipline.
* The requirements discipline.
* The analysis and design discipline.
* The implementation discipline.
* The test discipline.
* The configuration and change management discipline.
* The environment discipline.
* The deployment discipline.
While the steps used in the analysis differs from discipline to discipline, the following are common to all:
* Purpose.
* Roles and artifacts.
* Workflow.
* Tool support.
* Summary.
The tool support section is particularly helpful if you are evaluating the RUP for possible use in your organization. IBM/Rational has many tools that can aid you in your efficient use of the RUP. In fact, without software tools to aid you, much of the material in this book would be of theoretical interest only.
Large software projects require an overall organizing process to be imposed on them if there is to be a chance for successful completion. The RUP is currently one of the best such processes and this book will show the fundamentals of the process and how it can work for you.
Definitive.......2004-04-15
First of all, please let me clarify something. In another review of mine (for the book "The Rational Unified Process Made Easy" of Kroll & Kruchten) I mentioned that there are 3 books on the RUP. Well, this might have been true in August of 2003, but it is not anymore: There are 3 more books on the RUP out there, namely:
- "Adopting the Rational Unified Process"
- "Software Development for Small Teams"
- "Practical Software Engineering" (.NET-oriented)
To be frank, I found the "Made Easy" book to a be a bit more fun than this one. Probably, because this book is more descriptive, whereas the "Made Easy" one is more normative. Having said that, I feel this book is the definitive book to have if you
are working with the RUP, and a heck of a useful book to read even if you're not. Especially now that everything Rational has gained more leverage (because of the acquisition of Rational Software by IBM that gives RUP an arguably more powerful marketing mechanism and exposure, let alone its plausible gradual integration into the methodologies used by the 150,000-people-strong IBM Global Services organization), this book becomes even more relevant.
There is a foreword by Grady Booch (one of the 3 amigos) that goes though a can-never-remember-how-many thousand mile view of the whole landscape, followed by a chapter by the author, who briefly goes through all the nice concepts (iterative development, architecture, etc.) that permeate the RUP. There is also a brief history of the RUP in this chapter that I found quite illuminating. I always like to know the historal context; it usually helps explain the rationale behind ideas and constructs.
The next chapter, entitled "Static Structure", discusses the constituent concepts of the RUP, namely role, activity, artifact, workflow, discipline, deliberately ignoring for the moment the temporal dimension (for the most part). It is chapter 4, "Dynamic Structure", where the core concept of iterative development is expounded, and the expected contrast with the traditional waterfall is made (hence explaining the rationale for coming up with the perhaps-not-intuitive-at-first-glance idea of iterative development). Phases and milestones are explained.
If there are three pillars of the RUP, these are (i) iterative development, (ii) executable architecture, and (iii) use-case driven development. Hence, it comes to no surprise that the next two chapters deal with architecture and use cases. In chapter 5 a mention is made, among other things, to the author's important work on the 4+1 Views of Architecture that underlies the RUP. Chapter 6 is a condensed discussion of the role and merit of use cases in a software development process in general, and RUP in particular.
This concludes Part I of the book. Part II consists of 9 chapters, one for each RUP so-called discipline (Project Management, Business Modeling, Requirements, Analysis and Design, Implementation, Test, Configuration, Environment, Deployment). The "Made Easy" book follows a similar pattern, with the difference, congruent with I've already mentioned above, that this book tends to treat the Disciplines in a descriptive rather than normative manner.
There is a pretty good "Summary of Roles" appendix at the end, and I liked the Glossary too, as the definitions contained therein are very precise but at the same time very comprehensible too. Finally, there is a rich annotated bibliography section, which, if you're at all like me, you'll find rather useful (There's also a poster of the RUP at the back if you're into that sort of thing).
All in all, I haven't at all regretted the 38.50 and the time I've spent reading the book; and imagine that I was familiar with this stuff already. If this happens to be the first book you read on RUP (as it should normally be) then the benefit for you will be even greater.
Customer Reviews:
Excellent read for an overview of ÇMMI........2007-07-15
This book is easy to read and well organized and provides a great overview of CMMI. A good choice for those wanting to acquire a working knowledge in a short period of time.
Not for me, I'm afraid.......2006-12-26
Many words, but not too practical. Definitions are fine, but that could have happened in 50 pages. This book basically consists of bureacratic motherhood. I will now look for a book written by someone who has actually managed a project to see what his book says about practical application of CMMI.
I wish I could remember the name of the author of a book I read several years ago on SEI processes, which provided excellent guidelines for projects. The author was very explicit and provided examples. He also stated in the Foreword that, though the book contained a great deal of excellent and useful information, if you tried to do everything in the book, you would fail. That may have been the most important line he wrote, since it implied that common sense was still the most important ingredient to meaningful process.
Read it with a manager's mindset.......2006-05-19
CMMI is an acronym for Capability Maturity Model Integration, and is almost totally an area of management. Therefore, if you read this book with a mindset that is anything other than that of a manager, it will bore you and you may question the practicality of CMMI. When I say this, I am thinking of software developers, who will most likely consider some of what they read to be impediments to the true ways in which software is created.
As a set of objectives designed to improve quality, the basic tenets and activities mandated by the CMMI model are applicable to many other areas of business and organizations. This book is written for people unfamiliar with model-based processes and is non-technical, so very little is needed in the way of background knowledge. It is very appropriate for the manager who is considering adopting a CMMI model. Not only does it provide the essential background information, but also explains how to begin and execute the implementation of CMMI.
Like all other processes designed to improve quality, the most essential precondition is the desire to improve. No book can provide that ingredient. However, this one provides the essential knowledge about CMMI and I strongly recommend that all managers read it carefully. Even if your decision is to not implement CMMI, the knowledge that you will obtain will force you to rethink your current strategies and no doubt improve them.
Introduction - yes, implementation - no.......2005-11-17
This book is useful to those who are fairly well-versed in CMMI. For me, this is by far the best "reference" material, since it is concise, and it consolidates separate points into a table or a 1-pager with diagrams, making it easier to digest and understand. This is especially so when compared with the thick (700+ pages) big (A4 size) tome official guidebook from SEI. I could easily take Ahern onto the plane / train for quick brush-up on particular process areas. I would recommend this book to those who had already gained some CMMI knowledge, and would need a light handbook for quick reference.
A summary of CMMI, not a practical introduction.......2004-08-26
I bought the book thinking it would be a practical introduction on how to apply CMMI to your company hence I was very disappointed to find out the authors have limited themselves only to summarize the CMMI models. Few real explication is given about concepts within the CMMI models, neither any real life experience is shared that could help you implement CMMI.
Book Description
An Introduction to Programming with Fortran is a comprehensive introduction to Fortran, and is essential to the complete beginner who wants to learn the fundamentals of programming using a modern, powerful and expressive language; as well as those wanting to update their programming skills by making the move from earlier versions of Fortran.
It contains lots of clear and simple examples highlighting the key language features of the most recent versions of Fortran – Fortran 2003, 95 and 90. The authors also provide examples based on ISO TR 15580 and ISO TR 15581 as these are quite widely supported as well and cover the ISO TR on Enhanced Modules, which is of particular importance to large code suites.
The examples used throughout the book highlight common problems that occur when programming, and give a solution in Fortran, producing a very effective, hands-on approach.
Details of a variety of internet-based sources are also included, which will prove invaluable to those seeking further information and support.
Customer Reviews:
Excellent.......2007-02-13
Definitively, an excellent book that I enthusiastically recommend. I've been programming in Fortran (mainly 77) some years ago, so I needed to recycle not only my knowledge about the language but also my way of focussing tasks susceptible of being programmed. This book fully fulfilled my expectations.
Good introduction to FORTRAN.......2006-10-07
This book does not assume any prior knowledge and provides a good intro to Fortran programming (also provides a short intro to programming in general). Goes over the essential elements needed to get started with Fortran and provides many examples. In fact, most of the concepts are demonstrated using actual coding examples. One drawback is that the index in this book is not extensive, so it does not serve quite as well as a reference. However, it still does a decent job in this department. After reading through this book I felt well-prepared to begin programming in Fortran. A nice complement to getting this book is to download one of the freely available Fortran documentation manuals (e.g. from Intel) to serve as a reference guide.
slow moving field with lots of legacy code.......2006-01-30
No previous coding experience in Fortran is assumed by the authors. Actually, no previous programming in any language. Fortran is quite easy to learn, compared to others like C++ or Java or C#. The book explains the differences between the 4 major recent versions of Fortran. Though some of you might quibble as to why the book even talks about Fortran 77. That originated in 1977!
But the sheer mass of legacy code means that a lot still exists in F77. This market reality also has job implications. Some Fortran jobs will necessitate you being restricted to F77. Or F90. Hence the book's support for these. At least it does not talk about F66!
Amazon.com
Written for those with some background in software engineering, Automated Software Testing: Introduction, Management, and Performance delivers a rigorous guide to the state of the art in managing automated testing in a text that will benefit anyone who tests software for a living.
First and foremost, Automated Software Testing presents a methodology for test managers called Automated Testing Lifecycle Management (ATLM). This soup-to-nuts tour of testing takes you from initial planning, budgeting, and staffing to building a test plan and choosing test tools to executing tests and even improving your testing process the next time around. Though somewhat thickly written--with plenty of software engineering terminology--this book can also be useful to more practically minded readers because of its many sample test documents. (Besides numerous lists and charts outlining the steps in the ATLM process, the book presents a sample test plan, budget estimates, and staffing guides.)
A truly standout feature is the book's survey of currently available automated tools that can be used throughout the testing cycle, as well as how to choose the right ones for your next project. For many software testers and managers, this section alone is probably worth the price of the book.
As this book points out, test engineering is a growth field. While schools and businesses work hard to meet the demand for qualified testing professionals, this title can provide a solid guide to the best thinking on automated testing solutions that will save time and money as well as improve software quality. --Richard Dragan
Topics covered: Theory and practice of automated software testing, the Automated Testing Lifecycle Management (ATLM) process, test analysis, planning, design and execution, white-box and black-box testing, metrics, and choosing testing tools.
Customer Reviews:
Best Automation Testing Book Ever.......2006-09-01
This book as far as I am concerned is best automation software testing book written ever.
Cut out the bull.......2002-12-03
Unfortunately this book (like nearly all other books on software testing) does not teach you how to test software. Instead it only gives you information needed to manage software testing. And, like many other books of management, it is highly repetitive and redundant. For somebody needing compressed information this is the wrong book. I think it would be no big deal to reduce the number of pages to 50% and still deliver the same message. The exmamples given in the text read like from a psychology book, not like from a technical book. Despite my critique I have to admit that the annexes in the book can be highly valuable. Personally I liked best the review of the big number of test tools.
Excellent Book for implementing Automation.......2001-09-28
This is one of THE books if you plan on implementing automated testing in your software shop. Covers everything from Lifecycle to tool evaluations to best practices. This one that is definitely on my "bookshelf on the go" that follows me to all projects. I especially appreciated the Appendix with real world stuff and references to tool manufacturers. Great work!
You'll Need This Guide to Implement Automated Testing.......2001-04-26
I recently joined a firm that simply wanted to purchase an automated test tool within two weeks; "it made little difference which tool". Using this book, they became convinced we should install at least three tools, on evaluation. Good thing we did: we found that only one could deal with "customized" Java applets used in their applications.
Little did our test team know beforehand that new automated tools require evaluation: what technologies are your applications using? what levels of test planning and scripting skills will be required for each tool? what other tools may be necessary sooner or later? and, does your test tool vendor of choice market such complementary tools? And much, much more.
"Automated Software Testing" guides readers through each step in the planning, selection, and implementation process to assure that automated software testing will be developed in a systematic manner.
See the table of contents. You will find that for less than the cost of a testers time for two hours, your business will be investing in knowledge that will save perhaps hundreds of thousands of dollars over the life of your applications.
A Compilation of Generalizations.......2001-03-15
As an engineer involved with software QA for a number of years, I found the book to be so generalized as to be essentially worthless. The authors devote page after page to explain methods and procedures with diagrams that depict the intuitively obvious. Their ATLM (Automated Test Life-Cycle Methodology) is as complicated as diagramming the Earth's water cycle. I don't need to spend Forty odd dollars and peruse 600 pages to learn that I might be able to use some nonspecific automated testing tool somewhere along the software development process.
Amazon.com
Aimed at the computer science student, Introduction to the Team Software Process provides a textbook-style introduction to the author's Team Software Process (TSP), a rigorous group-based design process that stresses planning, metrics, scripts, accountability, and ultimately, higher code quality. Although best suited for a semester- or two-semester-length course, this book provides a useful model for any team development effort.
This textbook focuses squarely on the team-based nature of successful software development. The author, who also invented the Personal Software Process (PSP), outlines the steps for "staffing" a classroom-based software project with different multiple member roles, such as team leaders and development managers. The Team Software Process (TSP) outlined here stresses accountability through numerous scripts and metrics. (An appendix features over 80 pages of scripts and forms that would be used over the course of the semester.) Not only does the author provide a thorough guide to choosing the right team role that fits your personality and skills, but several sections offer some "motivational speaking" on the advantage of "discipline," both as a person and software engineer.
This book does a particularly good job of defining a team's role for each stage in the development process, beginning from the initial planning stages to requirements definition, implementation, testing, and postmortem followup. There are hints for dealing with missed deadlines, staffing, and design problems.
The reality is that teams are used throughout the software industry, but many computer science students do not get much experience working in successful teams. As a first encounter with team development, Introduction to the Team Software Process provides a model for serious implementation of a smart, rigorous software method that can put readers on the right track with group development. --Richard Dragan
Topics Covered: Team Software Process (TSP) basics and scripts, building production software teams, team goals, team roles, planning, risk management, quality plan, requirements, design principles, product implementation, integration and system testing, test planning, defect tracking, documentation, conducting postmortems, team leaders, development managers, planning managers, quality/process managers, support managers.
Customer Reviews:
Excellent Process for Software Devleopment.......2005-03-31
My software team used the TSP for developing a 3 release Java application over 12 weeks. There is a stiff learning curve, but once you learn it, you can quickly realize the results. This book takes the guesswork out of developing software. If you have a dedicated team that will take the time to learn it, you will be very happy with the results.
totalitarian control is not the answer.......2004-05-19
A state-of-the-art process for producing PL/I programs on punchcards. If you can master PSP/TSP, you will be more effective than 99% of all software developers at filling out forms and producing status reports. A shockingly wasteful approach to quality management.
Outstanding Reference for Software Engineers.......2000-10-23
I've been involved with many different projects in a team environment. This book contains some of the best and most respected procedures to complete a team project. I've used these methods and they work well! The principles outlined in this book apply to more than just software engineering. Take a look! You'll be glad you did!
Good introduction to creating software in a team.......2000-08-30
This is a good introduction to working in a team and using good software engineering techniques such as planning and inspections. It is geared for undergraduate students, therefore the managerial roles have been created. This would probably not work out of the box for an organization that is already set up. For students, the manager roles give each team member ownership in the product while making sure each aspect of good engineering has an advocate.
The processes are written as scripts. These are very easy to follow and take the guesswork out of how to do each step in the lifecycle.
This is a process book therefore there is not a lot of technically-oriented information in the book. For example, the book tells you that you must design your software. It does not give many guidelines on what a good (object-oriented, client-server, real time, etc.) design might look like. In addition, some of the data bookkeeping is long and involved. A good tool would help with this.
Overall, this is a good tutorial and a good reference book. I used this book as a graduate student, and I continue to pull ideas out of it for use in my work.
Average customer rating:
- Excellent introduction to Apache Jakarta and beyond
- Nice coverage of the top jakarta tools for webapps
|
Apache Jakarta and Beyond: A Java Programmer's Introduction
Larne Pekowsky
Manufacturer: Addison-Wesley Professional
ProductGroup: Book
Binding: Paperback
 General
| Java
| Programming
| Computers & Internet
| Subjects
| Books
Beginner's Guides
| Java
| Programming
| Computers & Internet
| Subjects
| Books
General
| Introductory & Beginning
| Programming
| Computers & Internet
| Subjects
| Books
Software Development
| Software Design, Testing & Engineering
| Programming
| Computers & Internet
| Subjects
| Books
General
| Programming
| Computers & Internet
| Subjects
| Books
General
| Languages & Tools
| Programming
| Computers & Internet
| Subjects
| Books
All Titles
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Computers & Internet
| Qualifying Textbooks - Fall 2007
| Stores
| Books
Similar Items:
-
Jakarta Commons Cookbook
-
Ant: The Definitive Guide, 2nd Edition
-
Pro Apache Tomcat 5/5.5
-
Foundations of Ajax (Foundation)
-
JBoss at Work: A Practical Guide
ASIN: 0321237714 |
Customer Reviews:
Excellent introduction to Apache Jakarta and beyond.......2005-12-31
If you ever wonder how to keep up with the open-source explosion especially with respect to Java tools and technologies, here is one book that could come in your assistance. Very well written, simple to understand and easy to read examples explain various open-source technologies that can take you beyond Jakarta and a bit more. May be next year we can see the 2nd edition that can talk about the advances made in the last couple of years or so :-).
-SB
Nice coverage of the top jakarta tools for webapps.......2005-03-24
Many tools were discussed. The Ant tool chapter alone was better than the whole book called "Ant the Definitive Guide". He explains ant in a very gentle way. Good job. You get a good feel of how the industry cranks out webapps with these tools like eclipse,struts,junit,cactus,etc,etc. Good coverage!
Book Description
In recognition of the tremendous variation across children and language, the fifth edition of this readable book devotes much more space to individual developmental differences and cultural differences.
Discussion of other cultures has been included wherever possible. In addition, the sections on bidialectalism and bilingualism have been expanded to reflect more accurately the realities of everyday life in the United States. Developed within a chronological framework, every aspect of syntax, morphology, semantics, phonology, and pragmatics is examined.
For anyone interested in language development.
Customer Reviews:
Easy to Understand.......2007-02-13
This book gives comprehensive detail on how language is normally developed. Its very easy to understand
Good info, hard read.......2007-01-04
This book is chock-full of vital information on the subject. The issue is that it is not an easy read. The words are small and it seems as if the info just goes on and on and on with no page breaks or chapter reviews often. But because of the good content, I've decided to keep the book instead of selling it back.
Too much information.......1999-07-22
This book is packed with an incredible amount of information on language development making it a good resource. However, this incredible detail is confusing for students taking their first course in language development.
Book Description
This introduction to programming places computer science in the core of a liberal arts education. Unlike other introductory books, it focuses on the program design process. This approach fosters a variety of skills--critical reading, analytical thinking, creative synthesis, and attention to detail--that are important for everyone, not just future computer programmers.
The book exposes readers to two fundamentally new ideas. First, it presents program design guidelines that show the reader how to analyze a problem statement; how to formulate concise goals; how to make up examples; how to develop an outline of the solution, based on the analysis; how to finish the program; and how to test. Each step produces a well-defined intermediate product. Second, the book comes with a novel programming environment, the first one explicitly designed for beginners. The environment grows with the readers as they master the material in the book until it supports a full-fledged language for the whole spectrum of programming tasks.
All the book's support materials are available for free on the Web. The Web site includes the environment, teacher guides, exercises for all levels, solutions, and additional projects.
Customer Reviews:
Excellent Book for Rookies and Veterans.......2006-12-26
I have been professionally developing software for about 5 years. I found this book to be one of the most useful and helpful books to help my coding skills. Even though I have been programming professionally for a few years and have a computer science degree, I learned a lot of new neat concepts from this book. It also helped to me to remind me of all the basic good practices that I have forgotten.
It is also an excellent book for beginners. The books doesn't use a popular programming language like Java to accomplish its goals. Instead, it uses Scheme so the student can focus on the concepts rather than syntax. It also teaches great concepts and breaks the problem down on how to solve various problems. Also it isn't "hardcore" like SICP-- it is very friendly to non-MIT level people.
A Recipe for Programming.......2006-07-06
This book opened my eyes. I'd finished a Ph.D. in computer science, and had a decent exposure to quite a few programming languages and paradigms, before coming across this book. I was surprised to start working through this introductory book, and find myself learning new things! The book transformed my approach to programming.
From page one, HtDP starts talking about good program design, and gives a methodical approach. Until this, I'd always thought programming books were "here are ten small example programs; go write ten more." That's hardly teaching. But HtDP builds up a straightforward design recipe, to guide programs along. If I get stuck or have a mistake in my program, 90% of the time I realize it's because I strayed from the book's recipe. The approach is language-independent, although some programming environments make it much easier to implement the design recipe; the book provides links to a good (free) Scheme environment, which it uses for its code examples too. (I've come to use that environment day-to-day). My code--in any language--has become much more robust, and when I do have a bug I usually locate it early, thanks to this book.
In addition, HtDP made me think about things I'd taken for granted: How is assignment to a variable fundamentally different than assignment to a structure's field? Even, *why* do I use assignment statements in certain situations, instead of choosing a functional approach? How often do my programs actually need the efficiency of imprecise floating-point arithmetic, vs using bignums which totally liberate me from numerical inaccuracy?
Although the text is available on line, I cherish my hardcopy. This is a book to first learn programming from, and one to revisit every five years.
Everyone should learn to design programs.......2004-06-03
As a programming do-it-yourselfer I've had many conflicting responses to this text -- it's didactic style, its attention to detail, its sometimes patronizing tone, its rigor and broad scope and at the same time its immersion in minutia and quiddities I have never encountered in 'computer books' I had ever perused. Perhaps it's my liberal arts background, or love 'em/hate 'em sensitivity to all those broad stiff-spined textbooks I had carried in back-packs since childhood, combined with a disdain for the authoritative stilted style these educators exude -- despite their patent love of their subject. I felt at once both patronized and condescended to.
From the very start of their journey into a detailed six step-by-step process that show the reader how to analyze problem statements, how to formulate goals, make up examples, outline a solution, and test a solution the authors proclaim their pedagogical ends: "We [...] believe that the study of program design deserves the same central role in general education as mathematics and English. Or, put more succinctly, everyone should learn how to design programs..." This is not a textbook, this is a revolutionary pamphlet calling for educational reform. I had read nothing like this in the tens of 'Dummies' and 'In 24 Hours' books I had exposed myself to. One part priggish, two parts pedagogic. I often found myself asking for whom was it written? First-year college student?, ambitious would-be high-school programmer wanna-be? Math mavens? Surely not a middle-aged bookish clerk who tastes run more to Turgenev and Dostoevsky than Turing and Dijkstra. But then I demanded more than mere anonymous web-lurking from my lowly pc. I remember myself many years ago trying to learn BASIC on a massive time-share computer and telling myself surely there was had to be more magic to computing than this. Well, after reading more texts and having had to unlearn the 'Dummies' and the 'In 24 hours' style of disinformation I had finally found the marrow of a discipline that is as demanding as any I had ever come across and as vexing as any artistic rigor I had ever been inspired by. Come be confused, come be amused, amazed and intellectually abused. Sorely, if I find I have little talent for this excruciatingly logical endevour, I have also found a full-blown appreciation of such daunting computational cheekiness. Much to learn here, and this is only the "core subject of a liberal arts education." What had I been wasting my time on all those years as a professional student?
The joy of learn programming.......2003-11-15
Great book! I liked the way the author approaches how to begin designing programs. I am half-way through the book and I am finding it very entertaining. Yeap! I recommend this book.
Should be read by Everyone who wants to program........2001-09-27
Have you ever looked at other people's codes and said to yourself something like "No... this isn't the way it should be written!". Or, worst yet, have you ever been asked by someone who wants you to read his/her codes and tell him/her what does it do?
Both things happened quite often, though.
The problems are mainly because they don't know how to "design" their programs properly. Being able to progam doesn't mean being to design/organize a good code at all. And being good at finding/inventing algorithms for problem solving doesn't mean that either.
One another thing, I (maybe just only me, I don't know) think that C shouldn't be taught as the first language (at least, not anymore). This is mainly because, in C, you can hardly express yourself. Also, C codes look cryptic to those new to programming. And you must know a lot, and practice a lot, (that takes a lot of time, friend) to be able to express what you want.
And also, several times, I saw many people just playing around with the * and & (well, the pointer-dereferencing, and address-taking symbol in C/C++), adding one more, deleting one off, to see which will make their programs work. (Sometime, it just works by miracle...)
This book, using Scheme (a modern dialect of Lisp) as the language of choice. I, personally, agree of choosing it. Scheme was designed in the way such that programmers can focus on what they want to express, rather than imprementation details. From my own experience, I became a better programmer after learning it. (I was already a C++ programmer by that time. I just have to use Lisp on my study/research).
One thing that I like is that, it focused on how to "design" programs, not just how to program, while college classes are mostly focused on how to write programs. No matter how students write their codes, if it could run, then it is fine.
Then, I think, a lot of people do have ability to program, a lot are good at it. However, the number of people who knows how to design programs are much lesser. And this would result in something like those silly examples at the beginning of this review. Therefore, this book had emphasized on quite an important thing.
And the last thing to say about this one is: MIT Press' textbooks are very high-quality, and this one is not an exception. It is very easy to read and to understand. And, even the html version is available at the book's official homepage, it is nice to have the printed version.
How to "design" programs is very important for every CS major people, and is important to everyone else in general (to program your "everyday life schedule", etc). Whether you want to become a professional programmer (write codes for living, etc) or not.
Books:
- Basic English Grammar, Third Edition (Full Student Book with Audio CD and Answer Key)
- Basic Italian: Learn to Speak and Understand Italian with Pimsleur Language Programs (Simon & Schuster's Pimsleur)
- Beginner's French Reader
- Berlitz French Phrase Book (Berlitz Phrase Books)
- Berlitz German Phrase Book (Berlitz Phrase Book)
- Blood Fever (The Young James Bond, Book 2)
- Cassell's Contemporary Spanish: A Handbook of Grammar, Current Usage, and Word Power
- CINEMA 4D 10 Workshop
- Color Atlas of Anatomy: A Photographic Study of the Human Body (Color Atlas of Anatomy (Rohen))
- Complete French: The Basics (CD) (LL(R) Complete Basic Courses)
Books Index
Books Home
Recommended Books
- Motor Control Electronics Handbook
- History: Fiction or Science
- Basic Budgeting Practices for Librarians
- Encyclopedia of Hollywood Film Actors, Vol. 1: From the Silent Era to 1965
- Financial Accounting: An Introduction to Concepts, Methods, and Uses
- I Hate You, Don't Leave Me: Understanding the Borderline Personality
- History: Fiction or Science
- Ready Notes, Volume 1, Chapters 1-13 for use with Fundamental Accounting Principles
- European Migration: What Do We Know
- Hell's Bottom, Colorado
UML Distilled: A Brief Guide to the Standard Object Modeling Language (3rd Edition) (The Addison-Wesley Object Technology Series)
Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series)
Head First Design Patterns (Head First)
Agile and Iterative Development: A Manager's Guide
Writing Effective Use Cases
