Pages with the fewest revisions

From CSSEMediaWiki
Jump to: navigation, search

Showing below up to 250 results starting with #251.

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

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

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

Views
Toolbox