Pages without language links

From CSSEMediaWiki
Jump to: navigation, search
Prefix 

Showing below up to 250 results starting with #51.

View (previous 250 | next 250) (20 | 50 | 100 | 250 | 500)

  1. Avoid downcasting
  2. Avoid equals
  3. Avoid god classes
  4. Avoid inheritance for implementation
  5. Avoid inheritance for optional containment
  6. Avoid interface bloat
  7. Avoid interface pollution
  8. Avoid mixing inputs and outputs
  9. Avoid multiple inheritance
  10. Avoid no-op overrides
  11. Avoid protected data
  12. Avoid side effects
  13. Avoid verb classes
  14. Barbara Liskov
  15. BaseBean
  16. Becomes problem
  17. Behavioral completeness
  18. Benjamin's Design Study
  19. BenjaminTaylor Previous Design Work
  20. Bertrand's Design Study
  21. Bertrand Meyer
  22. Beware accessors
  23. Beware inheritance over composition
  24. Beware of many accessors
  25. Beware of non-communicating methods
  26. Beware singletons
  27. Beware type switches
  28. Beware value switches
  29. Big ball of mud
  30. Big design up front
  31. Blackboard System
  32. Boat anchor
  33. Bob Martin
  34. Bob Martin's heuristics
  35. Bob Martin's principles
  36. BrettWardsDesignStudy
  37. Bridge
  38. Builder
  39. CLU
  40. Call super
  41. Cay Horstmann 2006
  42. Chain of Responsibility
  43. Change Reference to Value
  44. Change Unidirectional Association to Bidirectional
  45. Change Value to Reference
  46. Christopher Alexander
  47. Christopher Alexander 1977
  48. Christopher Alexander 1979
  49. Circle-ellipse problem
  50. Circular dependency
  51. Citation needed
  52. Class Encapsulation
  53. Class diagram
  54. Class hierarchies should be deep and narrow
  55. Class versus Object
  56. Code smells
  57. Collapse Hierarchy
  58. Collecting Parameter
  59. Combining design patterns
  60. Command
  61. Command query separation
  62. Comments and suggestions
  63. Comments smell
  64. Common closure principle
  65. Common reuse principle
  66. Component versus Module
  67. Composite
  68. Constant interface
  69. Contain contents not parents
  70. Contained objects should not use each other
  71. Containment implies uses
  72. Copy Constructor vs the Encapsulation Boundary
  73. Coupling and cohesion
  74. Cut and paste programming
  75. DMA Design Project
  76. DMA Design Project - Source Code
  77. DMA Design Project - first submission
  78. DMA Design Project first draft
  79. Data class smell
  80. Data clumps smell
  81. Data mapper pattern
  82. David Parnas
  83. Decomposition
  84. Decorator
  85. Defer identification of state variables pattern
  86. Define classes by behavior, not state pattern
  87. Define default values via explicit protocol pattern
  88. Delegation
  89. Dependency injection
  90. Dependency inversion principle
  91. Design Project
  92. Design by contract
  93. Design examples
  94. Design maxims
  95. Design maxims Equivalence
  96. Design patterns
  97. Design patterns break rules
  98. Designfest
  99. Diamond Problem
  100. Different Design
  101. Distribute system intelligence
  102. Divergent change smell
  103. Do not change the state of an object without going through its public interface
  104. Do the simplest thing that could possibly work
  105. Documenting Patterns
  106. Domain model pattern
  107. Don't burn your base class
  108. Don't expose mutable attributes
  109. Don't repeat yourself
  110. Double Dispatch
  111. Duplicate Observed Data
  112. Duplicate code smell
  113. Editing Tips
  114. Eliminate case analysis
  115. Eliminate irrelevant classes
  116. Empty method over-rides
  117. Encapsulate Collection
  118. Encapsulate Downcast
  119. Encapsulate Field
  120. Encapsulate concrete state pattern
  121. Encapsulate that which varies
  122. Encapsulation
  123. Encapsulation boundary
  124. Encapsulation is hierarchical
  125. Enum idiom
  126. Equals vs the Encapsulation Boundary
  127. Erich Gamma
  128. Establishing priorities
  129. Exam Quick Reference
  130. Exam questions
  131. Extensibility
  132. Extract Class
  133. Extract Hierarchy
  134. Extract Interface
  135. Extract Method
  136. Extract Subclass
  137. Extract Superclass
  138. Extreme programming
  139. Facade
  140. Factor implementation differences into subcomponents
  141. Factory Method
  142. Fat interfaces
  143. Favor composition over inheritance
  144. Favour containment over association
  145. Favour deep hierarchies
  146. Feature envy smell
  147. Flyweight
  148. Frogs design
  149. Frogs second design
  150. Front controller pattern
  151. Functional decomposition
  152. Gang of Four
  153. Gang of Four 1995
  154. GenA: A Genetic Algorithms Framework
  155. GenericGuidelines
  156. Getter and setter policy
  157. Getters and setters
  158. God object
  159. Goto considered harmful
  160. Greg Searle's captains log star date
  161. Greg Searle's design
  162. Greg Searle's project blackjack
  163. Guitar Amplifier Design
  164. Guitar Tutor Design
  165. Guitar Tutor Report
  166. Hall of fame
  167. Have courage
  168. Hide Delegate
  169. Hide Method
  170. Hide data within its class
  171. Hide your decisions
  172. Hierarchical Model View Controller
  173. Hillside Group
  174. HistoryCrumbs.user.js
  175. How to assess
  176. Identify message layers pattern
  177. Identity map pattern
  178. Idioms
  179. If it ain't broke don't fix it
  180. Immutable object
  181. Impedance mismatch
  182. Implement behavior with abstract state pattern
  183. Inappropriate intimacy smell
  184. Incomplete library class smell
  185. Information hiding
  186. Inheritance
  187. Inheritance for specialization
  188. Inline Class
  189. Inline Method
  190. Inline Temp
  191. Instance
  192. Intelligent children pattern
  193. Interface
  194. Interface segregation principle
  195. Interface should be dependent on model
  196. Interpreter
  197. Introduce Explaining Variable
  198. Introduce Foreign Method
  199. Introduce Local Extension
  200. Introduce Null Object
  201. Introduce Parameter Object
  202. Introduce common base class
  203. Introduce common data class
  204. Introduction to the Terrain Renderer
  205. Inventory and Accounting
  206. Inversion of control
  207. Iterator
  208. JITAS Design Study
  209. JUnit
  210. James Ashford Design Study
  211. James Ashford Log
  212. Janina's Design Study
  213. Jason's Useful Links Page
  214. Java Collections Framework
  215. Jenny Harlow
  216. Jim Coplien
  217. Joey's design study
  218. Joff's Place
  219. John Hofman's Design Study
  220. John Hofman's Log
  221. John Hofman US001
  222. Johnson and Foote's heuristics
  223. Johnson and Foote 1988
  224. Jojo's 2008 Design Study
  225. Jojo's OO Design Project Log
  226. Joshua Bloch
  227. Joshua Bloch 2006 Bumper Sticker API Design
  228. Jumble
  229. Keep accessors and mutators separate
  230. Keep last years stuff
  231. Keep related data and behavior in one place
  232. Ken Auer
  233. Ken Auer 1995
  234. Kent Beck
  235. Kent Beck 2003
  236. Kris's Design Study
  237. Language Spectrum
  238. Large class smell
  239. Law of Demeter
  240. Law of leaky abstractions
  241. Lazy class smell
  242. Lazy load pattern
  243. Lecture sequence
  244. Lecture times
  245. Limit compositions in a class
  246. Limit hierarchy depth
  247. Liskov substitution principle
  248. List of OO Languages
  249. Long method smell
  250. Long parameter list smell

View (previous 250 | next 250) (20 | 50 | 100 | 250 | 500)

Views
Toolbox