SmalltalkObjectsandDesign:Contents
- Smalltalk Objects and Design 목차
- Acknowledgements
- Preface
- part 1 Objects
- Objects
- Examples of Smalltalk messages(telegrams)
- Pitfall: the effect versus the return
- Why objects matter
- recap: objects
- Exercise: warmup (the image)
- Commentary: perspectives on objects
- part 2 Classes and inheritance
- Classes
- The word "class"
- Inheritance
- Terminology
- Exercise: hierarchies
- Solution and discussion: Aggregation hierarchies
- Example: aggregation plus inheritance
- Syntaces for inheritance
- Example: inheritance in Smalltalk
- Exercise: building a class hierarchy
- Commentary: what is object-oriented programming?
- Commentary: other languages
- Commentary: history
- part 3 Smalltalk introduction
- Elementary objects
- Messages and their precedences
- Pitfalls: basic Smalltalk gotchas
- Examples
- Exercise: a hypothetical method
- Solution and discussion
- Kinds of variables
- Pitfall: variables != objects
- Classes are objects
- Control flow
- Commentary: metaclasses
- part 4 Exercises - Foundations
- Precautions
- Finding things in Smalltalk
- Elements of Smalltalk
- Smalltalk's debugger
- Provocations
- part 5 Abstract classes
- Exercise in object-oriented design
- Solution and discussion
- Pure virtual (subclassRespinsibility) methods
- Exercise: discovering pure virtuals
- Solution and discussion
- Ensuring no instances
- Concrete behavior in abstracr classes
- Summery: methods in abstract classes
- part 6 Containers and other indispensable ideas
- Heterogeneity and homogeneity
- Exercise: heterogeneity and homogeneity
- Exercise: dictionaries
- Preparatory exercise: identity versus equality
- Identity dictionaries
- Exercise: identity dictionaries
- Overriding equality
- Exercise: anomaly of the disappearing element
- Exercise: excursion into Streams
- Con tainers versus aggregations
- Shallow and deep copying
- Commentary: value and reference semantics
- Commentary: containers in C++
- part 7 CRC cards
- Design exercise
- Solution and discussion
- Common questions and answers
- Commentary: analysis, design, and implementation
- part 8 Exercises-Implementing a design
- Create the classes
- A test case
- Write "new" methods
- Write instance methods
- Test your solution
- Engineering discipline
- A minor variation
- "Private" methods
- Commentary: getters and setters
- Summary
- part 9 When (not) to inherit
- Historical background
- Inverting hierarchies
- Buy or inherit?
- Exercise
- Solution and discussion
- Conclusions
- Commentary: multiple inheritance
- part 10 Use cases and dynamic relationships
- Interaction diagrams
- Exercise
- Solution and discussion
- Use cases and interaction diagrams in analysis and design
- Limitations
- Summary
- Commentary: historical note
- part 11 The venerable model-view-controller
- Model-view-controller example
- Exercise
- How MVC works
- Exercise: the original dependency mechanism
- MVC: benefirs and difficulties
- What's become of MVC?
- part 12 Building windows
- What you need to know about Motif
- Widget resources
- Excursion: pool dictionaries
- Exercise: a first window
- Exercise: a window for the account balance
- Exercise: a window for transaction log
- Exercise: a window containing both widgets
- Assessment : building windows
- Callbacks and events
- Preparation
- Exercise: mouse event handling
- Challenging exercise: dynamic updates
- Summary
- part 13 Designing the UI: a brief tour
- User interfaces
- Elementary examples
- Coherent conceptual models
- Metaphor
- Magic
- Exercise: design a user interface
- Discussion of your results
- Isomorphism
- Summary
- part 14 Polymorphism
- Dynamic binding
- Dynamic binding enables ... polymorphism
- A word on terminology
- Exercise: polymorphism
- Solutions and discussion
- Exercise: Smalltalk's if-less-ness
- Solution
- Summary tip
- Commentary: performance
- Commentary: Smalltalk, C++, and type-checking
- Commentary: the tomaro in the mailbox
- Commentary: multi-methods
- part 15 Practicing polymorphism
- Design exercise I: a shape editor
- Solution and discussion
- Design exercise II : undo and redo
- Solution and discussion
- Implementing undo
- Summary
- part 16 How object-oriented languages work
- Virtual machines
- Method lookup
- Memory management: a brief hisrory of garbage collection
- The irony of garbage collection
- Commentary: why not garbage collect C++?
- Smalltalk deviates from uniformity
- Exercises
- Summary
- part 17 Two kinds of inheritance
- Beauty and the beast
- Why types matter: polymorphism
- Commentary: an aside on subsets
- Commentary: what does "consistency" mean?
- Consistency and Smalltalk
- Exercise: Smalltalk's container "types"
- Solution and discussion
- Exercise: Smalltalk's container "classes"
- Solution and discussion
- Summary
- Commentary: standardizing Smalltalk
- part 18 Design patterns
- Notation
- Smart container (aka collection-worker)
- Reification
- Command
- Factory method
- Objects from records
- Proxies and ghosts, I
- Proxies and ghosts, II
- Dependency
- Solitaire (aka singleton)
- Duet (aka pas de deux, double dispatch)
- Lawyer (aka object handler)
- Composite
- Visitor
- Conclusion
- Commentary: history
- part 19 Frameworks (one hearty example)
- Problems
- Materialization
- Managing object identity
- Searching (filtering)
- Updating
- Summary
- Commentary: varieties of brokers
- Commentary: buying outdoes inheriting (sometimes)
- part 20 Metaclasses
- Facts about metaclasses
- Inheritance
- Method new
- The full picture
- Recapitulation
- Exercises
- part 21 Why developing software is still hard
- Misconceptions 264
- Where projects go awry: borders
- Characteristics of successful projects
- An optimistic conclusion
- Appendix: Some differences between dialects
- References
- Index