Atjaunināt sīkdatņu piekrišanu

Building Object Applications that Work: Your Step-by-Step Handbook for Developing Robust Systems with Object Technology [Mīkstie vāki]

(AmbySoft Inc., Toronto)
  • Formāts: Paperback / softback, 508 pages, height x width x depth: 254x178x26 mm, weight: 870 g
  • Sērija : SIGS: Managing Object Technology
  • Izdošanas datums: 13-Feb-1998
  • Izdevniecība: Cambridge University Press
  • ISBN-10: 0521648262
  • ISBN-13: 9780521648264
Citas grāmatas par šo tēmu:
  • Mīkstie vāki
  • Cena: 95,03 €
  • Grāmatu piegādes laiks ir 3-4 nedēļas, ja grāmata ir uz vietas izdevniecības noliktavā. Ja izdevējam nepieciešams publicēt jaunu tirāžu, grāmatas piegāde var aizkavēties.
  • Daudzums:
  • Ielikt grozā
  • Piegādes laiks - 4-6 nedēļas
  • Pievienot vēlmju sarakstam
Building Object Applications that Work: Your Step-by-Step Handbook for Developing Robust Systems with Object TechnologyPalielināt
  • Formāts: Paperback / softback, 508 pages, height x width x depth: 254x178x26 mm, weight: 870 g
  • Sērija : SIGS: Managing Object Technology
  • Izdošanas datums: 13-Feb-1998
  • Izdevniecība: Cambridge University Press
  • ISBN-10: 0521648262
  • ISBN-13: 9780521648264
Citas grāmatas par šo tēmu:
Permanent link: https://www.kriso.lv/db/9780521648264.html
Keywords:
Reviews the entire process of building object applications from analyzing the project, to designing a user-friendly interface and testing the functionality of your approaches.

Written by internationally-acclaimed trainer and developer Scott Ambler, this book is a must-have resource for designers, programmers and testers of today's OO applications. The author takes you through the entire process of building object applications, from analyzing the project, to designing a user-friendly interface, to testing your approaches to make sure your applications work properly. Building Object Applications That Work includes sections on: how to use the Unified Modeling Language effectively; analysis, so you know what you need to build; design techniques, so that you know how you are going to build your application; collecting the right metrics to improve your development approach; applying OO patterns to improve the quality of your applications; creating applications for stand-alone, client/server and distributed environments; using both relational and object-oriented databases to make your objects persistent; and architecting your applications so they are maintainable and extensible.

Recenzijas

"...Scott Ambler's book delivers exactly what it promises- a robust look into building object applications. This is no small feat given the wide range of object-oriented development. Ambler's willingness to depart from a UML-only viewpoint and to advocate practical techniques like CRC modeling or data modeling provides a bridge from classic CASE methods to object-oriented design, It also has the strong feel of practical object-oriented application building experience. Its common thrust is an elaboration of theory into usable practices for developing robust object-oriented systems." Software Development

Papildus informācija

