66. You write small methods, yes?
We say we do, but do we really?
65. The ripple hypothesis.
Measuring ripple effect. Again.
64. How to avoid messy code.
If you could ask programs themselves how to avoid messiness, what would they say?
63. The structure of Netty.
Probably the best package structure in the world.
62. Improved radial encapsulation.
Making radial encapsulation more suitable for very large projects.
61. Are we still writing spaghetti code?
Is spaghettiness objective?
60. Evidence-based principles.
Do other principles show traces of objectivity?
59. Does my method look big in this?
The first of the SIPT principles examined: keep methods small.
58. Sip tea.
SIPT: objective principles redux.
57. A quick name-change.
"Impact set" and "Impacted Set" have swapped names.
56. Thank you, Mr Pearson.
Still looking for structural objectivity.
55. Is there any evidence for ripple effect?
Surely we should be able to see this most fundamental of concepts?
54. The 80% rule.
An indispensable coupling rule-of-thumb.
53. Fundamental refactoring vs elaborative refactoring.
Which type of refactoring are you doing?
52. Metrics considered charmful.
Vague notions are not enough.
51. The spectacular instability of good code structure.
Why unstable is good.
50. Do interfaces terminate dependencies?
Not quite an, "It depends," but close.
49. Is your code too concrete?
Don't neglect abstraction in the fight against structural decay.
48. Structure and emergent design.
Can well-structured systems ever just emerge?
47. Battle of the structures.
Which would win: semantic or syntactic structure?
46. Interface over-segregation.
Can interfaces be too small?
45. Bugs and cracks.
Why aren't structure faults as important as run-time faults?
44. Structural simplicity.
WWRHD: What would Rich Hickey do?
43. The structure of Apache Lucene.
The structure-of series continues with another Apache jewel.
42. Software engineering as ... engineering.
A tool software engineers might take from other fields.
41. Structure and the FBI.
An unusual application of your software's structure.
40. Breaking Bad ... interfaces.
How do you split a large interface?
39. The Blighttown corollary.
The importance of grand-scale structure.
38. Visualizing engineering fields.
A look at the competition.
37. Bad program structure: the complectation.
A minor oddity of structure.
36. The most important factor in software decay.
Why are programs poorly structured?
35. The four best refactorings.
Most refactoring is pretty; some is essential.
34. A funny thing happened on the way to the refactory.
Freedom of travel in the land of radial encapsulation.
33. Who's afraid of the big bad class?
How to refactor large classes.
32. Structural contingency (part one).
How to improve the intent of our code.
31. What's the opposite of duplication?
Strange that we still worry about duplication.
30. Dependency inversion: the structure logarithm.
A new use for an old principle.
29. The refactorer spectrum.
Refactoring is difficult and not everyone can do it.
28. Coupling and cohesion: failed concepts.
What's wrong with these two great concepts?
27. Asimov's three laws of refactoring.
Don't phone: it's just for fun.
26. The structure of FitNesse.
A structural peek under the bonnet of a great piece of software.
25. Structure-driven design.
Seriously, who didn't see this coming?
24. Interfaces in Java.
Some unfinished interface business.
23. The tragedy of package coupling.
Why package coupling still overpowers us.
22. Structure and information.
Gettin' entropic with it.
21. Structure and theorems.
Are programs theorems?
20. Structure and zombies.
All aboard the zombie-bandwagon!
19. Amplification revisited.
Investigating the bane of accidental interconnectedness.
18. ptainai, pronounced, "Peh-tain-eye."
An investigation into some hallowed advice.
17. The structure of Spring (core).
Finally, some light in the darkness.
16. Code autopsy.
An unsolved mystery remains in Ant: we're going back in.
15. Going Dawkins on god objects.
How to identify and slay these structure bad-boys.
14. The structure of Struts.
The excellent Struts gets the structure-analysis treatment.
13. How deep is your code?
Source code has many dimensions but its depth can be most dangerous.
12. The structure of Ant.
The search for excellent code structure continues with a look at Ant.
11. The structure of JUnit.
JUnit is a masterpiece. Its structure should be studied.
10. A simple suggestion to radically improve your package structure.
You don't need elaborate JSRs to build a better package structure.
9. How many classes and packages should you have?
What constrains your system's classes and packages?
8. The three greatest paragraphs ever written on encapsulation.
Encapsulation is a concept we all know and love. But where did it come from?
7. Serpents and sunbursts in source code structure.
What can we learn from viewing just the structure of a program?
6. Can we measure encapsulation?
Welcome to the world of potential coupling.
5. Spoiklin Soice.
A documentation and static analysis tool.
4. The Tulegatan principles.
A summary of some software development principles.
3. What is good source code structure?
And would you recognise it if it bit you?
2. The three-box model of software development.
Software development encompasses many, many things but sometimes a simplification helps.
1. What is source code structure?
Do we really know what we're looking for?

Ed Kirwan profile

Java Code Geeks
Dzone dude