M

Michael Feathers

michaelfeathers.typepad.com · Personal blog · on HN since 2007

Michael Feathers, author of a book on legacy code, writes about software design, testing, object orientation and code complexity.

What HN saysHN commenters cite his 'carrying cost of code' post on the hidden cost of features and complexity, and note he wrote the book on legacy code.
23HN people shared it
3linked it in comments
39stories submitted
534story points
2 years agolast shared
2007people per year2026

Most-shared posts

  1. 1
    The Carrying-Cost of Code: Taking Lean Seriously (2011)
    8 people · 138 points · first shared 2011 · 23 comments on HN
  2. 2
    The Flawed Theory Behind Unit Testing
    4 people · 32 points · first shared 2008 · 5 comments on HN
  3. 3
    The Framework Superclass Anti-Pattern
    3 people · 9 points · first shared 2013 · discussion on HN
  4. 4
    Global Variables Destroy Design Information
    3 people · 4 points · first shared 2012 · discussion on HN
  5. 5
  6. 6
    Making Too Much of TDD
    2 people · 44 points · first shared 2010 · 16 comments on HN
  7. 7
    Temporal Correlation of Class Changes
    2 people · 1 points · first shared 2011 · discussion on HN
  8. 8
    The Tyranny of the Diff
    1 people · 81 points · first shared 2012 · 52 comments on HN
  9. 9
    Avoid Null Checks by Replacing Finders with Tellers
    1 people · 59 points · first shared 2013 · 103 comments on HN
  10. 10
    Flipping Assumptions with 'Programmer Anarchy'
    1 people · 26 points · first shared 2013 · 3 comments on HN
  11. 11
    The Bad Code Kata
    1 people · 24 points · first shared 2010 · 4 comments on HN
  12. 12
    The Long Tail of Technical Debt
    1 people · 16 points · first shared 2012 · 1 comments on HN
  13. 13
    Refactoring is Sloppy
    1 people · 8 points · first shared 2013 · discussion on HN
  14. 14
    Unconditional Programming
    1 people · 7 points · first shared 2013 · discussion on HN
  15. 15
    The Cult of Language Expertise
    1 people · 7 points · first shared 2007 · 1 comments on HN

What HN people wrote when they linked it

michaelfeathers · 2013-06-21
I've been pushing this idea for the past couple of years with clients, and when I give talks at conferences. The fact of the matter is that unless an organization knows what the carrying cost is for their features, and the effect in terms of complexity, they are flying blind. In essence, it is Joel's Law of Leaky Abstractions at work. You can't manage a software project just in terms of a set of features you agree upon with business. The codebase is a key constraint that underlies all of those discussions and unless the effects of feature choice are on the table, you end up incurring radically different costs. This isn't just about paying attention to technical debt. It's about having the discussion about whether it is worth targeting some features or not, taking the code into account - using it as a factor in business decisions. http://www.confreaks.com/videos/717-rockymtnruby2011-opening-keynote-c… http://michaelfeathers.typepad.com/michael_feathers_blog/2011/05/the-c…
mattgreenrocks · 2014-06-09
That's just the fat model approach. It suffers from similar issues as fat controllers, whereby unrelated functionality tends to accumulate. Why do models know how to persist themselves? Or send themselves over the network? What does that have to do with the concept they represent? It conflates technical concerns ("how do I serialize myself?") with business concerns ("am I valid?"). It doesn't help that Core Data forces you into the framework superclass antipattern: http://michaelfeathers.typepad.com/michael_feathers_blog/2013/01/the-f…
shoo · 2014-11-11
This reminds me of a post by Michael Feathers, titled "The carrying cost of code" [1]. Feathers wrote the book about legacy code [2]. I think he makes approximately the same point: > If you are making cars or widgets, you make them one by one. They proceed through the manufacturing process and you can gain very real efficiencies by paying attention to how the pieces go through the process. Lean Software Development has chosen to see tasks as pieces. We carry them through a process and end up with completed products on the other side. > It's a nice view of the world, but it is a bit of a lie. In software development, we are essentially working on the same car or widget continuously, often for years. We are in the same soup, the same codebase. We can't expect a model based on independence of pieces in manufacturing to be accurate when we are working continuously on a single thing (a codebase) that shows wear over time and needs constant attention. [1] - http://michaelfeathers.typepad.com/michael_feathers_blog/2011/05/the-c… [2] - http://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0…

Keyboard shortcuts

/Search
j kNext / previous blog
EnterOpen selected blog
vVisit the blog site
fFollow / unfollow
lSwitch grid / list view
dSwitch dark mode
g hHome
g pTop posts
g tTopics
g fFollowing
g lLiked
g yHistory
g qFAQ
EscBack / close