Pages with the most revisions

From CSSEMediaWiki
Jump to: navigation, search

Showing below up to 250 results starting with #51.

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

  1. OO tools‏‎ (26 revisions)
  2. Object-oriented design anti-patterns‏‎ (25 revisions)
  3. Jenny Harlow‏‎ (24 revisions)
  4. LukasKorsikaDesignStudy‏‎ (24 revisions)
  5. Joff's Place‏‎ (24 revisions)
  6. Refactoring‏‎ (24 revisions)
  7. Prototype‏‎ (24 revisions)
  8. OO gurus‏‎ (24 revisions)
  9. Encapsulation boundary‏‎ (23 revisions)
  10. Getters and setters‏‎ (22 revisions)
  11. Strategy‏‎ (22 revisions)
  12. Nomenclature‏‎ (21 revisions)
  13. Tanmay's Log‏‎ (21 revisions)
  14. Decorator‏‎ (21 revisions)
  15. Flyweight‏‎ (21 revisions)
  16. 427 assessment‏‎ (21 revisions)
  17. Terrain Renderer Design‏‎ (19 revisions)
  18. Coupling and cohesion‏‎ (19 revisions)
  19. Composite‏‎ (19 revisions)
  20. Lecture times‏‎ (19 revisions)
  21. Poker Simulator Design Log‏‎ (18 revisions)
  22. Duplicate code smell‏‎ (18 revisions)
  23. Multiple Inheritance‏‎ (18 revisions)
  24. Michal's Design Study‏‎ (18 revisions)
  25. Abstract Factory‏‎ (18 revisions)
  26. Schools of thought‏‎ (18 revisions)
  27. Mujtaba's design study‏‎ (17 revisions)
  28. 2005 Exam answers‏‎ (17 revisions)
  29. Iterator‏‎ (17 revisions)
  30. Memento‏‎ (17 revisions)
  31. Adapter‏‎ (17 revisions)
  32. BrettWardsDesignStudy‏‎ (17 revisions)
  33. Bridge‏‎ (17 revisions)
  34. 427 design standard‏‎ (17 revisions)
  35. Defer identification of state variables pattern‏‎ (16 revisions)
  36. Similar patterns and how to tell them apart‏‎ (16 revisions)
  37. Antipatterns‏‎ (16 revisions)
  38. Hall of fame‏‎ (16 revisions)
  39. Ken Auer 1995‏‎ (16 revisions)
  40. Singleton‏‎ (16 revisions)
  41. Open closed principle‏‎ (16 revisions)
  42. Super quick exam ref‏‎ (16 revisions)
  43. Parse tree design‏‎ (16 revisions)
  44. Johnson and Foote 1988‏‎ (15 revisions)
  45. 2006 Exam answers‏‎ (15 revisions)
  46. Interpreter‏‎ (15 revisions)
  47. Equals vs the Encapsulation Boundary‏‎ (15 revisions)
  48. Nick Brettel's eight puzzle design‏‎ (15 revisions)
  49. Facade‏‎ (15 revisions)
  50. Command‏‎ (14 revisions)
  51. Poker Simulator Design Writeup‏‎ (14 revisions)
  52. Frogs second design‏‎ (14 revisions)
  53. Avoid multiple inheritance‏‎ (14 revisions)
  54. Command query separation‏‎ (14 revisions)
  55. Maxim Hierarchy‏‎ (14 revisions)
  56. Comments and suggestions‏‎ (14 revisions)
  57. About COSC427‏‎ (14 revisions)
  58. Ward Cunningham‏‎ (14 revisions)
  59. OO Python Character Animation Design Study‏‎ (14 revisions)
  60. Arthur Riel 1996‏‎ (14 revisions)
  61. Design by contract‏‎ (14 revisions)
  62. Premature optimization‏‎ (14 revisions)
  63. State‏‎ (14 revisions)
  64. Introduce Null Object‏‎ (14 revisions)
  65. Tell, don't ask‏‎ (14 revisions)
  66. Combining design patterns‏‎ (13 revisions)
  67. Getter and setter policy‏‎ (13 revisions)
  68. Law of Demeter‏‎ (13 revisions)
  69. Avoid concrete base classes‏‎ (13 revisions)
  70. Trains design‏‎ (13 revisions)
  71. Dependency inversion principle‏‎ (13 revisions)
  72. Class versus Object‏‎ (13 revisions)
  73. Video rental system‏‎ (13 revisions)
  74. Abstract vs Interface‏‎ (13 revisions)
  75. Beware type switches‏‎ (13 revisions)
  76. Analysis patterns‏‎ (13 revisions)
  77. Template Method‏‎ (12 revisions)
  78. Patterns‏‎ (12 revisions)
  79. Keep related data and behavior in one place‏‎ (12 revisions)
  80. Interface segregation principle‏‎ (12 revisions)
  81. Mediator‏‎ (12 revisions)
  82. Data class smell‏‎ (12 revisions)
  83. Single responsibility principle‏‎ (12 revisions)
  84. Bob Martin‏‎ (12 revisions)
  85. Data clumps smell‏‎ (12 revisions)
  86. Acyclic dependencies principle‏‎ (12 revisions)
  87. Empty method over-rides‏‎ (12 revisions)
  88. Test Driven Development‏‎ (12 revisions)
  89. Quotes‏‎ (12 revisions)
  90. JUnit‏‎ (12 revisions)
  91. Proxy‏‎ (12 revisions)
  92. Aggregation versus Composition‏‎ (12 revisions)
  93. Resource materials‏‎ (11 revisions - redirect page)
  94. Keep last years stuff‏‎ (11 revisions)
  95. Design patterns break rules‏‎ (11 revisions)
  96. Chain of Responsibility‏‎ (11 revisions)
  97. Ward's wiki‏‎ (11 revisions)
  98. Avoid downcasting‏‎ (11 revisions)
  99. Monsters design‏‎ (11 revisions)
  100. Common closure principle‏‎ (11 revisions)
  101. Stable abstractions principle‏‎ (11 revisions)
  102. Gang of Four 1995‏‎ (11 revisions)
  103. Stable dependencies principle‏‎ (11 revisions)
  104. OO culture‏‎ (11 revisions)
  105. Christopher Alexander 1977‏‎ (11 revisions)
  106. Martin Fowler 1999‏‎ (11 revisions)
  107. Encapsulate concrete state pattern‏‎ (11 revisions)
  108. Mujtaba's Log‏‎ (11 revisions)
  109. Automation‏‎ (10 revisions)
  110. Andrew Hunt 1999‏‎ (10 revisions)
  111. Liskov substitution principle‏‎ (10 revisions)
  112. Michael's Log‏‎ (10 revisions)
  113. Bertrand's Design Study‏‎ (10 revisions)
  114. How to assess‏‎ (10 revisions)
  115. Alan Kay‏‎ (10 revisions)
  116. Inventory and Accounting‏‎ (10 revisions)
  117. Avoid protected data‏‎ (10 revisions)
  118. Separation of concerns‏‎ (10 revisions)
  119. Dependency injection‏‎ (10 revisions)
  120. Extract Method‏‎ (10 revisions)
  121. Jojo's OO Design Project Log‏‎ (10 revisions)
  122. Kent Beck‏‎ (10 revisions)
  123. Object pool‏‎ (10 revisions)
  124. Common reuse principle‏‎ (10 revisions)
  125. Double Dispatch‏‎ (10 revisions)
  126. Builder‏‎ (10 revisions)
  127. GenericGuidelines‏‎ (10 revisions)
  128. Martin Fowler 2003‏‎ (10 revisions)
  129. Encapsulate that which varies‏‎ (9 revisions)
  130. Large class smell‏‎ (9 revisions)
  131. DMA Design Project - first submission‏‎ (9 revisions)
  132. One Into Many‏‎ (9 revisions)
  133. Account setup‏‎ (9 revisions)
  134. Intelligent children pattern‏‎ (9 revisions)
  135. Encapsulation‏‎ (9 revisions)
  136. Jason's Useful Links Page‏‎ (9 revisions)
  137. Accountability‏‎ (9 revisions)
  138. Switch statement smell‏‎ (9 revisions)
  139. A froggy visitor‏‎ (9 revisions)
  140. Information hiding‏‎ (9 revisions)
  141. Anti patterns‏‎ (9 revisions - redirect page)
  142. One key abstraction‏‎ (9 revisions)
  143. Fat interfaces‏‎ (9 revisions)
  144. Use lazy initialization pattern‏‎ (9 revisions)
  145. Identify message layers pattern‏‎ (9 revisions)
  146. Architectural patterns‏‎ (9 revisions)
  147. Eliminate irrelevant classes‏‎ (9 revisions)
  148. AlexsLibrary‏‎ (9 revisions)
  149. Minimize number of methods‏‎ (9 revisions)
  150. Start here‏‎ (9 revisions)
  151. Christopher Alexander‏‎ (9 revisions)
  152. Martin Fowler 1997‏‎ (9 revisions)
  153. Perfect OO Language‏‎ (9 revisions)
  154. Software reuse‏‎ (9 revisions)
  155. Avoid interface bloat‏‎ (9 revisions)
  156. DMA Design Project‏‎ (9 revisions)
  157. Sorcerers design‏‎ (9 revisions)
  158. Do the simplest thing that could possibly work‏‎ (8 revisions)
  159. Johnson and Foote's heuristics‏‎ (8 revisions)
  160. Define classes by behavior, not state pattern‏‎ (8 revisions)
  161. A class should not depend on its users‏‎ (8 revisions)
  162. Anemic Domain Model‏‎ (8 revisions)
  163. Define default values via explicit protocol pattern‏‎ (8 revisions)
  164. Reuse release equivalence principle‏‎ (8 revisions)
  165. Editing Tips‏‎ (8 revisions)
  166. Recursion introduction‏‎ (8 revisions)
  167. Goto considered harmful‏‎ (8 revisions)
  168. Polymorphism‏‎ (8 revisions)
  169. Are you gonna eat that‏‎ (8 revisions)
  170. Favour containment over association‏‎ (8 revisions)
  171. Avoid god classes‏‎ (8 revisions)
  172. Idioms‏‎ (8 revisions)
  173. Observations and Measurements‏‎ (8 revisions)
  174. Abstract class‏‎ (8 revisions)
  175. Parallel hierarchies problem‏‎ (8 revisions)
  176. Martin Fowler‏‎ (8 revisions)
  177. Trygve Reenskaug‏‎ (8 revisions)
  178. Decomposition‏‎ (8 revisions)
  179. Amelioration patterns‏‎ (8 revisions)
  180. Association versus Dependency‏‎ (8 revisions)
  181. Nil or export coupling only‏‎ (8 revisions)
  182. Impedance mismatch‏‎ (8 revisions)
  183. Implement behavior with abstract state pattern‏‎ (8 revisions)
  184. Exam questions‏‎ (8 revisions)
  185. Superclass‏‎ (7 revisions)
  186. Model the real world‏‎ (7 revisions)
  187. Professionalism‏‎ (7 revisions)
  188. William Brown 1998‏‎ (7 revisions)
  189. Single choice principle‏‎ (7 revisions)
  190. God object‏‎ (7 revisions)
  191. Tour Guide Project Page‏‎ (7 revisions)
  192. Don't burn your base class‏‎ (7 revisions)
  193. Favor composition over inheritance‏‎ (7 revisions)
  194. Reduce implicit parameter passing‏‎ (7 revisions)
  195. Avoid side effects‏‎ (7 revisions)
  196. You ain't gonna need it‏‎ (7 revisions)
  197. Robert Cecil Martin 1996a‏‎ (7 revisions)
  198. Gang of Four‏‎ (7 revisions)
  199. Beware of many accessors‏‎ (7 revisions)
  200. Smalltalk‏‎ (7 revisions)
  201. Avoid inheritance for implementation‏‎ (7 revisions)
  202. Subclasses should be specializations‏‎ (7 revisions)
  203. Method‏‎ (7 revisions)
  204. Feature envy smell‏‎ (7 revisions)
  205. Hide data within its class‏‎ (7 revisions)
  206. Replace Type Code with Class‏‎ (7 revisions)
  207. Abstraction‏‎ (7 revisions)
  208. Presentation separation idiom‏‎ (7 revisions)
  209. Overloading‏‎ (6 revisions)
  210. Shotgun surgery smell‏‎ (6 revisions)
  211. John Hofman US001‏‎ (6 revisions)
  212. Refused bequest smell‏‎ (6 revisions)
  213. Party of Five 1996‏‎ (6 revisions)
  214. Contain contents not parents‏‎ (6 revisions)
  215. Preserve Whole Object‏‎ (6 revisions)
  216. Big design up front‏‎ (6 revisions)
  217. Party of five 1996‏‎ (6 revisions)
  218. Speculative generality smell‏‎ (6 revisions)
  219. Separate methods that do not communicate‏‎ (6 revisions)
  220. List of OO Languages‏‎ (6 revisions)
  221. Split Temporary Variable‏‎ (6 revisions)
  222. Avoid no-op overrides‏‎ (6 revisions)
  223. Extract Hierarchy‏‎ (6 revisions)
  224. Replace Inheritance with Delegation‏‎ (6 revisions)
  225. Many to many association idiom‏‎ (6 revisions)
  226. Object cesspool‏‎ (6 revisions)
  227. Inheritance‏‎ (6 revisions)
  228. Package versus Namespace‏‎ (6 revisions)
  229. Interface should be dependent on model‏‎ (6 revisions)
  230. Long parameter list smell‏‎ (6 revisions)
  231. Robert Pirsig 1974‏‎ (6 revisions)
  232. Inversion of control‏‎ (6 revisions)
  233. Object orgy‏‎ (6 revisions)
  234. Class hierarchies should be deep and narrow‏‎ (6 revisions)
  235. Don't expose mutable attributes‏‎ (6 revisions)
  236. Enum idiom‏‎ (6 revisions)
  237. Strategy pattern‏‎ (6 revisions - redirect page)
  238. Reduce the size of methods‏‎ (6 revisions)
  239. Alternative classes with different interfaces smell‏‎ (6 revisions)
  240. Wards wiki‏‎ (6 revisions - redirect page)
  241. Subclass‏‎ (6 revisions)
  242. Hide Delegate‏‎ (6 revisions)
  243. Encapsulate Collection‏‎ (6 revisions)
  244. If it ain't broke don't fix it‏‎ (6 revisions)
  245. BaseBean‏‎ (6 revisions)
  246. Properties / Fields / Attributes‏‎ (6 revisions)
  247. Beware singletons‏‎ (6 revisions)
  248. Text design‏‎ (6 revisions)
  249. Organisational patterns‏‎ (6 revisions)
  250. The Alexander conspiracy‏‎ (6 revisions)

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

Views
Toolbox