Reviews the entire process of building object applications from analyzing the project, to designing a user-friendly interface and testing the functionality of your approaches.
About the Author xix(2)
Foreword xxi(2)
Preface xxiii(6)
Acknowledgments xxix
Part I INTRODUCTION TO BUILDING OBJECT APPLICATIONS 3(46)
Chapter 1 Where We've Been Before-Object-Oriented Concepts and Techniques
3(46)
1.1 Object-Oriented Concepts-A Really Quick Recap
4(10)
1.1.1 Objects and Classes
5(1)
1.1.2 Attributes and Methods
6(1)
1.1.3 Abstraction, Encapsulation, and Information Hiding
6(2)
1.1.4 Inheritance
8(1)
1.1.5 Persistence
9(1)
1.1.6 Instance Relationships
10(1)
1.1.7 Aggregation
11(1)
1.1.8 Collaboration
12(1)
1.1.9 Coupling and Cohesion
12(1)
1.1.10 Polymorphism
13(1)
1.2 Object-Oriented Analysis and Design Techniques-A Really Quick Recap
14(13)
1.2.1 CRC Modeling
14(6)
1.2.2 Use-Case Scenario Testing
20(5)
1.2.3 Class Diagramming
25(2)
1.3 Iterative Object-Oriented Development-The Pinball System Development Life Cycle (SDLC)
27(6)
1.3.1 The Pinball Metaphor
28(2)
1.3.2 The Steps of the Pinball SDLC
30(3)
1.4 What We Missed in The Object Primer
33(9)
1.4.1 The Difference Between Class and Instance Attributes
33(2)
1.4.2 The Difference Between Class and Instance Methods
35(2)
1.4.3 The Implications of Class Attributes and Methods
37(3)
1.4.4 What We Mean When We Say "Attribute" or "Method,"
40(1)
1.4.5 The Ambler Class Diagram Notation v2.0
40(1)
1.4.6 The Unified Modeling Language Class-Diagram Notation (Simplified)
41(1)
1.5 Just in Case You've Forgotten-The Bank Case Study
42(3)
1.5.1 The ABC Case Study
42(3)
1.6 Where We're Going in This Book
45(4)
Part II OBJECT-ORIENTED ANALYSIS, DESIGN, AND ARCHITECTURE 49(122)
Chapter 2 Bubbles and Lines-Useful Diagrams for Object-Oriented Analysis and Design
49(36)
2.1 The Importance of Bubbles and Lines
50(4)
2.1.1 Making Your Diagrams Look Good
50(4)
2.2 Other People's Notations-Understanding Class Diagrams
54(3)
2.3 Use-Case Diagrams-Understanding Use Cases
57(3)
2.3.1 Drawing Use-Case Diagrams
58(1)
2.3.2 Why and When Should We Create Use-Case Diagrams?
59(1)
2.4 Sequence Diagrams-Understanding Use Cases Even Better
60(3)
2.4.1 How to Draw Sequence Diagrams
62(1)
2.4.2 Why and When Should We Draw Sequence Diagrams?
63(1)
2.5 State Diagrams-Understanding Complicated Classes
63(6)
2.5.1 How to Draw a State Diagram
66(1)
2.5.2 Taking State Diagramming a Bit Further
67(1)
2.5.3 When and Why Should We Draw State Diagrams?
68(1)
2.6 Collaboration Diagrams
69(1)
2.6.1 Drawing Collaboration Diagrams
69(1)
2.6.2 Why and When Should We Draw Collaboration Diagrams?
70(1)
2.7 Process Models-Understanding What's Currently Going On
70(4)
2.7.1 Drawing Process Models
72(2)
2.7.2 Why and When Should We Draw Process Models?
74(1)
2.8 Interface-Flow Diagrams-Understanding the User Interface
74(3)
2.8.1 Drawing Interface-Flow Diagrams
75(1)
2.8.2 Why and When Should We Draw Interface-Flow Diagrams?
76(1)
2.9 Data Models-Modeling Your Database Design
77(2)
2.9.1 Drawing Data Models
78(1)
2.9.2 Why and When Should We Draw Data Models?
79(1)
2.10 An Overall Analysis and Design Strategy
79(2)
2.11 What We've Learned
81(4)
Chapter 3 Improving Your Design-A Class-Type Architecture
85(32)
3.1 Why Do We Need a Class-Type Architecture?
87(1)
3.2 Building Up to a Class-Type Architecture
87(11)
3.2.1 A Two-Layer Class-Type Architecture
88(2)
3.2.2 A Three-Layer Class-Type Architecture
90(3)
3.2.3 A Four-Layer Class Architecture
93(4)
3.2.4 A Five-Layer Class-Type Architecture
97(1)
3.3 A Detailed Look at the Various Class Types
98(8)
3.3.1 Interface Classes
98(3)
3.3.2 Business Classes
101(1)
3.3.3 Persistence Classes
102(3)
3.3.4 System Classes
105(1)
3.4 Issues with the Five-Layer Class-Type Architecture
106(8)
3.4.1 To Which Layer Does This Class Belong?
106(1)
3.4.2 Can I Buy Some of These Classes?
107(2)
3.4.3 What Are the Implications for Project Management?
109(1)
3.4.4 What Are the Implications for Development?
110(3)
3.4.5 Is This Enough?
113(1)
3.4.6 What Are the Advantages and Disadvantages?
114(1)
3.5 What We've Learned
114(3)
Chapter 4 Reusing Your Development Efforts-Object-Oriented Patterns
117(22)
4.1 Design Patterns
119(6)
4.1.1 Singleton
119(1)
4.1.2 Proxy
120(2)
4.1.3 Roles Played (State)
122(3)
4.2 Analysis Patterns
125(7)
4.2.1 Item-Item Description
126(2)
4.2.2 Business Entity
128(1)
4.2.3 Contact Point
128(2)
4.2.4 Shipping/Billing
130(1)
4.2.5 Place
131(1)
4.3 How to Use Patterns Effectively
132(1)
4.4 How to Discover New Patterns
133(1)
4.5 The Advantages and Disadvantages of Patterns
134(2)
4.5.1 Advantages
134(1)
4.5.2 Disadvantages
135(1)
4.6 What We've Learned
136(3)
Chapter 5 Development in the 90s and Beyond-Designing Distributed Object-Oriented Applications
139(32)
5.1 Centralized Mainframes
141(1)
5.2 Client/Server
142(6)
5.2.1 Two-Tier Client/Server
144(2)
5.2.2 Three-Tier Client/Server
146(2)
5.3 Distributed Classes
148(13)
5.3.1 "Traditional" Client/Server Using Object Technology
149(1)
5.3.2 Taking a Peer-to-Peer Approach--Object-Oriented Client/Server
149(11)
5.3.3 Applets
160(1)
5.4 Distributed Objects
161(6)
5.4.1 Common Object Request Broker Architecture
163(4)
5.5 What We've Learned
167(4)
Part III OBJECT-ORIENTED CONSTRUCTION 171(192)
Chapter 6 Measuring and Improving the Quality of Your Work-Object-Oriented Metrics
171(26)
6.1 What Are Metrics and What Can They Do for/to Me?
172(1)
6.2 Estimating Projects
173(5)
6.2.1 Number of Key Classes
174(1)
6.2.2 Person Days per Class
174(1)
6.2.3 Classes per Developer
175(1)
6.2.4 Number of Reused Classes
176(1)
6.2.5 Function and Feature Points
177(1)
6.3 Improving Your Development Efforts
178(12)
6.3.1 Analysis Metrics
179(1)
6.3.2 Design Metrics
180(5)
6.3.3 Construction Metrics
185(4)
6.3.4 Testing Metrics
189(1)
6.4 Choosing the Right Tools
190(1)
6.4.1 Comments per Method and Percentage of Commented Methods
190(1)
6.5 Improving Your Development Approach
191(1)
6.6 Metrics Success Factors
191(3)
6.7 What We've Learned
194(3)
Chapter 7 Choosing an Object-Oriented Language-Comparing the Leading Languages
197(24)
7.1 What to Look For in an OO Language
198(4)
7.2 The Leading OO Languages
202(5)
7.2.1 C++
202(1)
7.2.2 Java
203(2)
7.2.3 ObjectCOBOL
205(2)
7.2.4 Smalltalk
207(1)
7.2.5 Comparing the Leading OO Languages
207(1)
7.3 Understanding Electronic Commerce on the Internet
207(9)
7.3.1 An Architecture for Supporting Electronic Commerce
209(1)
7.3.2 Payment Processing on the Internet
210(1)
7.3.3 It's the WORLD Wide Web-International Issues
211(1)
7.3.4 You Can Sell Both Physical and Virtual Products Internationally
212(1)
7.3.5 Don't Forget Taxes
212(1)
7.3.6 Using Smalltalk/ObjectCOBOL and Java to Develop Electronic Commerce Applications
213(3)
7.4 Beyond Programming Languages-Other Development Tools
216(2)
7.5 What We've Learned
218(3)
Chapter 8 Building Your Application-Effective Object-Oriented Construction Techniques
221(40)
8.1 Attitude Is Everything
222(4)
8.1.1 There's More to Development Than Just Coding
222(1)
8.1.2 There's More to Development Than Just Development
223(1)
8.1.3 You Need to Get the Design Right First
224(1)
8.1.4 You Need to Develop in Small Steps
225(1)
8.1.5 You Need to Work Closely with Your Users
226(1)
8.2 Working with Attributes Effectively
226(11)
8.2.1 Naming Attributes
226(3)
8.2.2 Accessor Methods
229(8)
8.3 Writing High-Quality Methods
237(10)
8.3.1 Naming Methods
237(1)
8.3.2 Documenting Methods
237(4)
8.3.3 Paragraphing Your Code
241(1)
8.3.4 Methods Should Always Do Something
242(1)
8.3.5 Methods Should Do One Thing Only
243(1)
8.3.6 Do One Thing per Line
244(1)
8.3.7 The 30-Second Rule
245(1)
8.3.8 Specify Order of Message Sends
245(1)
8.3.9 Polymorphism the Right Way-Avoiding Case Statements
246(1)
8.4 Creating Maintainable Classes
247(2)
8.4.1 The Law of Demeter
247(2)
8.5 Programming Techniques and Approaches
249(6)
8.5.1 Implementing Instance Relationships
249(2)
8.5.2 Error Handling
251(2)
8.5.3 Callback Methods and Message Dispatchers
253(2)
8.6 Organizing Construction Around the Class-Type Architecture
255(1)
8.7 What We've Learned
256(5)
Chapter 9 Making Your Applications Usable-Object-Oriented User Interface Design
261(30)
9.1 What Are Object-Oriented User Interfaces?
262(7)
9.1.1 An OO Bank Teller Application
264(4)
9.1.2 Why OOUIs Are Different but the Same
268(1)
9.2 Designing Effective User Interfaces
269(9)
9.2.1 Human Factors, the Study of People Using Machines
269(4)
9.2.2 Enough User Interface Design Tips to Sink a Ship, and Then Some
273(5)
9.3 Developing Effective Object-Oriented User Interfaces
278(9)
9.3.1 Applications Are No More, Just Objects
278(2)
9.3.2 You're Working with Objects Too, Not Just Windows
280(1)
9.3.3 Modeling Object-Oriented User Interfaces
281(1)
9.3.4 Prototyping Object-Oriented User Interfaces
282(5)
9.4 What We've Learned
287(4)
Chapter 10 Making Your Objects Persistent-Object-Orientation and Databases
291(52)
10.1 Getting Started-Some Common Terminology
292(3)
10.2 Saving Your Objects into Flat Files
295(3)
10.2.1 An Approach to Mapping Objects to Flat Files
295(3)
10.3 The Current Reality-Relational Technology and OO Applications
298(36)
10.3.1 Normalization
299(12)
10.3.2 Overcoming the Object/Relational Impedance Mismatch
311(15)
10.3.3 An Approach for Mapping Objects to Relational Databases
326(6)
10.3.4 The Seven Commandments for Mapping Objects to Relational Databases
332(2)
10.3.5 Looking into My Crystal Ball-OO and RDB in the Future
334(1)
10.4 Persistence on the Leading Edge-Object-Oriented Data-bases
334(5)
10.4.1 What to Look For in an OODBMS
335(3)
10.4.2 Debunking the Myths of Object Databases
338(1)
10.5 Taking a Hybrid Approach-Object/Relational Databases
339(2)
10.6 What We've Learned
341(2)
Chapter 11 Integrating Legacy Code-Wrapping
343(20)
11.1 Why Wrap?
344(2)
11.2 Approaches to Wrapping
346(2)
11.2.1 Leaving Things Well Enough Alone
347(1)
11.2.2 Wrapping Only Hardware and Operating System Calls
347(1)
11.2.3 Scaffolding Legacy Applications
347(1)
11.3 Wrapping Technologies
348(9)
11.3.1 Wrapping Hardware and Operating-System Calls
348(3)
11.3.2 Wrapping Legacy Applications
351(4)
11.3.3 Comparing Wrapping Technologies-When to Use Each One
355(2)
11.4 The Advantages and Disadvantages of Wrapping
357(1)
11.5 What We've Learned
358(5)
Part IV OBJECT-ORIENTED TESTING 363(56)
Chapter 12 Making Sure Your Applications Work-Full Life-Cycle Object-Oriented Testing (FLOOT)
363(56)
12.1 Why FLOOT?
365(2)
12.2 Testing Your Previous Efforts-Regression Testing
367(2)
12.3 Testing Your Analysis
369(3)
12.3.1 Use-Case Scenario Testing
370(1)
12.3.2 Prototype Walkthroughs
370(1)
12.3.3 User-Requirement Reviews
371(1)
12.4 Testing Your Design
372(8)
12.4.1 Technical-Design Reviews
372(7)
12.4.2 Requirement-Verification Matrices
379(1)
12.5 Testing Your Program Code
380(23)
12.5.1 Code Reviews
382(1)
12.5.2 Traditional Testing Methods
383(5)
12.5.3 New Testing Techniques for OO Program Code
388(10)
12.5.4 Language-Specific Testing Issues
398(1)
12.5.5 Implementing Program Code Test Cases
398(3)
12.5.6 A Process for Successfully Testing Your Code
401(1)
12.5.7 The Strengths of Each Program Code Testing Technique
402(1)
12.6 Testing Your Application As a Whole
403(7)
12.6.1 System Testing
403(4)
12.6.2 User-Acceptance Testing
407(2)
12.6.3 Alpha, Beta, and Pilot Testing
409(1)
12.7 Software Quality Assurance and ISO 9000
410(2)
12.8 Testing Tips and Techniques
412(2)
12.9 Full Life-Cycle Object-Oriented Testing Overview
414(1)
12.10 What We've Learned
415(4)
Part V CONCLUSION 419(8)
Chapter 13 Where to Go from Here-Personal Success Strategies
419(8)
13.1 Advice for Overcoming the OO Learning Curve
420(2)
13.2 What We Learned in This Book
422(2)
13.3 Parting Words
424(3)
APPENDICES 427(30)
Appendix A Notation Summary 427(2)
A.1 The Ambler Class Diagramming Notation, v2.0 427(1)
A.2 The Unified Modeling Language Class-Diagramming Notation v1.0 (Simplified) 428(1)
Appendix B Visual Glossary 429(28)
Index 457