Joe Duffy's Blog

  • July 13, 2013
  • Software Leadership #5: Blur the Line Between Research and Engineering
  • What I am about to say admittedly flies in the face of common wisdom. But I grow more convinced of it by the day. Put simply, there ought not to be a distinction between software research and software engineering.

  • April 12, 2013
  • Software Leadership #4: Slow Down to Speed Up
  • I am naturally drawn to teams that work at an insane pace. The momentum, and persistent drive to increase that momentum, generates amazing results. And it’s crazy fun.

  • April 11, 2013
  • InfoQ interview about safe concurrency
  • I mentioned a few months back that my team had collaborated with MSR to publish a paper to OOPSLA about some novel aspects of our programming language (see here and here).

  • March 16, 2013
  • Software Leadership #3: A Rising Tide Lifts All Boats
  • It’s really hard to build a great team. It can take years of hard work and an enormous amount of patience.

  • March 3, 2013
  • Software Leadership #2: Authority is an Illusion
  • The very notion of “authority” is 90% in your head. And it’s one that often holds back otherwise very capable people.

  • February 17, 2013
  • Software Leadership #1: Code Speaks; Love the Code
  • The best people in software have an innate ability to communicate using code. They have an idea and simply code it up, thereby making it reality. In fact, the best people are, I would say, obsessed with code.

  • February 17, 2013
  • Software Leadership series
  • I’ve been managing software teams for several years. Perhaps more importantly, I have worked for some excellent leaders and have had the opportunity to learn from their good (and bad) habits.

  • December 8, 2012
  • Imperative + Functional == :-)
  • I mentioned recently that a paper from my team appeared at OOPSLA in October:

  • October 30, 2012
  • Beware the string
  • .NET has a lovely property: it’s got a single string type.

  • October 28, 2012
  • Uniqueness and Reference Immutability for Safe Parallelism
  • A glimpse of some research we’ve done recently just appeared at OOPSLA last week:

  • November 12, 2011
  • A brief note on object mortality
  • I often wish that .NET had erred on the side of offering postmortem instead of premortem finalization.

  • October 23, 2011
  • On generics and (some of) the associated overheads
  • It’s been unbelievably long since I last blogged.

  • June 1, 2011
  • An interview with InfoQ
  • InfoQ recently asked me a few questions about concurrency and programming languages, and here is what I had to say:

  • December 4, 2010
  • Sayonara volatile
  • After spending more time than I’d like to admit over the years researching memory model literature (particularly Java’s terrific JMM and related publications), subsequently trying to “fix” the CLR memory model, reviewing proposals for new C++ memory models, and beating my head against the wall for months developing a new memory model that supports weakly ordered processors like the kind you’ll find on ARM in a developer-friendly yet power-efficient way, I have a conclusion to share.

  • October 31, 2010
  • Dense, and pointer-free
  • I rambled on and on a few weeks back about how much performance matters. Although I got a lot of contrary feedback, most of it had to do with my deliberately controversial title than the content of the article. I had intended to post a redux, but something more concise is on my mind lately.