Software Reuse Books

MagicBeanDip.com

Page 1 of 17 - Go to page: 1 2 3 4 5 6 12

Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series)

Erich Gamma, Richard Helm, Ralph Johnson, John M. Vlissides

Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley Professional Computing Series) Erich Gamma, Richard Helm, Ralph Johnson, John M. Vlissides Amazon Price: $41.57
List Price: $59.99
Usually ships in 24 hours
By: Addison-Wesley Professional
Amazon Marketplace: 93 new & used starting at $33.00

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Computer Science -> Software Engineering -> Design Tools & Techniques
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Object-Oriented Design
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Reuse

Customer Reviews:
Total reviews: 250 Average rating: 4.5 of 5

Why are people still buying this book? 3 out of 5 stars.
3 of 4 people found this review helpful.

I give this book a 3 because it was great when it was written. But now, it is not a very good book to read. Most people who read it acknowledge they can't understand it. There are two excellent books on the market that should be read if you want to learn design patterns.

Head First Design Patterns (Head First) - is the best book to read on what patterns are as solutions to a problem in a context. Fun to read, useful, really wonderful *****.

However, if you want to learn what patterns really are - the thought process behind them, read Design Patterns Explained: A New Perspective on Object-Oriented Design (2nd Edition) (Software Patterns Series) *****

A related book that would also be a good read is Scott Bain's Emergent Design: The Evolutionary Nature of Professional Software Development (Net Objectives Product Development Series) *****

Let's give tribute to the acknowledged #1 classic in the modern software industry. But it is not the book to read to learn patterns anymore.

Editorial Review:

*Capturing a wealth of experience about the design of object-oriented software, four top-notch designers present a catalog of simple and succinct solutions to commonly occurring design problems. Previously undocumented, these 23 patterns allow designers to create more flexible, elegant, and ultimately reusable designs without having to rediscover the design solutions themselves. *The authors begin by describing what patterns are and how they can help you design object-oriented software. They then go on to systematically name, explain, evaluate, and catalog recurring designs in object-oriented systems. With Design Patterns as your guide, you will learn how these important patterns fit into the software development process, and how you can leverage them to solve your own design problems most efficiently.

Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (2nd Edition) (Microsoft .NET Development Series)

Krzysztof Cwalina, Brad Abrams

Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (2nd Edition) (Microsoft .NET Development Series) Krzysztof Cwalina, Brad Abrams Amazon Price: $39.99
List Price: $49.99
Usually ships in 24 hours
By: Addison-Wesley Professional
Amazon Marketplace: 17 new & used starting at $39.92

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Microsoft -> Development -> .NET
Subjects -> Computers & Internet -> Microsoft -> Networking
Subjects -> Computers & Internet -> Networking -> Networks, Protocols & APIs -> General

Customer Reviews:
Total reviews: 1 Average rating: 5.0 of 5

Editorial Review:

Framework Design Guidelines is one of those rare books that can be read at different reading levels and can be useful to different kinds of developers. Regardless of whether you want to design an effective object model, improve your understanding of the .NET Framework, borrow from the experience of software gurus, stay clear of the most common programming mistakes, or just get an idea of the huge effort that led to the .NET initiative, this book is a must-read.”

–Francesco Balena, The VB Migration Partner Team (www.vbmigration.com), Code Architect, Author, and Microsoft Regional Director, Italy

 

“ Frameworks are valuable but notoriously difficult to construct: your every decision must be geared toward making them easy to be used correctly and difficult to be used incorrectly. This book takes you through a progression of recommendations that will eliminate many of those downstream ‘I wish I’d known that earlier’ moments. I wish I’d read it earlier.”

–Paul Besly, Principal Technologist, QA

 

“ Not since Brooks’ The Mythical Man Month has the major software maker of its time produced a book so full of relevant advice for the modern software developer. This book has a permanent place on my bookshelf and I consult it frequently.”

–George Byrkit, Senior Software Engineer, Genomic Solutions

 

“ Updated for the new language features of the .NET Framework 3.0 and 3.5, this book continues to be the definitive resource for .NET developers and architects who are designing class library frameworks. Some of the existing guidelines have been expanded with new annotations and more detail, and new guidance covering such features as extension methods and nullable types has also been included. The guidance will help any developer write clearer and more understandable code, while the annotations provide invaluable insight into some of the design decisions that made the .NET Framework what it is today.”

