Popular pages

From CSSEMediaWiki
Jump to: navigation, search

Showing below up to 500 results starting with #1.

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

  1. Main Page‏‎ (176,617 views)
  2. Resources‏‎ (32,454 views)
  3. Wiki users‏‎ (24,726 views)
  4. OO gurus‏‎ (22,309 views)
  5. Design maxims‏‎ (21,864 views)
  6. TobiW's Design Study‏‎ (17,803 views)
  7. Refactoring‏‎ (17,762 views)
  8. Design patterns‏‎ (16,550 views)
  9. OO wisdom‏‎ (15,898 views)
  10. Matthew's Design Study‏‎ (14,784 views)
  11. Martin Fowler‏‎ (14,772 views)
  12. Encapsulation boundary‏‎ (14,473 views)
  13. HistoryCrumbs.user.js‏‎ (13,717 views)
  14. Coupling and cohesion‏‎ (12,643 views)
  15. Lecture sequence‏‎ (12,481 views)
  16. Code smells‏‎ (11,422 views)
  17. Warfarin Design‏‎ (11,282 views)
  18. Aidan's Design Study‏‎ (10,844 views)
  19. William Brown 1998‏‎ (10,173 views)
  20. Wals library‏‎ (9,743 views)
  21. Janina's Design Study‏‎ (9,492 views)
  22. Riel's heuristics‏‎ (9,392 views)
  23. Information hiding‏‎ (9,384 views)
  24. Schools of thought‏‎ (8,808 views)
  25. Design examples‏‎ (8,771 views)
  26. Class versus Object‏‎ (8,199 views)
  27. James Ashford Design Study‏‎ (8,026 views)
  28. Design Project‏‎ (7,971 views)
  29. Nelson Shaw Design Project‏‎ (7,970 views)
  30. Nick's Design Study‏‎ (7,944 views)
  31. Extract Method‏‎ (7,922 views)
  32. Hall of fame‏‎ (7,865 views)
  33. Video rental system‏‎ (7,666 views)
  34. Editing Tips‏‎ (7,426 views)
  35. Encapsulation‏‎ (7,308 views)
  36. Poker Simulator Design Writeup‏‎ (7,067 views)
  37. One hour tour‏‎ (6,718 views)
  38. OO culture‏‎ (6,710 views)
  39. Data clumps smell‏‎ (6,656 views)
  40. Stable abstractions principle‏‎ (6,624 views)
  41. Martins Design Study‏‎ (6,517 views)
  42. Test Driven Development‏‎ (6,493 views)
  43. Start here‏‎ (6,237 views)
  44. Transaction script pattern‏‎ (6,234 views)
  45. Overloading‏‎ (6,219 views)
  46. Reuse release equivalence principle‏‎ (5,923 views)
  47. John Hofman's Design Study‏‎ (5,872 views)
  48. Use lazy initialization pattern‏‎ (5,669 views)
  49. Decorator‏‎ (5,458 views)
  50. Joey's design study‏‎ (5,451 views)
  51. About COSC427‏‎ (5,300 views)
  52. Strategy‏‎ (5,251 views)
  53. Keep related data and behavior in one place‏‎ (5,235 views)
  54. OOTetris Design‏‎ (5,199 views)
  55. Iterator‏‎ (5,195 views)
  56. Guitar Amplifier Design‏‎ (5,135 views)
  57. Program to the interface not the implementation‏‎ (4,950 views)
  58. Server Requests‏‎ (4,893 views)
  59. Design by contract‏‎ (4,795 views)
  60. David Parnas‏‎ (4,793 views)
  61. Flyweight‏‎ (4,732 views)
  62. Model view controller‏‎ (4,716 views)
  63. Object-oriented design anti-patterns‏‎ (4,628 views)
  64. AlexsDesignStudy‏‎ (4,587 views)
  65. Law of Demeter‏‎ (4,545 views)
  66. Divergent change smell‏‎ (4,539 views)
  67. Long method smell‏‎ (4,455 views)
  68. Factory Method‏‎ (4,415 views)
  69. Command query separation‏‎ (4,374 views)
  70. Observer‏‎ (4,370 views)
  71. Project ideas‏‎ (4,324 views)
  72. Visitor‏‎ (4,321 views)
  73. Parallel hierarchies problem‏‎ (4,247 views)
  74. Poker Simulator Design Log‏‎ (4,165 views)
  75. Automation‏‎ (4,162 views)
  76. Tell, don't ask‏‎ (4,132 views)
  77. Open closed principle‏‎ (4,125 views)
  78. 427 assessment‏‎ (4,029 views)
  79. Prototype‏‎ (3,831 views)
  80. Adapter‏‎ (3,831 views)
  81. Dependency inversion principle‏‎ (3,829 views)
  82. The top of the class hierarchy should be abstract‏‎ (3,756 views)
  83. Gang of Four 1995‏‎ (3,735 views)
  84. JITAS Design Study‏‎ (3,716 views)
  85. Mujtaba's design study‏‎ (3,689 views)
  86. Introduce Parameter Object‏‎ (3,653 views)
  87. My actual Project, I think.‏‎ (3,626 views)
  88. Oliver Cardwell/Project‏‎ (3,611 views)
  89. Define classes by behavior, not state pattern‏‎ (3,601 views)
  90. Abstract Factory‏‎ (3,546 views)
  91. Ken Auer 1995‏‎ (3,540 views)
  92. 2008 Exam answers‏‎ (3,518 views)
  93. Unified Modeling Language‏‎ (3,502 views)
  94. Facade‏‎ (3,429 views)
  95. Association versus Dependency‏‎ (3,426 views)
  96. Antipatterns‏‎ (3,413 views)
  97. Don't burn your base class‏‎ (3,382 views)
  98. Avoid concrete base classes‏‎ (3,333 views)
  99. Benjamin's Design Study‏‎ (3,326 views)
  100. Duplicate code smell‏‎ (3,310 views)
  101. Common closure principle‏‎ (3,296 views)
  102. OO tools‏‎ (3,186 views)
  103. Composite‏‎ (3,156 views)
  104. Shotgun surgery smell‏‎ (3,152 views)
  105. Bridge‏‎ (3,146 views)
  106. Ward's wiki‏‎ (3,143 views)
  107. Quick Reference‏‎ (3,098 views)
  108. Single responsibility principle‏‎ (3,087 views)
  109. Alternative classes with different interfaces smell‏‎ (3,083 views)
  110. Singleton‏‎ (3,033 views)
  111. Tanmay's Design Study‏‎ (3,018 views)
  112. Aggregation versus Composition‏‎ (2,995 views)
  113. Acyclic dependencies principle‏‎ (2,978 views)
  114. Do the simplest thing that could possibly work‏‎ (2,974 views)
  115. Intelligent children pattern‏‎ (2,937 views)
  116. Michael's Design Study‏‎ (2,930 views)
  117. Nomenclature‏‎ (2,929 views)
  118. Favor composition over inheritance‏‎ (2,920 views)
  119. Encapsulate Collection‏‎ (2,912 views)
  120. Java Collections Framework‏‎ (2,912 views)
  121. Kent Beck‏‎ (2,910 views)
  122. Mujtaba's Log‏‎ (2,901 views)
  123. State‏‎ (2,880 views)
  124. Interface segregation principle‏‎ (2,878 views)
  125. Mediator‏‎ (2,828 views)
  126. Double Dispatch‏‎ (2,823 views)
  127. Parse tree design‏‎ (2,817 views)
  128. PaulDesignStudy‏‎ (2,762 views)
  129. Table module pattern‏‎ (2,749 views)
  130. Bob Martin‏‎ (2,735 views)
  131. Frogs design‏‎ (2,722 views)
  132. Data class smell‏‎ (2,711 views)
  133. Nick Brettel's eight puzzle design‏‎ (2,677 views)
  134. Getters and setters‏‎ (2,649 views)
  135. Avoid downcasting‏‎ (2,639 views)
  136. 2007 Exam answers‏‎ (2,634 views)
  137. Memento‏‎ (2,624 views)
  138. Accountability‏‎ (2,621 views)
  139. Perfect OO Language‏‎ (2,618 views)
  140. Avoid no-op overrides‏‎ (2,608 views)
  141. Switch statement smell‏‎ (2,591 views)
  142. Separation of concerns‏‎ (2,576 views)
  143. Architectural patterns‏‎ (2,573 views)
  144. Template Method‏‎ (2,565 views)
  145. Command‏‎ (2,556 views)
  146. Martin Doms' Design Study‏‎ (2,524 views)
  147. Software reuse‏‎ (2,497 views)
  148. Liskov substitution principle‏‎ (2,485 views)
  149. Defer identification of state variables pattern‏‎ (2,483 views)
  150. Martin Fowler 2003‏‎ (2,480 views)
  151. Michal's Design Study‏‎ (2,469 views)
  152. Analysis patterns‏‎ (2,445 views)
  153. Avoid inheritance for implementation‏‎ (2,434 views)
  154. Johnson and Foote 1988‏‎ (2,426 views)
  155. State machine design‏‎ (2,424 views)
  156. Premature optimization‏‎ (2,413 views)
  157. Subclass‏‎ (2,382 views)
  158. Incomplete library class smell‏‎ (2,354 views)
  159. Joff's Place‏‎ (2,339 views)
  160. Patterns‏‎ (2,335 views)
  161. Idioms‏‎ (2,322 views)
  162. Feature envy smell‏‎ (2,320 views)
  163. Common reuse principle‏‎ (2,315 views)
  164. Introduce Null Object‏‎ (2,303 views)
  165. Frogs second design‏‎ (2,283 views)
  166. Wiki tips‏‎ (2,268 views)
  167. Builder‏‎ (2,266 views)
  168. JUnit‏‎ (2,258 views)
  169. Account setup‏‎ (2,254 views)
  170. Inheritance‏‎ (2,254 views)
  171. Encapsulate concrete state pattern‏‎ (2,247 views)
  172. Polymorphism‏‎ (2,233 views)
  173. Eliminate irrelevant classes‏‎ (2,227 views)
  174. Object pool‏‎ (2,219 views)
  175. Once and only once‏‎ (2,182 views)
  176. Avoid god classes‏‎ (2,177 views)
  177. Message chain smell‏‎ (2,150 views)
  178. Replace Inheritance with Delegation‏‎ (2,133 views)
  179. Exam questions‏‎ (2,127 views)
  180. 2005 Exam answers‏‎ (2,116 views)
  181. Parallel inheritance hierarchies smell‏‎ (2,109 views)
  182. Observations and Measurements‏‎ (2,105 views)
  183. Method‏‎ (2,104 views)
  184. Abstract class‏‎ (2,099 views)
  185. Maxim Hierarchy‏‎ (2,094 views)
  186. Implement behavior with abstract state pattern‏‎ (2,092 views)
  187. Proxy‏‎ (2,090 views)
  188. Template view pattern‏‎ (2,090 views)
  189. Interpreter‏‎ (2,088 views)
  190. Abstraction‏‎ (2,083 views)
  191. Gang of Four‏‎ (2,075 views)
  192. Guitar Tutor Design‏‎ (2,072 views)
  193. Recursion introduction‏‎ (2,060 views)
  194. Terrain Renderer Design‏‎ (2,058 views)
  195. Large class smell‏‎ (2,054 views)
  196. Stable dependencies principle‏‎ (2,053 views)
  197. Ward Cunningham‏‎ (2,049 views)
  198. 427 design standard‏‎ (2,049 views)
  199. Robert Pirsig 1974‏‎ (2,040 views)
  200. LukasKorsikaDesignStudy‏‎ (2,036 views)
  201. BaseBean‏‎ (2,031 views)
  202. Equals vs the Encapsulation Boundary‏‎ (2,031 views)
  203. Bob Martin's principles‏‎ (2,021 views)
  204. Long parameter list smell‏‎ (2,017 views)
  205. Martin Fowler 1999‏‎ (2,000 views)
  206. Comments and suggestions‏‎ (1,993 views)
  207. Object cesspool‏‎ (1,982 views)
  208. 2006 Exam answers‏‎ (1,974 views)
  209. Beware type switches‏‎ (1,960 views)
  210. Chain of Responsibility‏‎ (1,925 views)
  211. Arthur Riel 1996‏‎ (1,921 views)
  212. Martin Fowler 1997‏‎ (1,913 views)
  213. Model the real world‏‎ (1,896 views)
  214. One key abstraction‏‎ (1,887 views)
  215. God object‏‎ (1,885 views)
  216. Refused bequest smell‏‎ (1,861 views)
  217. Sorcerers design‏‎ (1,858 views)
  218. Combining design patterns‏‎ (1,832 views)
  219. DMA Design Project - first submission‏‎ (1,830 views)
  220. Trains design‏‎ (1,826 views)
  221. Fat interfaces‏‎ (1,825 views)
  222. Presentation separation idiom‏‎ (1,825 views)
  223. Advice from alumni‏‎ (1,816 views)
  224. Super quick exam ref‏‎ (1,813 views)
  225. You ain't gonna need it‏‎ (1,802 views)
  226. Speculative generality smell‏‎ (1,780 views)
  227. Big design up front‏‎ (1,779 views)
  228. Johnson and Foote's heuristics‏‎ (1,760 views)
  229. Lecture times‏‎ (1,757 views)
  230. Extract Class‏‎ (1,755 views)
  231. Don't expose mutable attributes‏‎ (1,754 views)
  232. Comments smell‏‎ (1,752 views)
  233. Getter and setter policy‏‎ (1,738 views)
  234. Quotes‏‎ (1,735 views)
  235. Class hierarchies should be deep and narrow‏‎ (1,733 views)
  236. PLoP 1995‏‎ (1,732 views)
  237. Enum idiom‏‎ (1,720 views)
  238. Avoid mixing inputs and outputs‏‎ (1,716 views)
  239. Encapsulate that which varies‏‎ (1,713 views)
  240. Service layer pattern‏‎ (1,707 views)
  241. Avoid protected data‏‎ (1,703 views)
  242. A class should not depend on its users‏‎ (1,699 views)
  243. Many to many association idiom‏‎ (1,686 views)
  244. Avoid interface bloat‏‎ (1,684 views)
  245. Hide data within its class‏‎ (1,681 views)
  246. Goto considered harmful‏‎ (1,674 views)
  247. Define default values via explicit protocol pattern‏‎ (1,674 views)
  248. Behavioral completeness‏‎ (1,669 views)
  249. Dependency injection‏‎ (1,668 views)
  250. Identify message layers pattern‏‎ (1,666 views)
  251. Referring to Objects‏‎ (1,660 views)
  252. Robert Cecil Martin 1996a‏‎ (1,653 views)
  253. Robert Cecil Martin 2002‏‎ (1,647 views)
  254. Tanmay's Log‏‎ (1,644 views)
  255. Avoid side effects‏‎ (1,642 views)
  256. Empty method over-rides‏‎ (1,640 views)
  257. BrettWardsDesignStudy‏‎ (1,639 views)
  258. Monsters design‏‎ (1,635 views)
  259. Wiki etiquette‏‎ (1,632 views)
  260. Minimize number of methods‏‎ (1,617 views)
  261. OO Python Character Animation Design Study‏‎ (1,616 views)
  262. Don't repeat yourself‏‎ (1,613 views)
  263. Multiple Inheritance‏‎ (1,608 views)
  264. Teaching and learning style‏‎ (1,594 views)
  265. Favour containment over association‏‎ (1,584 views)
  266. Robert Cecil Martin 1996b‏‎ (1,581 views)
  267. Beware value switches‏‎ (1,580 views)
  268. Beware of many accessors‏‎ (1,577 views)
  269. Similar patterns and how to tell them apart‏‎ (1,562 views)
  270. Abstract classes should be base classes‏‎ (1,560 views)
  271. Sign your work‏‎ (1,559 views)
  272. Robert Cecil Martin 1996c‏‎ (1,558 views)
  273. Beware singletons‏‎ (1,554 views)
  274. A froggy visitor‏‎ (1,546 views)
  275. Avoid equals‏‎ (1,543 views)
  276. Minimize accesses to variables‏‎ (1,542 views)
  277. Extreme programming‏‎ (1,537 views)
  278. Text design‏‎ (1,537 views)
  279. Avoid multiple inheritance‏‎ (1,536 views)
  280. Encapsulation is hierarchical‏‎ (1,535 views)
  281. Separate Query from Modifier‏‎ (1,534 views)
  282. Preserve Whole Object‏‎ (1,530 views)
  283. Inappropriate intimacy smell‏‎ (1,528 views)
  284. Reduce the size of methods‏‎ (1,514 views)
  285. Circle-ellipse problem‏‎ (1,512 views)
  286. Subclasses should be specializations‏‎ (1,505 views)
  287. Separate methods that do not communicate‏‎ (1,502 views)
  288. Domain model pattern‏‎ (1,501 views)
  289. Abstract vs Interface‏‎ (1,497 views)
  290. Impedance mismatch‏‎ (1,496 views)
  291. Alumni‏‎ (1,486 views)
  292. Are you gonna eat that‏‎ (1,475 views)
  293. Single choice principle‏‎ (1,473 views)
  294. Robert Cecil Martin 1996e‏‎ (1,469 views)
  295. Avoid interface pollution‏‎ (1,466 views)
  296. Robert Cecil Martin 1996d‏‎ (1,464 views)
  297. Replace Type Code with Class‏‎ (1,464 views)
  298. Send messages to components instead of to self‏‎ (1,462 views)
  299. Robert Cecil Martin 2003‏‎ (1,459 views)
  300. Robert Cecil Martin 1997b‏‎ (1,444 views)
  301. Eliminate case analysis‏‎ (1,443 views)
  302. Replace Conditional with Polymorphism‏‎ (1,439 views)
  303. Replace Parameter with Explicit Methods‏‎ (1,438 views)
  304. Extract Hierarchy‏‎ (1,432 views)
  305. Encapsulate Field‏‎ (1,432 views)
  306. Jason's Useful Links Page‏‎ (1,431 views)
  307. Jenny Harlow‏‎ (1,429 views)
  308. Nil or export coupling only‏‎ (1,418 views)
  309. Software crisis‏‎ (1,414 views)
  310. Keep last years stuff‏‎ (1,410 views)
  311. Alan Kay‏‎ (1,404 views)
  312. Middle man smell‏‎ (1,402 views)
  313. Robert Cecil Martin 1997a‏‎ (1,394 views)
  314. GenericGuidelines‏‎ (1,393 views)
  315. Big ball of mud‏‎ (1,389 views)
  316. Jojo's OO Design Project Log‏‎ (1,387 views)
  317. Factor implementation differences into subcomponents‏‎ (1,360 views)
  318. The Alexander conspiracy‏‎ (1,345 views)
  319. No silver bullet‏‎ (1,344 views)
  320. No Global Variables‏‎ (1,339 views)
  321. Distribute system intelligence‏‎ (1,339 views)
  322. How to assess‏‎ (1,329 views)
  323. Reduce the number of arguments‏‎ (1,314 views)
  324. AlexsLibrary‏‎ (1,312 views)
  325. Sequential coupling‏‎ (1,311 views)
  326. Orthogonality‏‎ (1,310 views)
  327. Class diagram‏‎ (1,306 views)
  328. Christopher Alexander 1977‏‎ (1,297 views)
  329. What is Bad Design‏‎ (1,297 views)
  330. Encapsulate Downcast‏‎ (1,294 views)
  331. Ward and Kent‏‎ (1,292 views)
  332. Bertrand's Design Study‏‎ (1,289 views)
  333. Avoid becomes‏‎ (1,287 views)
  334. Ralph Johnson‏‎ (1,285 views)
  335. Split large classes‏‎ (1,281 views)
  336. Limit hierarchy depth‏‎ (1,277 views)
  337. Minimal public interface‏‎ (1,276 views)
  338. Replace Parameter with Method‏‎ (1,272 views)
  339. Keep accessors and mutators separate‏‎ (1,269 views)
  340. Refactoring and performance‏‎ (1,267 views)
  341. Documenting Patterns‏‎ (1,267 views)
  342. Greg Searle's captains log star date‏‎ (1,257 views)
  343. Model classes not roles‏‎ (1,257 views)
  344. Lazy class smell‏‎ (1,249 views)
  345. Party of five 1996‏‎ (1,248 views)
  346. Amelioration patterns‏‎ (1,244 views)
  347. Named constants‏‎ (1,243 views)
  348. Extensibility‏‎ (1,238 views)
  349. Hide your decisions‏‎ (1,234 views)
  350. Favour deep hierarchies‏‎ (1,229 views)
  351. Inversion of control‏‎ (1,226 views)
  352. Superclass‏‎ (1,224 views)
  353. Bob Martin's heuristics‏‎ (1,217 views)
  354. Beware of non-communicating methods‏‎ (1,215 views)
  355. Option-operand separation‏‎ (1,211 views)
  356. Organisational patterns‏‎ (1,209 views)
  357. Temporary field smell‏‎ (1,206 views)
  358. Greg Searle's project blackjack‏‎ (1,203 views)
  359. GenA: A Genetic Algorithms Framework‏‎ (1,202 views)
  360. Christopher Alexander 1979‏‎ (1,198 views)
  361. Change Unidirectional Association to Bidirectional‏‎ (1,198 views)
  362. Andrew Hunt 1999‏‎ (1,195 views)
  363. Law of leaky abstractions‏‎ (1,187 views)
  364. Immutable object‏‎ (1,186 views)
  365. Bertrand Meyer‏‎ (1,185 views)
  366. Inheritance for specialization‏‎ (1,184 views)
  367. Hide Delegate‏‎ (1,180 views)
  368. Replace Method with Method Object‏‎ (1,179 views)
  369. Smalltalk‏‎ (1,178 views)
  370. Reusable frameworks over reusable components‏‎ (1,178 views)
  371. Design patterns break rules‏‎ (1,177 views)
  372. Christopher Alexander‏‎ (1,167 views)
  373. Citation needed‏‎ (1,158 views)
  374. RL Design Study Log‏‎ (1,154 views)
  375. Real name‏‎ (1,149 views)
  376. Refactoring and design‏‎ (1,148 views)
  377. Exam Quick Reference‏‎ (1,140 views)
  378. Yo-yo problem‏‎ (1,104 views)
  379. Call super‏‎ (1,093 views)
  380. Strategy meets Template‏‎ (1,091 views)
  381. Package versus Namespace‏‎ (1,090 views)
  382. Kris's Design Study‏‎ (1,084 views)
  383. Replace Error Code with Exception‏‎ (1,080 views)
  384. Joshua Bloch 2006 Bumper Sticker API Design‏‎ (1,076 views)
  385. Erich Gamma‏‎ (1,076 views)
  386. Circular dependency‏‎ (1,075 views)
  387. Why refactoring works‏‎ (1,072 views)
  388. Guitar Tutor Report‏‎ (1,067 views)
  389. Anemic Domain Model‏‎ (1,053 views)
  390. Vehicles and operators design‏‎ (1,031 views)
  391. Interface‏‎ (1,030 views)
  392. Interface should be dependent on model‏‎ (1,023 views)
  393. Delegation‏‎ (1,023 views)
  394. Greg Searle's design‏‎ (1,018 views)
  395. Professionalism‏‎ (1,016 views)
  396. Beware inheritance over composition‏‎ (1,009 views)
  397. Inline Temp‏‎ (1,004 views)
  398. Object orgy‏‎ (1,001 views)
  399. Avoid accidental multiple inheritance‏‎ (999 views)
  400. Object Encapsulation‏‎ (997 views)
  401. Inventory and Accounting‏‎ (986 views)
  402. Hillside Group‏‎ (983 views)
  403. Class Encapsulation‏‎ (982 views)
  404. Introduction to the Terrain Renderer‏‎ (979 views)
  405. If it ain't broke don't fix it‏‎ (977 views)
  406. Jim Coplien‏‎ (969 views)
  407. DMA Design Project‏‎ (968 views)
  408. Replace Constructor with Factory Method‏‎ (960 views)
  409. Shalloway and Trott 2002‏‎ (955 views)
  410. Avoid verb classes‏‎ (953 views)
  411. Duplicate Observed Data‏‎ (949 views)
  412. Poltergeists‏‎ (943 views)
  413. Constant interface‏‎ (940 views)
  414. Tour Guide Project Page‏‎ (938 views)
  415. Replace Temp with Query‏‎ (930 views)
  416. Split Temporary Variable‏‎ (927 views)
  417. Contain contents not parents‏‎ (920 views)
  418. Agile manifesto‏‎ (919 views)
  419. Introduce Explaining Variable‏‎ (919 views)
  420. Instance‏‎ (905 views)
  421. Extract Subclass‏‎ (904 views)
  422. Component versus Module‏‎ (900 views)
  423. Methods should use most fields of a class‏‎ (899 views)
  424. Inline Class‏‎ (895 views)
  425. Transform view pattern‏‎ (895 views)
  426. Do not change the state of an object without going through its public interface‏‎ (893 views)
  427. Rename Method‏‎ (891 views)
  428. Move Field‏‎ (886 views)
  429. Joshua Bloch‏‎ (880 views)
  430. Language Spectrum‏‎ (880 views)
  431. Substitute Algorithm‏‎ (879 views)
  432. Trygve Reenskaug‏‎ (879 views)
  433. Michael's Log‏‎ (877 views)
  434. Move common factors up the hierarchy‏‎ (875 views)
  435. Row data gateway pattern‏‎ (867 views)
  436. Kent Beck 2003‏‎ (867 views)
  437. Beware accessors‏‎ (864 views)
  438. Introduce Foreign Method‏‎ (858 views)
  439. Party of Five 1996‏‎ (855 views)
  440. Extract Superclass‏‎ (850 views)
  441. Change Value to Reference‏‎ (847 views)
  442. Arthur Riel‏‎ (840 views)
  443. Separate non-communicating behaviour‏‎ (840 views)
  444. Introduce Local Extension‏‎ (833 views)
  445. Inline Method‏‎ (833 views)
  446. Push Down Method‏‎ (832 views)
  447. Pull Up Method‏‎ (832 views)
  448. Pull Up Field‏‎ (826 views)
  449. Move Method‏‎ (820 views)
  450. Access levels‏‎ (818 views)
  451. Push Down Field‏‎ (818 views)
  452. Collapse Hierarchy‏‎ (816 views)
  453. Parameterise Method‏‎ (811 views)
  454. 2009 frog design criticisms‏‎ (810 views)
  455. Ken Auer‏‎ (806 views)
  456. Introduce common base class‏‎ (804 views)
  457. Change Reference to Value‏‎ (803 views)
  458. Wal's Fish Tank‏‎ (801 views)
  459. Extract Interface‏‎ (797 views)
  460. Contained objects should not use each other‏‎ (797 views)
  461. Replace Data Value with Object‏‎ (793 views)
  462. Properties / Fields / Attributes‏‎ (787 views)
  463. Blackboard System‏‎ (784 views)
  464. Pull Up Constructor Body‏‎ (776 views)
  465. Remove Parameter‏‎ (773 views)
  466. Rebecca Wirfs-Brock 1990‏‎ (772 views)
  467. Limit compositions in a class‏‎ (768 views)
  468. Remove Setting Method‏‎ (767 views)
  469. Hide Method‏‎ (766 views)
  470. No Peter Pan objects‏‎ (763 views)
  471. Remove Middle Man‏‎ (761 views)
  472. Avoid inheritance for optional containment‏‎ (758 views)
  473. Cay Horstmann 2006‏‎ (755 views)
  474. Diamond Problem‏‎ (755 views)
  475. BenjaminTaylor Previous Design Work‏‎ (754 views)
  476. Agent classes irrelevant‏‎ (754 views)
  477. Spaghetti code‏‎ (750 views)
  478. Reduce implicit parameter passing‏‎ (746 views)
  479. Data mapper pattern‏‎ (741 views)
  480. Model the room‏‎ (741 views)
  481. Jojo's 2008 Design Study‏‎ (740 views)
  482. John Hofman US001‏‎ (739 views)
  483. Introduce common data class‏‎ (737 views)
  484. Hierarchical Model View Controller‏‎ (731 views)
  485. Replace Magic Number with Symbolic Constant‏‎ (731 views)
  486. Management antipatterns‏‎ (730 views)
  487. Jumble‏‎ (725 views)
  488. Front controller pattern‏‎ (718 views)
  489. Table data gateway pattern‏‎ (717 views)
  490. Designfest‏‎ (715 views)
  491. Self Encapsulate Field‏‎ (710 views)
  492. PluS XML format‏‎ (704 views)
  493. 2010 frog design criticisms‏‎ (703 views)
  494. One Into Many‏‎ (699 views)
  495. Agile methods‏‎ (698 views)
  496. CLU‏‎ (694 views)
  497. Barbara Liskov‏‎ (693 views)
  498. Establishing priorities‏‎ (690 views)
  499. Managing complexity‏‎ (688 views)
  500. Add Parameter‏‎ (688 views)

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

Views
Personal tools
Toolbox