30th
2009
Dec
permalink

It’s hard to change a little. It’s much easier to change a lot.

When you try to change a little, your old mindset still has its old values and attachments, and you inevitably slide back into your old groove. But when you change enough to create a new mindset, you can free yourself from your old way of looking at things and create a new groove.

rut

Homer Simpson’s ass groove comes to mind. Moving over a few inches would be painful at best. Moving across the couch to a new cushion would be like starting fresh. The mind and habits work the same way.

This has happened to me a number of times.

Waking Up Earlier

For years I tried to wake up about 30 minutes earlier than my regular routine. It would work for a while, but then I’d inevitably start waking up later and later until I reached my regular schedule. However, when I got a new job that required me to wake up 2 hours earlier, sure it was tough at first, like adjusting to jet lag, but it became my new routine. And I’ve had no problems consistently waking up 2 hours earlier than my old routine.

CVS/Subversion -> Distributed Version Control

I used to use CVS for version control at work. For a small project, a co-worker and I tried using Mercurial. On the surface, Mercurial is very similar to CVS, and it was very easy as a CVS user to just pick up Mercurial and get started using it. It ended up being nice, but we perceived it as CVS + local commits and a few other “neat” features. Nothing game-changing. Months go by and I decide to give distributed version control another shot. This time I tried git. Git is so different from CVS that I was forced to literally stop what I was doing and learn git. This seemed bad, but it forced me to change how I thought about version control. I used to think of version control as something that was akin to writing in stone because it was expensive and could never be changed. However, now I see everything as patches, and patches are cheap, can be applied, rolled back, and re-ordered. A completely different mindset. Now I’m hooked on distributed version control and couldn’t live without it.

Imperative Programming -> Functional Programming

People I have known who tried learning functional programming using a language that supports functional features but allows falling back on imperative loops and statements… they end up never really getting it because they inevitably fall back on their old imperative ways. When I was taught functional programming at Carnegie Mellon, it was mandated that we use Standard ML without any assignment statements (i.e. no references). I was completely lost for the first couple weeks, but after a certain point, it clicked — and from then on, I have been thinking functionally ever since.

So if you want to change how you think about something, in the long-run it’s hard to change a little; it’s much easier to change a lot.

27 notes

  1. hellobeastie reblogged this from plpatterns and added:
    don’t quite understand,...very good idea. Reminds...Malcolm...
  2. emkaybee reblogged this from plpatterns
  3. gurls-assylum reblogged this from plpatterns and added:
    Interesting premise here…Might have...it works. plpatterns:
  4. notational reblogged this from 1000reasonsnottostartmakingart and added:
    The most powerful changes are systemic.
  5. 1000reasonsnottostartmakingart reblogged this from ronenreblogs and added:
    Mmh, not sure I needed this. Rings true though.
  6. michaeltapp reblogged this from ronenreblogs and added:
    This actually makes sense to me.
  7. thadeej reblogged this from ronenreblogs
  8. bradofarrell reblogged this from ronenreblogs
  9. noahkai reblogged this from ronenreblogs and added:
    like when stella got her groove back?
  10. ronenreblogs reblogged this from plpatterns
  11. jonnytran reblogged this from plpatterns
  12. plpatterns posted this
blog comments powered by Disqus