–Scott Dorman, Microsoft MVP and President, Tampa Bay International Association of Software Architects

 

“ Filled with information useful to developers and architects of all levels, this book provides practical guidelines and expert background information to get behind the rules. Framework Design Guidelines takes the already published guidelines to a higher level, and it is needed to write applications that integrate well in the .NET area.”

–Cristof Falk, Software Engineer

 

“ This book is an absolute must read for all .NET developers. It gives clear ‘do’ and ‘don’t’ guidance on how to design class libraries for .NET. It also offers insight into the design and creation of .NET that really helps developers understand the reasons why things are the way they are. This information will aid developers designing their own class libraries and will also allow them to take advantage of the .NET class library more effectively.”

–Jeffrey Richter, Author/Trainer/Consultant, Wintellect

 

“ The second edition of Framework Design Guidelines gives you new, important insight into designing your own class libraries: Abrams and Cwalina frankly discuss the challenges of adding new features to shipping versions of their products with minimal impact on existing code. You’ll find great examples of how to create version N+1 of your software by learning how the .NET class library team

created versions 2.0, 3.0, and 3.5 of the .NET library. They were able to add generics, WCF, WPF, WF, and LINQ with minimal impact on the existing APIs, even providing capabilities for customers wanting to use only some of the new features, while still maintaining compatibility with the original library.”

–Bill Wagner, Founder and Consultant, SRT Solutions, author of Effective C# and More Effective C#

 

“ This book is a must read for all architects and software developers thinking about frameworks. The book offers insight into some driving factors behind the design of the .NET Framework. It should be considered mandatory reading for anybody tasked with creating application frameworks.”

–Peter Winkler, Sr. Software Engineer, Balance Technology Inc.

 

“An instant classic.”

–From the Foreword by Miguel de Icaza

 

Framework Design Guidelines, Second Edition, teaches developers the best practices for designing reusable libraries for the Microsoft .NET Framework. Expanded and updated for .NET 3.5, this new edition focuses on the design issues that directly affect the programmability of a class library, specifically its publicly accessible APIs.

 

This book can improve the work of any .NET developer producing code that other developers will use. It includes copious annotations to the guidelines by thirty-five prominent architects and practitioners of the .NET Framework, providing a lively discussion of the reasons for the guidelines as well as examples of when to break those guidelines.

 

Microsoft architects Krzysztof Cwalina and Brad Abrams teach framework design from the top down. From their significant combined experience and deep insight, you will learn

  • The general philosophy and fundamental principles of framework design
  • Naming guidelines for the various parts of a framework
  • Guidelines for the design and extending of types and members of types
  • Issues affecting–and guidelines for ensuring–extensibility
  • How (and how not) to design exceptions
  • Guidelines for–and examples of–common framework design patterns

Guidelines in this book are presented in four major forms: Do, Consider, Avoid, and Do not. These directives help focus attention on practices that should always be used, those that should generally be used, those that should rarely be used, and those that should never be used. Every guideline includes a discussion of its applicability, and most include a code example to help illuminate the dialogue.

 

Framework Design Guidelines, Second Edition, is the only definitive source of best practices for managed code API development, direct from the architects themselves.

 

A companion DVD includes the Designing .NET Class Libraries video series, instructional presentations by the authors on design guidelines for developing classes and components that extend the .NET Framework. A sample API specification and other useful resources and tools are also included.

Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (Microsoft .NET Development Series)

Krzysztof Cwalina, Brad Abrams

Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries (Microsoft .NET Development Series) Krzysztof Cwalina, Brad Abrams List Price: $49.99
By: Addison-Wesley Professional
Amazon Marketplace: 29 new & used starting at $18.94

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Computer Science -> Software Engineering -> Design Tools & Techniques
Subjects -> Computers & Internet -> Computer Science -> Software Engineering -> General AAS
Subjects -> Computers & Internet -> Microsoft -> Development -> .NET

Customer Reviews:
Total reviews: 29 Average rating: 5.0 of 5

Editorial Review:

