Agility and Discipline Made Easy: Practices from OpenUP and RUP

Pearson Education
1
Free sample

"The Japanese samurai Musashi wrote: 'One can win with the long sword, and one can win with the short sword. Whatever the weapon, there is a time and situation in which it is appropriate.'

"Similarly, we have the long RUP and the short RUP, and all sizes in between. RUP is not a rigid, static recipe, and it evolves with the field and the practitioners, as demonstrated in this new book full of wisdom to illustrate further the liveliness of a process adopted by so many organizations around the world. Bravo!"

--Philippe Kruchten, Professor, University of British Columbia

"The Unified Process and its practices have had, and continue to have, a great impact on the software industry. This book is a refreshing new look at some of the principles underlying the Unified Process. It is full of practical guidance for people who want to start, or increase, their adoption of proven practices. No matter where you are today in terms of software maturity, you can start improving tomorrow."

--Ivar Jacobson, Ivar Jacobson Consulting

"Kroll and MacIsaac have written a must-have book. It is well organized with new principles for software development. I encounter many books I consider valuable; I consider this one indispensable, especially as it includes over 20 concrete best practices. If you are interested in making your software development shop a better one, read this book!"

--Ricardo R. Garcia, President, Global Rational User Group Council, www.rational-ug.org/index.php

"Agile software development is real, it works, and it's here to stay. Now is the time to come up to speed on agile best practices for the Unified Process, and this book provides a great starting point."

--Scott W. Ambler, practice leader, Agile Modeling

"IBM and the global economy have become increasingly dependent on software over the last decade, and our industry has evolved some discriminating best practices. Per and Bruce have captured the principles and practices of success in this concise book; a must for executives, project managers, and practitioners. These ideas are progressive, but they strike the right balance between agility and governance and will form the foundation for successful systems and software developers for a long time."

--Walker Royce, Vice President, IBM Software Services-Rational

"Finally, the RUP is presented in digestible, byte-size pieces. Kroll and MacIsaac effectively describe a set of practices that can be adopted in a low-ceremony, ad hoc fashion, suited to the culture of the more agile project team, while allowing them to understand how to scale their process as needed."

--Dean Leffingwell, author and software business advisor and executive

"This text fills an important gap in the knowledge-base of our industry: providing agile practices in the proven, scalable framework of the Unified Process. With each practice able to be throttled to the unique context of a development organization, Kroll and MacIsaac provide software teams with the ability to balance agility and discipline as appropriate for their specific needs."

--Brian G. Lyons, CTO, Number Six Software, Inc.

In Agility and Discipline Made Easy , Rational Unified Process (RUP) and Open Unified Process (OpenUP) experts Per Kroll and Bruce MacIsaac share twenty well-defined best practices that you and your team can start adopting today to improve the agility, predictability, speed, and cost of software development.

Kroll and MacIsaac outline proven principles for software development, and supply a number of supporting practices for each. You'll learn what problems each practice addresses and how you can best leverage RUP and OpenUP (an open-source version of the Unified Process) to make the practice work for you. You'll find proactive, prescriptive guidance on how to adopt the practices with minimal risk and implement as much or as little of RUP or OpenUP as you want.

Learn how to apply sample practices from the Unified Process so you can

  • Execute your project in iterations
  • Embrace and manage change
  • Test your own code
  • Describe requirements from the user perspective
  • Architect with components and services
  • Model key perspectives

Whether you are interested in agile or disciplined development using RUP, OpenUP, or other agile processes, this book will help you reduce the anxiety and cost associated with software improvement by providing an easy, non-intrusive path toward improved results--without overwhelming you and your team.



Read more
Collapse

About the author

Per Kroll manages the development of RUP and is responsible for IBM Rational process strategy. He launched and is the project lead for the open source process initiative Eclipse Process Framework (EPF). In addition to his highly acclaimed books, Per has written for a variety of trade magazines.

Bruce MacIsaac is technical lead for the RUP content development team at IBM and oversees IBM's contributions to OpenUP. He has many years of experience as a software developer, technical lead, and manager of small to large software teams.



Read more
Collapse
5.0
1 total
Loading...

Additional Information

Publisher
Pearson Education
Read more
Collapse
Published on
May 19, 2006
Read more
Collapse
Pages
480
Read more
Collapse
ISBN
9780132702485
Read more
Collapse
Read more
Collapse
Read more
Collapse
Language
English
Read more
Collapse
Genres
Computers / Programming / Object Oriented
Computers / Software Development & Engineering / General
Read more
Collapse
Content Protection
This content is DRM protected.
Read more
Collapse
Eligible for Family Library

