SmalltalkObjectsandDesign:Contents

From 흡혈양파의 번역工房
Jump to: navigation, search
Smalltalk Objects and Design 목차
  • Acknowledgements
  • Preface


  • chapter 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


  • chapter 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


  • chapter 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


  • chapter 4 Exercises - Foundations
    • Precautions
    • Finding things in Smalltalk
    • Elements of Smalltalk
    • Smalltalk's debugger
    • Provocations


  • chapter 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


  • chapter 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++


  • chapter 7 CRC cards
    • Design exercise
    • Solution and discussion
    • Common questions and answers
    • Commentary: analysis, design, and implementation


  • chapter 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


  • chapter 9 When (not) to inherit
    • Historical background
    • Inverting hierarchies
    • Buy or inherit?
    • Exercise
    • Solution and discussion
    • Conclusions
    • Commentary: multiple inheritance


  • chapter 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


  • chapter 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?


  • chapter 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


  • chapter 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


  • chapter 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


  • chapter 15 Practicing polymorphism
    • Design exercise I: a shape editor
    • Solution and discussion
    • Design exercise II : undo and redo
    • Solution and discussion
    • Implementing undo
    • Summary


  • chapter 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


  • chapter 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


  • chapter 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


  • chapter 19 Frameworks (one hearty example)
    • Problems
    • Materialization
    • Managing object identity
    • Searching (filtering)
    • Updating
    • Summary
    • Commentary: varieties of brokers
    • Commentary: buying outdoes inheriting (sometimes)


  • chapter 20 Metaclasses
    • Facts about metaclasses
    • Inheritance
    • Method new
    • The full picture
    • Recapitulation
    • Exercises


  • chapter 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