"This book is an absolute must-read for all .NET developers. It gives clear do and don't guidance on how to design class libraries for .NET. It also offers insight into the design and creation of .NET that really helps developers understand the reasons why things are the way they are. This information will aid developers designing their own class libraries and will also allow them to take advantage of the .NET class library more effectively." --Jeffrey Richter, author/trainer/consultant, Wintellect "Framework Design Guidelines will help you in two important ways. First, any .NET developer will benefit from a greater understanding of the design principles that govern the .NET Base Class Library. Second, a deeper understanding of these principles will help you to create software that integrates well with the .NET environment. Quite frankly, this book should be on every .NET developer's bookshelf." --Bill Wagner, founder and consultant, SRT Solutions, author of Effective C# "Not since Brooks' The Mythical Man Month has the major software maker of its time produced a book so full of relevant advice for the modern software developer.This book has a permanent place on my bookshelf and I consult it frequently. " --George Byrkit, senior software engineer, Genomic Solutions "This book is a must-read for all architects and software developers thinking about frameworks. The book offers insight into some driving factors behind the design of the .NET Framework. It should be considered mandatory reading for anybody tasked with creating application frameworks." --Peter Winkler, senior software engineer, Balance Technology Inc. "Frameworks are valuable but notoriously difficult to construct: Your every decision must be geared towards making them easy to be used correctly and difficult to be used incorrectly. This book takes you through a progression of recommendations that will eliminate many of those downstream 'I wish I'd known that earlier' moments. I wish I'd read it earlier." --Paul Besly, principal technologist, QA "Filled with information useful to developers and architects of all levels, this book provides practical guidelines and expert background information to get behind the rules.Framework Design Guidelines takes the already published guidelines to a higher level, and it is needed to write applications that integrate well in the .NET area." --Cristof Falk, software engineer Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable . NET Libraries teaches developers the best practices for designing system frameworks and reusable libraries for use with the Microsoft .NET Framework and WinFX. This book focuses on the design issues that directly affect the programmability of a framework, specifically its publicly accessible APIs. This book can improve the work of any .NET developer producing code that other developers will use. An added benefit is a collection of annotations to the guidelines by various members of the Microsoft .NET Framework and WinFX teams, which provide a lively discussion of the motives behind the guidelines, along with examples of good reasons for breaking the guidelines. Microsoft architects Krzysztof Cwalina and Brad Abrams offer guidelines for framework design from the top down.From their long experience and deep insight, you will learn *The general philosophy of framework design *Principles and guidelines that are fundamental to overall framework design *Naming guidelines for the various parts of a framework, such as namespaces, types, and members *Guidelines for the design of types and members of types *Issues and guidelines that are important to ensure appropriate extensibilityin your framework *Guidelines for working with exceptions, the preferred error reporting mechanism in the . NET Framework and WinFX *Guidelines for extending and using types that commonly appear in frameworks *Guidelines for and examples of common framework design patterns Guidelines in this book come in four major forms: Do, Consider, Avoid, and Do not. In general, a Do guideline should almost always be followed, a Consider guideline should generally be followed, an Avoid guideline indicates that something is generally not a good idea, and a Do not guideline indicates something you should almost never do. Every guideline includes a discussion of its applicability, and most guidelines include a code example. A companion DVD includes the Designing .NET Class Libraries video series, instructional presentations by the authors on design guidelines for developing classes and components that extend the .NET Framework. A sample API specification and other useful resources are also included.

Analysis Patterns: Reusable Object Models (Addison-Wesley Object Technology Series)

Martin Fowler

Analysis Patterns: Reusable Object Models (Addison-Wesley Object Technology Series) Martin Fowler Amazon Price: $51.99
List Price: $64.99
Usually ships in 24 hours
By: Addison-Wesley Professional
Amazon Marketplace: 56 new & used starting at $19.00

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Object-Oriented Design
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Development
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Reuse

Customer Reviews:
Total reviews: 15 Average rating: 4.5 of 5

Study, don't just read this book. 5 out of 5 stars.
20 of 21 people found this review helpful.

I bet you are an object oriented software developer striving to build better applications. If you have not read GoF Design Patterns and followed that with Vlissides's Pattern Hatching, read those first. Follow those with this, Martin Fowler's Analysis Patterns.

As two readings of Design Patterns took my OO knowledge from infancy to adolecence, Analysis Patterns will take you from adolecence to adulthood. Fowler's work does not put together patterns from the Design Patterns book, but takes its time to decompose actual application domain concepts to applicable object models. It will then be up to you to use your knowledge from Design Patterns to create mechanisms that support properly modeled business concepts as Analysis Patterns describes.

If you like OO modeling and design, but are wondering how better to apply your modeling concepts, Fowler's book is something you will definitely benefit from. However, make a pot of coffee per chapter-this book is very dense with concepts.

