SmalltalkObjectsandDesign:Contents: Difference between revisions

From 흡혈양파의 번역工房
Jump to navigation Jump to search
(SOAD 목차 페이지 추가)
 
No edit summary
 
Line 5: Line 5:




* part 1 Objects
* chapter 1 Objects
** Objects
** Objects
** Examples of Smalltalk messages(telegrams)
** Examples of Smalltalk messages(telegrams)
Line 15: Line 15:




* part 2 Classes and inheritance
* chapter 2 Classes and inheritance
** Classes
** Classes
** The word "class"
** The word "class"
Line 31: Line 31:




* part 3 Smalltalk introduction
* chapter 3 Smalltalk introduction
** Elementary objects
** Elementary objects
** Messages and their precedences
** Messages and their precedences
Line 45: Line 45:




* part 4 Exercises - Foundations
* chapter 4 Exercises - Foundations
** Precautions
** Precautions
** Finding things in Smalltalk
** Finding things in Smalltalk
Line 53: Line 53:




* part 5 Abstract classes
* chapter 5 Abstract classes
** Exercise in object-oriented design
** Exercise in object-oriented design
** Solution and discussion
** Solution and discussion
Line 64: Line 64:




* part 6 Containers and other indispensable ideas
* chapter 6 Containers and other indispensable ideas
** Heterogeneity and homogeneity
** Heterogeneity and homogeneity
** Exercise: heterogeneity and homogeneity
** Exercise: heterogeneity and homogeneity
Line 80: Line 80:




* part 7 CRC cards
* chapter 7 CRC cards
** Design exercise
** Design exercise
** Solution and discussion
** Solution and discussion
Line 87: Line 87:




* part 8 Exercises-Implementing a design
* chapter 8 Exercises-Implementing a design
** Create the classes
** Create the classes
** A test case
** A test case
Line 100: Line 100:




* part 9 When (not) to inherit
* chapter 9 When (not) to inherit
** Historical background
** Historical background
** Inverting hierarchies
** Inverting hierarchies
Line 110: Line 110:




* part 10 Use cases and dynamic relationships
* chapter 10 Use cases and dynamic relationships
** Interaction diagrams
** Interaction diagrams
** Exercise
** Exercise
Line 120: Line 120:




* part 11 The venerable model-view-controller
* chapter 11 The venerable model-view-controller
** Model-view-controller example
** Model-view-controller example
** Exercise
** Exercise
Line 129: Line 129:




* part 12 Building windows
* chapter 12 Building windows
** What you need to know about Motif
** What you need to know about Motif
** Widget resources
** Widget resources
Line 145: Line 145:




* part 13 Designing the UI: a brief tour
* chapter 13 Designing the UI: a brief tour
** User interfaces
** User interfaces
** Elementary examples
** Elementary examples
Line 157: Line 157:




* part 14 Polymorphism
* chapter 14 Polymorphism
** Dynamic binding
** Dynamic binding
** Dynamic binding enables ... polymorphism
** Dynamic binding enables ... polymorphism
Line 172: Line 172:




* part 15 Practicing polymorphism
* chapter 15 Practicing polymorphism
** Design exercise I: a shape editor
** Design exercise I: a shape editor
** Solution and discussion
** Solution and discussion
Line 181: Line 181:




* part 16 How object-oriented languages work
* chapter 16 How object-oriented languages work
** Virtual machines
** Virtual machines
** Method lookup
** Method lookup
Line 192: Line 192:




* part 17 Two kinds of inheritance
* chapter 17 Two kinds of inheritance
** Beauty and the beast
** Beauty and the beast
** Why types matter: polymorphism
** Why types matter: polymorphism
Line 206: Line 206:




* part 18 Design patterns
* chapter 18 Design patterns
** Notation
** Notation
** Smart container (aka collection-worker)
** Smart container (aka collection-worker)
Line 225: Line 225:




* part 19 Frameworks (one hearty example)
* chapter 19 Frameworks (one hearty example)
** Problems
** Problems
** Materialization
** Materialization
Line 236: Line 236:




* part 20 Metaclasses
* chapter 20 Metaclasses
** Facts about metaclasses
** Facts about metaclasses
** Inheritance
** Inheritance
Line 245: Line 245:




* part 21 Why developing software is still hard
* chapter 21 Why developing software is still hard
** Misconceptions 264
** Misconceptions 264
** Where projects go awry: borders
** Where projects go awry: borders

Latest revision as of 02:44, 7 August 2013

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