Popular pages

From CSSEMediaWiki
Jump to: navigation, search

Showing below up to 500 results starting with #51.

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

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

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

Views
Toolbox