Fowler ends Analysis Patterns with some more easily read chapters on application design on a larger scale. You've heard of "n-tier," his discussion of the concepts of "n-tier" at the end of the book are possibly worth reading first.

After reading this book-and understanding it's motivations-you will never again be tempted to take "innocent" shortcuts in your application design. You will not be motivated to use "Strings" for "measurements" or "doubles" for "distances." You will look upon your peer's object designs either with a new understanding that they know that going the distance with their object model is worth it-and you won't demand they dumb down their design ever again-and you'll likewise gain intuition about where a simplistic business domain model is going to fail.

Editorial Review:

Martin Fowler is a consultant specializing in object-oriented analysis and design. This book presents and discusses a number of object models derived from various problem domains. All patterns and models presented have been derived from the author's own consulting work and are based on real business cases.

Adobe AIR: Create - Modify - Reuse (Programmer to Programmer)

Marc Leuchner, Todd Anderson, Matt Wright

Adobe AIR: Create - Modify - Reuse (Programmer to Programmer) Marc Leuchner, Todd Anderson, Matt Wright Amazon Price: $26.39
List Price: $39.99
Usually ships in 24 hours
By: Wrox
Amazon Marketplace: 54 new & used starting at $18.80

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Home Computing -> Internet -> General AAS
Subjects -> Computers & Internet -> Graphic Design -> General AAS
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Reuse

Customer Reviews:
Total reviews: 5 Average rating: 4.0 of 5

extended case studies 4 out of 5 stars.
7 of 12 people found this review helpful.

The attraction of this book is the collection of 11 extended examples. Each is a case study in how to use AIR to code desktop applications. There is a slight irony here in the trajectory taken by Adobe. Its original products, and probably still its main revenue sources, were for desktop usages. Think Postscript and PDF. But the rise of the Web caused it to develop Flash for web applications. Now here, we come back to the desktop.

The book's examples involve Java as the programming language. Extensive usage is also made of XML and HTML. You are encouraged to use the examples as a basis for modification for your own needs. The examples are verbose, but luckily you can also get these from the accompanying website.

The examples do vary in their complexity. You may want to pay especial attention to the Map application. This involves accessing a SQL database that comes with AIR. The code shows how to make the necessary tables. If you have in mind a "serious" application with lots of data, then often you'll need a SQL database for it. The example here shows that this can be straightforward.

Editorial Review:

Adobe Integrated Runtime (AIR) revolutionizes the way Rich Internet Applications (RIAs) are deployed and supports two primary technologiesFlash and HTML/Ajaxin order to make desktop development something that every web developer can do. This book walks you through eleven fully implemented AIR applications with source code that you can use as they currently exist or customize. Each project begins with a discussion of architecture and design, followed by code implementation. Youll get hands-on knowledge of AIR application design and development that you can then use to build dynamic RIAs.

Python: Create - Modify - Reuse

James O. Knowlton

Python: Create - Modify - Reuse James O. Knowlton Amazon Price: $26.39
List Price: $39.99
Usually ships in 24 hours
By: Wrox
Amazon Marketplace: 49 new & used starting at $17.50

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> Python
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General AAS

Customer Reviews:
Total reviews: 3 Average rating: 3.5 of 5

Editorial Review:

Python: Create-Modify-Reuse is designed for all levels of Python developers interested in a practical, hands-on way of learning Python development. This book is designed to show you how to use Python (in combination with the raw processing power of your computer) to accomplish real-world tasks in a more efficient way. Don’t look for an exhaustive description of the Python language––you won’t find it. The book’s main purpose is not to thoroughly cover the Python language, but rather to show how you can use Python to create robust, real-world applications.

In this respect, the goal is similar to foreign-language books that identify themselves as “conversational,” focusing on the vocabulary and concepts that people will need the most. Likewise, I focus specifically on the Python knowledge needed to accomplish practical, specific tasks. Along the way, you will learn to create useful, efficient scripts that are easy to maintain and enhance.

This book is for developers with some experience with Python who want to explore how to develop full-blown applications. It is also for developers with experience in other languages who want to learn Python by building robust applications. It is well-suited for developers who like to “learn by doing,” rather than exploring a language feature by feature. To get the most out of the book, you should understand basic programming principles.

Because this book is project-based, you can approach it in numerous ways. You can, of course, read it from cover to cover. Chapters 2 through 8 each cover a different project, so the chapters are independent of each other. However, because each chapter project is covered individually, there may be some overlap of information. I also sometimes refer to explanations of particular topics covered in previous chapters. This will help to reinforce important concepts.

