Pages with the fewest revisions

From CSSEMediaWiki
Jump to: navigation, search

Showing below up to 250 results starting with #1.

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

  1. Toast‏‎ (2 revisions)
  2. Limit hierarchy depth‏‎ (2 revisions)
  3. Avoid mixing inputs and outputs‏‎ (2 revisions)
  4. No concrete base classes‏‎ (2 revisions - redirect page)
  5. Avoid accidental multiple inheritance‏‎ (2 revisions)
  6. Rebecca Wirfs-Brock 1990‏‎ (2 revisions)
  7. Reusable frameworks over reusable components‏‎ (2 revisions)
  8. Unit Test‏‎ (2 revisions)
  9. PLoP (Software Patterns Series)‏‎ (2 revisions)
  10. Blackboard System‏‎ (2 revisions)
  11. Containment implies uses‏‎ (2 revisions)
  12. Front controller pattern‏‎ (2 revisions)
  13. HistoryCrumbs.user.js‏‎ (2 revisions)
  14. PLoP 1995‏‎ (2 revisions)
  15. Guitar Tutor Report‏‎ (2 revisions)
  16. Accountability Design‏‎ (2 revisions)
  17. Jojo's 2008 Design Study‏‎ (2 revisions)
  18. Table data gateway pattern‏‎ (2 revisions)
  19. Ken Auer‏‎ (2 revisions)
  20. Extract Interface‏‎ (2 revisions)
  21. Gang Of Four 1995‏‎ (2 revisions - redirect page)
  22. Favour composition over inheritance‏‎ (2 revisions - redirect page)
  23. Have courage‏‎ (2 revisions)
  24. Nelson Shaw Project Log‏‎ (2 revisions)
  25. Open/closed principle‏‎ (2 revisions - redirect page)
  26. MVC‏‎ (2 revisions - redirect page)
  27. Beware of non-communicating methods‏‎ (2 revisions)
  28. Lazy load pattern‏‎ (2 revisions)
  29. Component versus Module‏‎ (2 revisions)
  30. Favour deep hierarchies‏‎ (2 revisions)
  31. Robert Cecil Martin 1996d‏‎ (2 revisions)
  32. Kris's Design Study‏‎ (2 revisions)
  33. Encapsulate Downcast‏‎ (2 revisions)
  34. Shallow VS Deep Copy‏‎ (2 revisions)
  35. Make all Member Variables Private‏‎ (2 revisions)
  36. Move methods‏‎ (2 revisions)
  37. GenA: A Genetic Algorithms Framework‏‎ (2 revisions)
  38. Why refactoring works‏‎ (2 revisions)
  39. Pull Up Constructor Body‏‎ (2 revisions)
  40. AudioSystems‏‎ (2 revisions)
  41. John Hofman's Log‏‎ (2 revisions)
  42. Avoid interface pollution‏‎ (2 revisions)
  43. DMA Design Project - Source Code‏‎ (2 revisions)
  44. James Ashford Log‏‎ (2 revisions)
  45. Pull Up Field‏‎ (3 revisions)
  46. Stephen's Design Study‏‎ (3 revisions)
  47. Big ball of mud‏‎ (3 revisions)
  48. Primitive obsession smell‏‎ (3 revisions)
  49. BenjaminTaylor Previous Design Work‏‎ (3 revisions)
  50. Pull Up Method‏‎ (3 revisions)
  51. Contained objects should not use each other‏‎ (3 revisions)
  52. Call super‏‎ (3 revisions)
  53. Remove Middle Man‏‎ (3 revisions)
  54. Robert Cecil Martin 2003‏‎ (3 revisions)
  55. Extract Class‏‎ (3 revisions)
  56. Push Down Field‏‎ (3 revisions)
  57. Interface‏‎ (3 revisions)
  58. Model the room‏‎ (3 revisions)
  59. Introduction to the Terrain Renderer‏‎ (3 revisions)
  60. Cay Horstmann 2006‏‎ (3 revisions)
  61. Remove Parameter‏‎ (3 revisions)
  62. Domain model pattern‏‎ (3 revisions)
  63. Split large classes‏‎ (3 revisions)
  64. Push Down Method‏‎ (3 revisions)
  65. Remove Setting Method‏‎ (3 revisions)
  66. Named constants‏‎ (3 revisions)
  67. Temporary field smell‏‎ (3 revisions)
  68. Law of leaky abstractions‏‎ (3 revisions)
  69. Class diagram‏‎ (3 revisions)
  70. Active record pattern‏‎ (3 revisions)
  71. Table module pattern‏‎ (3 revisions)
  72. Change Reference to Value‏‎ (3 revisions)
  73. Row data gateway pattern‏‎ (3 revisions)
  74. Lazy class smell‏‎ (3 revisions)
  75. Replace Parameter Object‏‎ (3 revisions - redirect page)
  76. Move Field‏‎ (3 revisions)
  77. Designfest‏‎ (3 revisions)
  78. Change Unidirectional Association to Bidirectional‏‎ (3 revisions)
  79. Data mapper pattern‏‎ (3 revisions)
  80. Extract Subclass‏‎ (3 revisions)
  81. Inheritance for specialization‏‎ (3 revisions)
  82. Joshua Bloch‏‎ (3 revisions)
  83. Diamond Problem‏‎ (3 revisions)
  84. Barbara Liskov‏‎ (3 revisions)
  85. Kent Beck 2003‏‎ (3 revisions)
  86. Extract Superclass‏‎ (3 revisions)
  87. Inline Class‏‎ (3 revisions)
  88. Arthur Riel‏‎ (3 revisions)
  89. Replace Parameter with Method‏‎ (3 revisions)
  90. Introduce Foreign Method‏‎ (3 revisions)
  91. Software crisis‏‎ (3 revisions)
  92. Alumni‏‎ (3 revisions)
  93. Scrum‏‎ (3 revisions)
  94. Hide Method‏‎ (3 revisions)
  95. Introduce Local Extension‏‎ (3 revisions)
  96. Robert Cecil Martin 1996e‏‎ (3 revisions)
  97. Becomes problem‏‎ (3 revisions)
  98. Collapse Hierarchy‏‎ (3 revisions)
  99. Ralph Johnson‏‎ (3 revisions)
  100. Parameterise Method‏‎ (3 revisions)
  101. Referring to Objects‏‎ (3 revisions)
  102. Replace Data Value with Object‏‎ (3 revisions)
  103. Duplicate Observed Data‏‎ (3 revisions)
  104. Greg Searle's design‏‎ (3 revisions)
  105. Introduce Parameter Object‏‎ (3 revisions)
  106. Do not change the state of an object without going through its public interface‏‎ (3 revisions)
  107. Spaghetti code‏‎ (3 revisions)
  108. Language Spectrum‏‎ (3 revisions)
  109. Circle-ellipse problem‏‎ (3 revisions)
  110. No Peter Pan objects‏‎ (4 revisions)
  111. Greg Searle's project blackjack‏‎ (4 revisions)
  112. Access levels‏‎ (4 revisions)
  113. Wiki tips‏‎ (4 revisions)
  114. Hierarchical Model View Controller‏‎ (4 revisions)
  115. Agile manifesto‏‎ (4 revisions)
  116. Unified Modeling Language‏‎ (4 revisions)
  117. Introduce common base class‏‎ (4 revisions)
  118. Extensibility‏‎ (4 revisions)
  119. Introduce common data class‏‎ (4 revisions)
  120. Documenting Patterns‏‎ (4 revisions)
  121. No silver bullet‏‎ (4 revisions)
  122. Avoid becomes‏‎ (4 revisions)
  123. Program to the interface not the implementation‏‎ (4 revisions)
  124. Yo-yo problem‏‎ (4 revisions)
  125. Poltergeists‏‎ (4 revisions)
  126. Comments smell‏‎ (4 revisions)
  127. Mike's Design Study‏‎ (4 revisions)
  128. Sequential coupling‏‎ (4 revisions)
  129. Remove assignments to Parameters‏‎ (4 revisions)
  130. Ward and Kent‏‎ (4 revisions)
  131. Jim Coplien‏‎ (4 revisions)
  132. Minimal public interface‏‎ (4 revisions)
  133. Transaction script pattern‏‎ (4 revisions)
  134. Bob Martin's heuristics‏‎ (4 revisions)
  135. Robert Cecil Martin 1996b‏‎ (4 revisions)
  136. Rename Method‏‎ (4 revisions)
  137. Minimize accesses to variables‏‎ (4 revisions)
  138. Replace Parameter with Explicit Methods‏‎ (4 revisions)
  139. Introduce Explaining Variable‏‎ (4 revisions)
  140. Robert Cecil Martin 1996c‏‎ (4 revisions)
  141. Change Value to Reference‏‎ (4 revisions)
  142. Message chain smell‏‎ (4 revisions)
  143. Service layer pattern‏‎ (4 revisions)
  144. Joshua Bloch 2006 Bumper Sticker API Design‏‎ (4 revisions)
  145. Move common factors up the hierarchy‏‎ (4 revisions)
  146. Erich Gamma‏‎ (4 revisions)
  147. Teaching and learning style‏‎ (4 revisions)
  148. Replace Conditional with Polymorphism‏‎ (4 revisions)
  149. Option-operand separation‏‎ (4 revisions)
  150. RL Design Study Log‏‎ (4 revisions)
  151. Replace Temp with Query‏‎ (4 revisions)
  152. Substitute Algorithm‏‎ (4 revisions)
  153. Advice from alumni‏‎ (4 revisions)
  154. Avoid inheritance for optional containment‏‎ (4 revisions)
  155. Refactoring and performance‏‎ (4 revisions)
  156. Distribute system intelligence‏‎ (4 revisions)
  157. 2010 frog design criticisms‏‎ (4 revisions)
  158. Immutable object‏‎ (4 revisions)
  159. Replace Constructor with Factory Method‏‎ (4 revisions)
  160. Encapsulate Field‏‎ (4 revisions)
  161. Shalloway and Trott 2002‏‎ (4 revisions)
  162. Robert Cecil Martin 1997a‏‎ (4 revisions)
  163. Exam Quick Reference‏‎ (4 revisions)
  164. Behavioral completeness‏‎ (4 revisions)
  165. No Global Variables‏‎ (4 revisions)
  166. Wiki etiquette‏‎ (4 revisions)
  167. Constant interface‏‎ (4 revisions)
  168. Robert Cecil Martin 1997b‏‎ (4 revisions)
  169. Replace Error Code with Exception‏‎ (5 revisions)
  170. Separate Query from Modifier‏‎ (5 revisions)
  171. Factor implementation differences into subcomponents‏‎ (5 revisions)
  172. Model classes not roles‏‎ (5 revisions)
  173. Management antipatterns‏‎ (5 revisions)
  174. Robert Cecil Martin 2002‏‎ (5 revisions)
  175. A Genetic Algorithms Framework‏‎ (5 revisions - redirect page)
  176. Inappropriate intimacy smell‏‎ (5 revisions)
  177. Circular dependency‏‎ (5 revisions)
  178. Incomplete library class smell‏‎ (5 revisions)
  179. Citation needed‏‎ (5 revisions)
  180. EXtreme programming‏‎ (5 revisions - redirect page)
  181. Separate non-communicating behaviour‏‎ (5 revisions)
  182. Object Encapsulation‏‎ (5 revisions)
  183. Class Encapsulation‏‎ (5 revisions)
  184. Middle man smell‏‎ (5 revisions)
  185. Delegation‏‎ (5 revisions)
  186. Encapsulation is hierarchical‏‎ (5 revisions)
  187. Replace Method with Method Object‏‎ (5 revisions)
  188. Eliminate case analysis‏‎ (5 revisions)
  189. Strategy meets Template‏‎ (5 revisions)
  190. Coupling‏‎ (5 revisions - redirect page)
  191. Reduce the number of arguments‏‎ (5 revisions)
  192. Beware inheritance over composition‏‎ (5 revisions)
  193. Avoid equals‏‎ (5 revisions)
  194. Avoid verb classes‏‎ (5 revisions)
  195. Don't repeat yourself‏‎ (5 revisions)
  196. Bob Martin's principles‏‎ (5 revisions)
  197. 2009 frog design criticisms‏‎ (5 revisions)
  198. Abstract classes should be base classes‏‎ (5 revisions)
  199. Inline Method‏‎ (5 revisions)
  200. What is Bad Design‏‎ (5 revisions)
  201. Parallel inheritance hierarchies smell‏‎ (5 revisions)
  202. Extreme programming‏‎ (5 revisions)
  203. Greg Searle's captains log star date‏‎ (5 revisions)
  204. Inline Temp‏‎ (5 revisions)
  205. PluS XML format‏‎ (5 revisions)
  206. Divergent change smell‏‎ (5 revisions)
  207. Send messages to components instead of to self‏‎ (5 revisions)
  208. Limit compositions in a class‏‎ (5 revisions)
  209. Uncle Bob‏‎ (5 revisions - redirect page)
  210. Wal's Fish Tank‏‎ (5 revisions)
  211. Overloading‏‎ (6 revisions)
  212. John Hofman US001‏‎ (6 revisions)
  213. Contain contents not parents‏‎ (6 revisions)
  214. Party of Five 1996‏‎ (6 revisions)
  215. Speculative generality smell‏‎ (6 revisions)
  216. Separate methods that do not communicate‏‎ (6 revisions)
  217. Big design up front‏‎ (6 revisions)
  218. Party of five 1996‏‎ (6 revisions)
  219. Split Temporary Variable‏‎ (6 revisions)
  220. Replace Inheritance with Delegation‏‎ (6 revisions)
  221. List of OO Languages‏‎ (6 revisions)
  222. Avoid no-op overrides‏‎ (6 revisions)
  223. Extract Hierarchy‏‎ (6 revisions)
  224. Many to many association idiom‏‎ (6 revisions)
  225. Object cesspool‏‎ (6 revisions)
  226. Robert Pirsig 1974‏‎ (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. Object orgy‏‎ (6 revisions)
  232. Inversion of control‏‎ (6 revisions)
  233. Don't expose mutable attributes‏‎ (6 revisions)
  234. Class hierarchies should be deep and narrow‏‎ (6 revisions)
  235. Strategy pattern‏‎ (6 revisions - redirect page)
  236. Reduce the size of methods‏‎ (6 revisions)
  237. Enum idiom‏‎ (6 revisions)
  238. Wards wiki‏‎ (6 revisions - redirect page)
  239. Subclass‏‎ (6 revisions)
  240. Alternative classes with different interfaces smell‏‎ (6 revisions)
  241. Properties / Fields / Attributes‏‎ (6 revisions)
  242. Encapsulate Collection‏‎ (6 revisions)
  243. Hide Delegate‏‎ (6 revisions)
  244. If it ain't broke don't fix it‏‎ (6 revisions)
  245. BaseBean‏‎ (6 revisions)
  246. Text design‏‎ (6 revisions)
  247. Beware singletons‏‎ (6 revisions)
  248. Organisational patterns‏‎ (6 revisions)
  249. The Alexander conspiracy‏‎ (6 revisions)
  250. Christopher Alexander 1979‏‎ (6 revisions)

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

Views
Personal tools
Toolbox