Reading information

Smartphones and Tablets

Install the Google Play Books app for Android and iPad/iPhone. It syncs automatically with your account and allows you to read online or offline wherever you are.

Laptops and Computers

You can read books purchased on Google Play using your computer's web browser.

eReaders and other devices

To read on e-ink devices like the Sony eReader or Barnes & Noble Nook, you'll need to download a file and transfer it to your device. Please follow the detailed Help center instructions to transfer the files to supported eReaders.
Software Conflict 2.0: The Art and Science of Software Engineering updates and expands a neglected classic in the field. The nearly 60 essays in this book--always easily digestible, often profound, and never too serious--are the work of pioneer Robert L. Glass, 50 year software veteran, and author or editor of more than 25 books, including the recent bestseller Facts and Fallacies of Software Engineering. As loyal Glass readers have come to expect, Software Conflict 2.0 takes up large themes and important questions, never shying away from controversy. Robert Glass has a unique perspective, owing partly to his longevity in the field, partly to his breadth and depth of experience as a practitioner, and partly to his experiences on multiple continents crossing back and forth between the worlds of the university and the professional programming shop. No matter what unique corner of the software engineering world you call home--be it aerospace or e-commerce--whether you are a researcher, hardcore coder, consultant, or manager, Software Conflict 2.0 tackles questions and conflicts that you will recognize. Bob Glass's wide and deep perspective on the art and science of software engineering will widen and deepen your own perspective. Pragmatic Programmer Andy Hunt writes in his Foreword to this book, "Eleventh-century philosopher Pierre Abelard taught that, 'The beginning of wisdom is found in doubting; by doubting we come to the question, and by seeking we may come upon the truth.' Welcome to Bob's essays on software conflict. Here you'll find the seeds of doubt, some underlying questions, and a fellow seeker." We couldn't agree more. The first edition of Software Conflict was published circa 1990 and, until now, has been out of print for some time. Why? Mainly because that?s the normal pattern for software books: a new book is hot when it hits the streets, but then trends change, paradigms shift, and eventually the publisher stops placing orders with the printer. As hundreds of new books are published every year, a real treasure can be buried in the shifting sands. Sometimes the significance of a software book transcends the endless cycle of trends and revolutions. In fact, some of the great software books continue to be discussed even decades after their original publication. Why do people keep reading these "dated" software engineering books? Because the insights of these great books are timeless, as valid today as they were yesterday. Because these insights help us become better software professionals, better researchers, better managers. And because the writings of a computing pioneer like Robert L. Glass might just reveal something about where we are today and where we?re headed. Software Conflict 2.0 features six new essays by Robert Glass and a new Foreword by Andrew Hunt of the Pragmatic Programmers (Table of Contents).
"Per Kroll and Philippe Kruchten are especially well suited to explain the RUP...because they have been the central forces inside Rational Software behind the creation of the RUP and its delivery to projects around the world."

--From the Foreword by Grady Booch

This book is a comprehensive guide to modern software development practices, as embodied in the Rational Unified Process, or RUP. With the help of this book's practical advice and insight, software practitioners will learn how to tackle challenging development projects--small and large--using an iterative and risk-driven development approach with a proven track record.

The Rational Unified Process Made Easy will teach you the key points involved in planning and managing iterative projects, the fundamentals of component design and software architecture, and the proper employment of use cases. All team members--from project managers to analysts, from developers to testers--will learn how to immediately apply the RUP to their work. You will learn that the RUP is a flexible, versatile process framework that can be tailored to suit the needs of development projects of all types and sizes.

Key topics covered include:

How to use the RUP to develop iteratively, adopt an architecture-centric approach, mitigate risk, and verify software quality Tasks associated with the four phases of the RUP: Inception, Elaboration, Construction, and Transition Roles and responsibilities of project managers, architects, analysts, developers, testers, and process engineers in a RUP project Incrementally adopting the RUP with minimal risk Common patterns for failure with the RUP--and how to avoid them

Use this book to get quickly up to speed with the RUP, so you can easily employ the significant power of this process to increase the productivity of your team.