The end of the book contains two appendixes. The first one is a listing of Python resources you can check out for more information. The second one will help you with installing additional components used in some of the examples.

This book starts with a basic overview of the Python language, designed for those familiar with other languages but new to Python. It is followed by several chapters, each of which describes a complete project that can be used as-is or modified and extended to suit your particular purposes. You’ll find applications that access databases, take advantage of web technologies, and facilitate network communications, to name a few. In addition, and more important than the technologies you will be introduced to, you will learn how to use Python to solve real challenges. Following these chapters are two chapters that cover accessing operating system resources and debugging and testing, respectively.

Each project chapter contains complete instructions describing how to install and use the application, so you can actually see the program run as you learn how to construct and use it, including how the project was designed and prototyped. This book is intended to be both a reference guide and a learning aid, teaching you how to build solutions with Python and providing reference information on a wide variety of Python programming concepts.

It is hoped that this book will help you have fun with Python and build useful applications, and—unlike my experience with building a deck—without sore thumbs.

This book is framed around the code itself. This is because developers are typically looking for how to do something; and, as with many activities, you learn how to do something by watching how others do and trying it yourself. If you want to know how a for loop works, you’ll find for loops in my code, but that’s not the thrust of the book. Instead, this book shows you how to do things: how to build a content management system, how to build a test management system, how to set up a system for tracking customer follow-up, and so on. Along the way, you’ll learn how to communicate with a SQL database, how to act as a web server or communicate with one, how to access operating system services, and more.

There are three basic components to the book:

  • Chapter 1 is a brief overview of the Python language.

  • Chapters 2–8 cover seven different programming projects, which illustrate various technologies and techniques available to Python developers.

  • Chapters 9–10 cover additional, advanced topics, which will help you as you build Python projects.

The project chapters have a consistent structure:

  • Overview: What does the application do?

  • Using the program

  • Design

  • How it all fits together

  • Modules involved

  • Code and code explanation

  • Module/class 1 explanation

  • Module/class 2 explanation

  • Minor code file explanation

  • Testing, including suggested tests

  • Modifying the project, including some suggested adaptations

  • Summary

Each project is designed with classes that can be reused and accessed for multiple purposes. This is one of the main benefits of object-oriented programming, so designing for reusability is a main focus of the book. The book contains the following chapters:

1. Python Basics

This chapter is a basic primer on the Python language, and it functions as either a quick tutorial for experienced programmers new to Python or a refresher for programmers with Python experience.

Part I: The Projects

2. Directory/File Snapshot Program

This project demonstrates how to interact with files, create and manipulate data structures, and provide user output. It also touches on code design issues to improve code maintainability. Often when installing or uninstalling software, or verifying changes to a file system, it can be valuable to take a “snapshot” of the files and directories, along with their size and last-modified time. The script introduced in this chapter does just that. This chapter also explores how to capture a directory listing into a Python list, and explains how to query this list for particular values.

3. DVD Inventory System

This project takes advantage of Python’s capability to access and manipulate data in a SQL database. The application enables multiple users to log in to a website that provides access to a DVD inventory database. Permissions are set such that some users can add, modify, or delete entries, whereas other users have read-only access to the data.

4. Web Performance Tester

This project shows how to communicate with a Python web server and retrieve information regarding how long it takes to receive requested items from the web server. Although writing Python programs to work on a single computer can be useful, the real power of Python can be seen when it is used to script communication between computers on a network. Most networks contain several web servers. A nice feature of Python is that it can act as a lightweight server for various Internet protocols, such as HTTP (web) and ftp. This application enables you to monitor performance of HTTP traffic on your network.

5. Customer Follow-Up System

This project shows how to present a web form to the user and retrieve data from it, how to automatically format and send e-mail through an SMTP server, and how to generate an HTML-formatted report. The task for the second example is to automatically generate a customer comments e-mail message based on information the customer enters in a form. It uses the mod_python Apache module to take the information entered in the HTTP form and then utilizes a Python script on the web server to send that information to an SMTP server for mail delivery.

6. Test Management/Reporting System

This project makes use of the unittest module to run tests against an existing application, and creates a framework for reporting test results. Testing is a vital process for developing software. This application enables users to run tests for a given piece of software, to list the previous test runs by date, to show test run results for any previously run tests, and to output the results of any test run as HTML for viewing in a web browser.

