Pages with the fewest 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. Duplicate Observed Data‏‎ (3 revisions)
  2. Robert Cecil Martin 2003‏‎ (3 revisions)
  3. Introduce Parameter Object‏‎ (3 revisions)
  4. Push Down Field‏‎ (3 revisions)
  5. Language Spectrum‏‎ (3 revisions)
  6. Circle-ellipse problem‏‎ (3 revisions)
  7. Do not change the state of an object without going through its public interface‏‎ (3 revisions)
  8. Big ball of mud‏‎ (3 revisions)
  9. Remove Parameter‏‎ (3 revisions)
  10. Split large classes‏‎ (3 revisions)
  11. Push Down Method‏‎ (3 revisions)
  12. BenjaminTaylor Previous Design Work‏‎ (3 revisions)
  13. Temporary field smell‏‎ (3 revisions)
  14. Remove Setting Method‏‎ (3 revisions)
  15. Call super‏‎ (3 revisions)
  16. Contained objects should not use each other‏‎ (3 revisions)
  17. Table module pattern‏‎ (3 revisions)
  18. Extract Class‏‎ (3 revisions)
  19. Interface‏‎ (3 revisions)
  20. Row data gateway pattern‏‎ (3 revisions)
  21. Introduction to the Terrain Renderer‏‎ (3 revisions)
  22. Cay Horstmann 2006‏‎ (3 revisions)
  23. Model the room‏‎ (3 revisions)
  24. Replace Parameter Object‏‎ (3 revisions - redirect page)
  25. Domain model pattern‏‎ (3 revisions)
  26. Law of leaky abstractions‏‎ (3 revisions)
  27. Class diagram‏‎ (3 revisions)
  28. Named constants‏‎ (3 revisions)
  29. Active record pattern‏‎ (3 revisions)
  30. Change Reference to Value‏‎ (3 revisions)
  31. Replace Parameter with Method‏‎ (3 revisions)
  32. Lazy class smell‏‎ (3 revisions)
  33. Software crisis‏‎ (3 revisions)
  34. Scrum‏‎ (3 revisions)
  35. Change Unidirectional Association to Bidirectional‏‎ (3 revisions)
  36. Move Field‏‎ (3 revisions)
  37. Designfest‏‎ (3 revisions)
  38. Inheritance for specialization‏‎ (3 revisions)
  39. Data mapper pattern‏‎ (3 revisions)
  40. Robert Cecil Martin 1996e‏‎ (3 revisions)
  41. Extract Subclass‏‎ (3 revisions)
  42. Joshua Bloch‏‎ (3 revisions)
  43. Barbara Liskov‏‎ (3 revisions)
  44. Kent Beck 2003‏‎ (3 revisions)
  45. Ralph Johnson‏‎ (3 revisions)
  46. Diamond Problem‏‎ (3 revisions)
  47. Inline Class‏‎ (3 revisions)
  48. Arthur Riel‏‎ (3 revisions)
  49. Referring to Objects‏‎ (3 revisions)
  50. Extract Superclass‏‎ (3 revisions)
  51. Introduce Foreign Method‏‎ (3 revisions)
  52. Replace Data Value with Object‏‎ (3 revisions)
  53. Alumni‏‎ (3 revisions)
  54. Spaghetti code‏‎ (3 revisions)
  55. Hide Method‏‎ (3 revisions)
  56. Introduce Local Extension‏‎ (3 revisions)
  57. Pull Up Field‏‎ (3 revisions)
  58. Stephen's Design Study‏‎ (3 revisions)
  59. Becomes problem‏‎ (3 revisions)
  60. Encapsulate Field‏‎ (4 revisions)
  61. Behavioral completeness‏‎ (4 revisions)
  62. Exam Quick Reference‏‎ (4 revisions)
  63. No Global Variables‏‎ (4 revisions)
  64. Constant interface‏‎ (4 revisions)
  65. Greg Searle's project blackjack‏‎ (4 revisions)
  66. Access levels‏‎ (4 revisions)
  67. Program to the interface not the implementation‏‎ (4 revisions)
  68. No Peter Pan objects‏‎ (4 revisions)
  69. Hierarchical Model View Controller‏‎ (4 revisions)
  70. Agile manifesto‏‎ (4 revisions)
  71. Introduce common base class‏‎ (4 revisions)
  72. Yo-yo problem‏‎ (4 revisions)
  73. Poltergeists‏‎ (4 revisions)
  74. Extensibility‏‎ (4 revisions)
  75. Introduce common data class‏‎ (4 revisions)
  76. Sequential coupling‏‎ (4 revisions)
  77. Documenting Patterns‏‎ (4 revisions)
  78. Avoid becomes‏‎ (4 revisions)
  79. Ward and Kent‏‎ (4 revisions)
  80. Remove assignments to Parameters‏‎ (4 revisions)
  81. No silver bullet‏‎ (4 revisions)
  82. Transaction script pattern‏‎ (4 revisions)
  83. Robert Cecil Martin 1996b‏‎ (4 revisions)
  84. Rename Method‏‎ (4 revisions)
  85. Replace Parameter with Explicit Methods‏‎ (4 revisions)
  86. Robert Cecil Martin 1996c‏‎ (4 revisions)
  87. Comments smell‏‎ (4 revisions)
  88. Mike's Design Study‏‎ (4 revisions)
  89. Service layer pattern‏‎ (4 revisions)
  90. Teaching and learning style‏‎ (4 revisions)
  91. Jim Coplien‏‎ (4 revisions)
  92. Bob Martin's heuristics‏‎ (4 revisions)
  93. Minimal public interface‏‎ (4 revisions)
  94. Replace Conditional with Polymorphism‏‎ (4 revisions)
  95. Substitute Algorithm‏‎ (4 revisions)
  96. RL Design Study Log‏‎ (4 revisions)
  97. Replace Temp with Query‏‎ (4 revisions)
  98. Refactoring and performance‏‎ (4 revisions)
  99. Introduce Explaining Variable‏‎ (4 revisions)
  100. Minimize accesses to variables‏‎ (4 revisions)
  101. Replace Constructor with Factory Method‏‎ (4 revisions)
  102. Change Value to Reference‏‎ (4 revisions)
  103. Shalloway and Trott 2002‏‎ (4 revisions)
  104. Message chain smell‏‎ (4 revisions)
  105. Robert Cecil Martin 1997a‏‎ (4 revisions)
  106. Wiki etiquette‏‎ (4 revisions)
  107. Joshua Bloch 2006 Bumper Sticker API Design‏‎ (4 revisions)
  108. Move common factors up the hierarchy‏‎ (4 revisions)
  109. Erich Gamma‏‎ (4 revisions)
  110. Robert Cecil Martin 1997b‏‎ (4 revisions)
  111. Option-operand separation‏‎ (4 revisions)
  112. Advice from alumni‏‎ (4 revisions)
  113. Avoid inheritance for optional containment‏‎ (4 revisions)
  114. Wiki tips‏‎ (4 revisions)
  115. Immutable object‏‎ (4 revisions)
  116. Unified Modeling Language‏‎ (4 revisions)
  117. Distribute system intelligence‏‎ (4 revisions)
  118. 2010 frog design criticisms‏‎ (4 revisions)
  119. Greg Searle's captains log star date‏‎ (5 revisions)
  120. Inline Temp‏‎ (5 revisions)
  121. Robert Cecil Martin 2002‏‎ (5 revisions)
  122. Extreme programming‏‎ (5 revisions)
  123. Divergent change smell‏‎ (5 revisions)
  124. Limit compositions in a class‏‎ (5 revisions)
  125. Separate non-communicating behaviour‏‎ (5 revisions)
  126. Factor implementation differences into subcomponents‏‎ (5 revisions)
  127. Management antipatterns‏‎ (5 revisions)
  128. Model classes not roles‏‎ (5 revisions)
  129. A Genetic Algorithms Framework‏‎ (5 revisions - redirect page)
  130. Inappropriate intimacy smell‏‎ (5 revisions)
  131. Circular dependency‏‎ (5 revisions)
  132. Replace Method with Method Object‏‎ (5 revisions)
  133. Strategy meets Template‏‎ (5 revisions)
  134. Incomplete library class smell‏‎ (5 revisions)
  135. Citation needed‏‎ (5 revisions)
  136. Reduce the number of arguments‏‎ (5 revisions)
  137. EXtreme programming‏‎ (5 revisions - redirect page)
  138. Object Encapsulation‏‎ (5 revisions)
  139. Class Encapsulation‏‎ (5 revisions)
  140. Middle man smell‏‎ (5 revisions)
  141. Delegation‏‎ (5 revisions)
  142. Encapsulation is hierarchical‏‎ (5 revisions)
  143. Eliminate case analysis‏‎ (5 revisions)
  144. Coupling‏‎ (5 revisions - redirect page)
  145. Beware inheritance over composition‏‎ (5 revisions)
  146. Avoid equals‏‎ (5 revisions)
  147. What is Bad Design‏‎ (5 revisions)
  148. Avoid verb classes‏‎ (5 revisions)
  149. Don't repeat yourself‏‎ (5 revisions)
  150. Bob Martin's principles‏‎ (5 revisions)
  151. PluS XML format‏‎ (5 revisions)
  152. Send messages to components instead of to self‏‎ (5 revisions)
  153. Uncle Bob‏‎ (5 revisions - redirect page)
  154. 2009 frog design criticisms‏‎ (5 revisions)
  155. Abstract classes should be base classes‏‎ (5 revisions)
  156. Inline Method‏‎ (5 revisions)
  157. Wal's Fish Tank‏‎ (5 revisions)
  158. Replace Error Code with Exception‏‎ (5 revisions)
  159. Separate Query from Modifier‏‎ (5 revisions)
  160. Parallel inheritance hierarchies smell‏‎ (5 revisions)
  161. Organisational patterns‏‎ (6 revisions)
  162. Speculative generality smell‏‎ (6 revisions)
  163. Separate methods that do not communicate‏‎ (6 revisions)
  164. Christopher Alexander 1979‏‎ (6 revisions)
  165. Beware value switches‏‎ (6 revisions)
  166. Methods should use most fields of a class‏‎ (6 revisions)
  167. Split Temporary Variable‏‎ (6 revisions)
  168. CLU‏‎ (6 revisions)
  169. Replace Inheritance with Delegation‏‎ (6 revisions)
  170. Once and only once‏‎ (6 revisions)
  171. John Hofman US001‏‎ (6 revisions)
  172. Overloading‏‎ (6 revisions)
  173. Contain contents not parents‏‎ (6 revisions)
  174. Party of Five 1996‏‎ (6 revisions)
  175. Big design up front‏‎ (6 revisions)
  176. Robert Pirsig 1974‏‎ (6 revisions)
  177. Party of five 1996‏‎ (6 revisions)
  178. List of OO Languages‏‎ (6 revisions)
  179. Avoid no-op overrides‏‎ (6 revisions)
  180. Strategy pattern‏‎ (6 revisions - redirect page)
  181. Reduce the size of methods‏‎ (6 revisions)
  182. Extract Hierarchy‏‎ (6 revisions)
  183. Wards wiki‏‎ (6 revisions - redirect page)
  184. Many to many association idiom‏‎ (6 revisions)
  185. Object cesspool‏‎ (6 revisions)
  186. Subclass‏‎ (6 revisions)
  187. Inheritance‏‎ (6 revisions)
  188. Interface should be dependent on model‏‎ (6 revisions)
  189. Long parameter list smell‏‎ (6 revisions)
  190. Properties / Fields / Attributes‏‎ (6 revisions)
  191. Package versus Namespace‏‎ (6 revisions)
  192. Inversion of control‏‎ (6 revisions)
  193. Object orgy‏‎ (6 revisions)
  194. Class hierarchies should be deep and narrow‏‎ (6 revisions)
  195. Don't expose mutable attributes‏‎ (6 revisions)
  196. Text design‏‎ (6 revisions)
  197. Enum idiom‏‎ (6 revisions)
  198. The Alexander conspiracy‏‎ (6 revisions)
  199. Alternative classes with different interfaces smell‏‎ (6 revisions)
  200. Hide Delegate‏‎ (6 revisions)
  201. The top of the class hierarchy should be abstract‏‎ (6 revisions)
  202. Encapsulate Collection‏‎ (6 revisions)
  203. If it ain't broke don't fix it‏‎ (6 revisions)
  204. BaseBean‏‎ (6 revisions)
  205. Shotgun surgery smell‏‎ (6 revisions)
  206. Beware singletons‏‎ (6 revisions)
  207. Preserve Whole Object‏‎ (6 revisions)
  208. Refused bequest smell‏‎ (6 revisions)
  209. Hide data within its class‏‎ (7 revisions)
  210. Abstraction‏‎ (7 revisions)
  211. Professionalism‏‎ (7 revisions)
  212. William Brown 1998‏‎ (7 revisions)
  213. Single choice principle‏‎ (7 revisions)
  214. Tour Guide Project Page‏‎ (7 revisions)
  215. Reduce implicit parameter passing‏‎ (7 revisions)
  216. You ain't gonna need it‏‎ (7 revisions)
  217. Model the real world‏‎ (7 revisions)
  218. Robert Cecil Martin 1996a‏‎ (7 revisions)
  219. Don't burn your base class‏‎ (7 revisions)
  220. Smalltalk‏‎ (7 revisions)
  221. God object‏‎ (7 revisions)
  222. Favor composition over inheritance‏‎ (7 revisions)
  223. Avoid side effects‏‎ (7 revisions)
  224. Subclasses should be specializations‏‎ (7 revisions)
  225. Gang of Four‏‎ (7 revisions)
  226. Beware of many accessors‏‎ (7 revisions)
  227. Replace Type Code with Class‏‎ (7 revisions)
  228. Presentation separation idiom‏‎ (7 revisions)
  229. Avoid inheritance for implementation‏‎ (7 revisions)
  230. Superclass‏‎ (7 revisions)
  231. Method‏‎ (7 revisions)
  232. Feature envy smell‏‎ (7 revisions)
  233. Association versus Dependency‏‎ (8 revisions)
  234. Nil or export coupling only‏‎ (8 revisions)
  235. Impedance mismatch‏‎ (8 revisions)
  236. Implement behavior with abstract state pattern‏‎ (8 revisions)
  237. Recursion introduction‏‎ (8 revisions)
  238. Reuse release equivalence principle‏‎ (8 revisions)
  239. Exam questions‏‎ (8 revisions)
  240. Do the simplest thing that could possibly work‏‎ (8 revisions)
  241. Johnson and Foote's heuristics‏‎ (8 revisions)
  242. Define classes by behavior, not state pattern‏‎ (8 revisions)
  243. A class should not depend on its users‏‎ (8 revisions)
  244. Anemic Domain Model‏‎ (8 revisions)
  245. Polymorphism‏‎ (8 revisions)
  246. Define default values via explicit protocol pattern‏‎ (8 revisions)
  247. Editing Tips‏‎ (8 revisions)
  248. Trygve Reenskaug‏‎ (8 revisions)
  249. Goto considered harmful‏‎ (8 revisions)
  250. Are you gonna eat that‏‎ (8 revisions)

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

Views
Toolbox