As the application of object technology--particularly the Java programming language--has become commonplace, a new problem has emerged to confront the software development community. Significant numbers of poorly designed programs have been created by less-experienced developers, resulting in applications that are inefficient and hard to maintain and extend. Increasingly, software system professionals are discovering just how difficult it is to work with these inherited, "non-optimal" applications. For several years, expert-level object programmers have employed a growing collection of techniques to improve the structural integrity and performance of such existing software programs. Referred to as "refactoring," these practices have remained in the domain of experts because no attempt has been made to transcribe the lore into a form that all developers could use. . .until now. In Refactoring: Improving the Design of Existing Code, renowned object technology mentor Martin Fowler breaks new ground, demystifying these master practices and demonstrating how software practitioners can realize the significant benefits of this new process.

With proper training a skilled system designer can take a bad design and rework it into well-designed, robust code. In this book, Martin Fowler shows you where opportunities for refactoring typically can be found, and how to go about reworking a bad design into a good one. Each refactoring step is simple--seemingly too simple to be worth doing. Refactoring may involve moving a field from one class to another, or pulling some code out of a method to turn it into its own method, or even pushing some code up or down a hierarchy. While these individual steps may seem elementary, the cumulative effect of such small changes can radically improve the design. Refactoring is a proven way to prevent software decay.

In addition to discussing the various techniques of refactoring, the author provides a detailed catalog of more than seventy proven refactorings with helpful pointers that teach you when to apply them; step-by-step instructions for applying each refactoring; and an example illustrating how the refactoring works. The illustrative examples are written in Java, but the ideas are applicable to any object-oriented programming language.

Refactoring has proven its value in a wide range of development projects–helping software professionals improve system designs, maintainability, extensibility, and performance. Now, for the first time, leading agile methodologist Scott Ambler and renowned consultant Pramodkumar Sadalage introduce powerful refactoring techniques specifically designed for database systems.

Ambler and Sadalage demonstrate how small changes to table structures, data, stored procedures, and triggers can significantly enhance virtually any database design–without changing semantics. You’ll learn how to evolve database schemas in step with source code–and become far more effective in projects relying on iterative, agile methodologies.

This comprehensive guide and reference helps you overcome the practical obstacles to refactoring real-world databases by covering every fundamental concept underlying database refactoring. Using start-to-finish examples, the authors walk you through refactoring simple standalone database applications as well as sophisticated multi-application scenarios. You’ll master every task involved in refactoring database schemas, and discover best practices for deploying refactorings in even the most complex production environments.

The second half of this book systematically covers five major categories of database refactorings. You’ll learn how to use refactoring to enhance database structure, data quality, and referential integrity; and how to refactor both architectures and methods. This book provides an extensive set of examples built with Oracle and Java and easily adaptable for other languages, such as C#, C++, or VB.NET, and other databases, such as DB2, SQL Server, MySQL, and Sybase.

Using this book’s techniques and examples, you can reduce waste, rework, risk, and cost–and build database systems capable of evolving smoothly, far into the future.

The practice of enterprise application development has benefited from the emergence of many new enabling technologies. Multi-tiered object-oriented platforms, such as Java and .NET, have become commonplace. These new tools and technologies are capable of building powerful applications, but they are not easily implemented. Common failures in enterprise applications often occur because their developers do not understand the architectural lessons that experienced object developers have learned.

Patterns of Enterprise Application Architecture is written in direct response to the stiff challenges that face enterprise application developers. The author, noted object-oriented designer Martin Fowler, noticed that despite changes in technology--from Smalltalk to CORBA to Java to .NET--the same basic design ideas can be adapted and applied to solve common problems. With the help of an expert group of contributors, Martin distills over forty recurring solutions into patterns. The result is an indispensable handbook of solutions that are applicable to any enterprise application platform.

This book is actually two books in one. The first section is a short tutorial on developing enterprise applications, which you can read from start to finish to understand the scope of the book's lessons. The next section, the bulk of the book, is a detailed reference to the patterns themselves. Each pattern provides usage and implementation information, as well as detailed code examples in Java or C#. The entire book is also richly illustrated with UML diagrams to further explain the concepts.

Armed with this book, you will have the knowledge necessary to make important architectural decisions about building an enterprise application and the proven patterns for use when building them.

The topics covered include

· Dividing an enterprise application into layers

· The major approaches to organizing business logic

· An in-depth treatment of mapping between objects and relational databases

· Using Model-View-Controller to organize a Web presentation

· Handling concurrency for data that spans multiple transactions

· Designing distributed object interfaces

©2019 GoogleSite Terms of ServicePrivacyDevelopersArtistsAbout Google|Location: United StatesLanguage: English (United States)
By purchasing this item, you are transacting with Google Payments and agreeing to the Google Payments Terms of Service and Privacy Notice.