7. Version Management System

This project connects to a list of servers via telnet, checks the application version of a pre-set application list, and displays its results both as output and to a log file. Often, a system administrator needs to patch systems or ensure that systems have the latest application versions installed. This script is an easy way to accomplish that task. It makes use of Python’s capability to emulate a telnet client and log in to remote systems and perform functions on that remote system.

8. Content Management System

This project explores Plone, a popular content management system based on Python and Zope (a Python-based application server). Because Python is a very mature language, numerous applications have been built on top of it. A great thing about working with Python-based applications is that you get the benefit of a full-blown application but you can still use Python to configure and customize it.

Part II: Advanced Topics

9. Interacting with the Operating System

When writing scripts “in the real world,” often it is critical to be able to access services available through (and particular to) the operating system you happen to be on. For example, suppose you wanted to read or modify the Window Registry? Or you wanted to get the Linux process ID of a particular process that is running? Is such a thing even possible? Definitely—and this chapter shows you how.

10. Debugging and Testing

Because I am a software tester myself, testing is a subject that is ...

Patterns in Java: A Catalog of Reusable Design Patterns Illustrated with UML, 2nd Edition, Volume 1

Mark Grand

Patterns in Java: A Catalog of Reusable Design Patterns Illustrated with UML, 2nd Edition, Volume 1 Mark Grand Amazon Price: $34.20
List Price: $45.00
Usually ships in 24 hours
By: Wiley
Amazon Marketplace: 36 new & used starting at $7.59

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Computer Science -> General
Subjects -> Computers & Internet -> Computer Science -> General AAS
Subjects -> Computers & Internet -> Programming -> Java -> General

Customer Reviews:
Total reviews: 63 Average rating: 3.0 of 5

Editorial Review:

"This is the best book on patterns since the Gang of Four's Design Patterns. The book manages to be a resource for three of the most important trends in professional programming: Patterns, Java, and UML."
—Larry O'Brien, Founding Editor, Software Development Magazine

Since the release of Design Patterns in 1994, patterns have become one of the most important new technologies contributing to software design and development. In this volume Mark Grand presents 41 design patterns that help you create more elegant and reusable designs. He revisits the 23 "Gang of Four" design patterns from the perspective of a Java programmer and introduces many new patterns specifically for Java. Each pattern comes with the complete Java source code and is diagrammed using UML.

Patterns in Java, Volume 1 gives you:

  • 11 Behavioral Patterns, 9 Structural Patterns, 7 Concurrency Patterns, 6 Creational Patterns, 5 Fundamental Design Patterns, and 3 Partitioning Patterns
  • Real-world case studies that illustrate when and how to use the patterns
  • Introduction to UML with examples that demonstrate how to express patterns using UML

The CD-ROM contains:

  • Java source code for the 41 design patterns
  • Trial versions of Together/J Whiteboard Edition from Object International (www.togetherj.com); Rational Rose 98 from Rational Software (www.rational.com); System Architect from Popkin Software (www.popkin.com); and OptimizeIt from Intuitive Systems, Inc.

C Interfaces and Implementations: Techniques for Creating Reusable Software (Addison-Wesley Professional Computing Series)

David R. Hanson

C Interfaces and Implementations: Techniques for Creating Reusable Software (Addison-Wesley Professional Computing Series) David R. Hanson Amazon Price: $43.99
List Price: $54.99
Usually ships in 24 hours
By: Addison-Wesley Professional
Amazon Marketplace: 30 new & used starting at $23.70

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Computer Science -> Software Engineering -> General AAS
Subjects -> Computers & Internet -> Microsoft -> Development -> C & C++ Windows Programming
Subjects -> Computers & Internet -> Programming -> Languages & Tools -> General

Customer Reviews:
Total reviews: 12 Average rating: 4.0 of 5

Editorial Review:

Every programmer and software project manager must master the art of creating reusable software modules; they are the building blocks of large, reliable applications. Unlike some modern object-oriented languages, C provides little linguistic support or motivation for creating reusable application programming interfaces (APIs). While most C programmers use APIs and the libraries that implement them in almost every application they write, relatively few programmers create and disseminate new, widely applicable APIs. C Interfaces and Implementations shows how to create reusable APIs using interface-based design, a language-independent methodology that separates interfaces from their implementations. This methodology is explained by example. The author describes in detail 24 interfaces and their implementations, providing the reader with a thorough understanding of this design approach. Features of C Interfaces and Implementations: *Concise interface descriptions that comprise a reference manual for programmers interested in using the interfaces.* A guided tour of the code that implements each chapter's interface tp help those modifying or extending an interface or designing related interfaces. *In-depth focus on "algorithm engineering:" how to package data structures and related algorithms into reusable modules. *Source code for 24 APIs and 8 sample applications is examined, with each presented as a "literate program" in which a thorough explanation is interleaved with the source code. *Rarely documented C programming tricks-of-the-trade. *Convenient access to all source code in the book via the World Wide Web at http://www.cs.princeton.edu/software/cii/ 0201498413B04062001

Measuring Software Reuse: Principles, Practices, and Economic Models

Jeffrey S. Poulin

Measuring Software Reuse: Principles, Practices, and Economic Models Jeffrey S. Poulin Amazon Price: $27.57
List Price: $39.99
Usually ships in 1 to 3 weeks
By: Addison-Wesley Professional
Amazon Marketplace: 10 new & used starting at $21.10

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Computer Science -> Software Engineering -> Information Systems
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Development
Subjects -> Computers & Internet -> Programming -> Software Design, Testing & Engineering -> Software Reuse

Customer Reviews:
Total reviews: 5 Average rating: 4.0 of 5

A Wealth of Practical Knowledge! 5 out of 5 stars.
11 of 11 people found this review helpful.

This book clearly explained the toughest problems associated with measuring reuse. It had numerous practical examples and references to break down the most difficult topics- especially "what should I measure?" in Chapter 4. I found the approach practical and applicable to any organization.

Excellent Practical Guide to Measuring Reuse! 5 out of 5 stars.
11 of 11 people found this review helpful.

This book explained things that no one else ever had presented, especially all the difficulties in actually getting a project to implement reuse metrics. I found it invaluable. It covers all languages (we use C++) and on my project we used the example metrics in the book to establish our own reuse program!

I highly recommend the book!

Editorial Review:

With the techniques in this book, you will have the tools you need to design afar more effective reuse program, prove its bottom-line profitability, and promote software reuse within your organization. Written by a leading software reuse practitioner, Measuring Software Reuse brings together all of the latest concepts, tools, and methods for software reuse metrics, presenting concrete quantitative techniques for accurately measuring the level of reuse in a software project and objectively evaluating its financial benefits.

Software Reuse: Architecture, Process and Organization for Business Success (ACM Press)

Ivar Jacobson, M. Griss, P. Jonsson

Software Reuse: Architecture, Process and Organization for Business Success (ACM Press) Ivar Jacobson, M. Griss, P. Jonsson Amazon Price: $59.99
List Price: $74.99
Usually ships in 24 hours
By: Addison-Wesley Professional
Amazon Marketplace: 42 new & used starting at $3.39

Buy at Amazon.com

Browse similar items by category:
Subjects -> Computers & Internet -> Computer Science -> Software Engineering -> Design Tools & Techniques
Subjects -> Computers & Internet -> Computer Science -> Software Engineering -> General
Subjects -> Computers & Internet -> Computer Science -> Software Engineering -> General AAS

Customer Reviews:
Total reviews: 3 Average rating: 5.0 of 5

Editorial Review:

"How can I incorporate reuse into my complex software development process in order to gain a competitive edge?" This is a question that many have attempted to answer by taking up object technology, with varying degrees of success. In Software Reuse: Architecture, Process and Organization for Business Success , the authors present a brand new, technically innovative, coherent and systematic model for implementing reuse. They have combined their experience in the fields of object oriented software engineering, business engineering and systematic software reuse to create the Reuse-Driven Software Engineering Business (Reuse Business) framework. "Software Reuse: Architecture, Process and Organization for Business Success - "introduces the concept of software reuse as a business success enable - describes how the right architecture allows applications and components to evolve gracefull - provides guidelines for implementing software engineering processe - advises on organizational issues such as the structure, transition, day-to-day managment, economics and measurement.Whether you are a software engineer, architect, designer, programmer or manager, whether you are familiar with the concepts of reuse, component-based software engineering, object oriented technology and business engineering or not, you should read Software Reuse: Architecture, Organization and Process for Business Success. In it you will find new ground-breaking information and advice Visit the Rational Web Site http://www.rational.com

Page 1 of 17 - Go to page: 1 2 3 4 5 6 12

Return to MagicBeanDip.com

This page was created in 0.1312 seconds.