23

I was watching a programming course ("Kotlin for Java Developers" on Coursera). The instructor of the training course said:

"We focused on the use cases we knew about from our everyday work and from what other people told us. This is one of the principles JetBrains runs on: we dog-food all the tools we create. So we use everything that's produced by JetBrains on an everyday basis in our development. And Kotlin was also dog-fooded a lot. We also integrated things from outside JetBrains to understand many more use cases."

I was wondering what is the meaning of "dog-food" here? I think it's about testing and using a tool or product before the releasing stage. Is that true?

Shayan Poursadeghi
  • 710
  • 4
  • 16

4 Answers4

48

The original phrase was "to eat your own dog food", with the meaning of "to use your own products (no matter how bad they might be) because it will help better the company or product itself." Over the years, it seems that phrase got lexicalized to simply "to dogfood."

Why was "dog food" chosen? I had always thought about it as, "like eating dog food, using your own product is something employees might not want to do." However, the usage of "dog food" is not that important to this metaphor.

This Wikipedia article discusses the complete history and etymology further.

As a real example from the Valley 25 years ago, Sun Microsystems's CEO Scott McNealy strongly believed in and liked the phrase "eating his own dog food" and forced even sales / back-office people to use Sun's office productivity suite. It was so terrible many people were forced to covertly use Microsoft Windows laptops, not Solaris workstations, to get their work done.

Glorfindel
  • 14,824
  • 15
  • 69
  • 76
davewp
  • 621
  • 4
  • 4
  • 1
    As an aside to this, a friend of mine used to deal with a major dog food manufacturer whose factory was over the road from a major tinned pie manufacturer, and he remembers the dog food quality control guys (whose job involved tasting the product) saying they were far happier eating their product than what was turned out in the factory over the road. – John U Jan 25 '22 at 17:41
15

First “dog food” has become an idiom, which means “use your own product”. This is not about using a pre-release version of your product, but using your product at all. Note that this only applies to certain types of product, you wouldn’t expect a company developing ag-software to be running a farm and so wouldn’t expect them to be dog fooding their software.

On the other hand I wouldn’t fly in a plane where the CEO of the aircraft manufacturer refused to fly in that model, or eat in a restaurant where the cook wouldn’t.

Jet Brains develops tools to make development faster and less error prone, requiring their team to use the pre-release version has several advantages: it helps them develop faster with less errors, and it helps them identify errors caused by unexpected situations.

jmoreno
  • 1,220
  • 6
  • 11
  • 2
    "has become an idiom among software developers," perhaps. – Azor Ahai -him- Jan 24 '22 at 23:11
  • Who else uses it? – Azor Ahai -him- Jan 24 '22 at 23:31
  • @AzorAhai-him-: Anyone that has heard of it. Consider https://www.avocadoaudio.com/post/the-power-of-dogfooding, the people talking might at one time have been software developers, but they are now running a business delivering audio content. Tech savvy is helpful, but developer skills are not required. – jmoreno Jan 24 '22 at 23:46
  • 1
    Haha, I'm not sure that's great evidence for "spreading beyond software developers." – Azor Ahai -him- Jan 24 '22 at 23:52
  • 1
    @AzorAhai-him-: https://tslmy.gitbook.io/k/other-tech-topics/questions-to-ask-the-engineers-before-dogfooding-a-hardware, developer but not talking in a software context, not read by developers. Also https://adue.engin.umich.edu/2021/01/28/dogfooding-xr-prototypes-in-the-time-of-corona/ – jmoreno Jan 24 '22 at 23:55
8

There is an idiom among programmers "eat the dog food". It means that you are using the software that you are developing as part of your normal suite of programmes used to develop software.

The metaphor seems to be that "dogfood" is the worst thing that is edible. Software that is dogfood is not good enough for release but it is usable.

It comes particularly from people writing web-browsers. If the developers were able to use the web-browser that they were developing for browsing the web (as part of their job, for example) they were "eating the dog-food". The idea is that developers who are using their own software will quickly learn what's missing or broken.

So by extension "to dog-food the tools" means "we use JetBrain as one of the tools we use to develop JetBrain", and so we know its strengths and weaknesses as users of the software and not just as developers.

James K
  • 217,650
  • 16
  • 258
  • 452
  • 11
    Your definition is right, but the reasoning is not. The metaphor is not that the food is bad, but that they run a factory making dog-food, so they should be the ones to eat it. – Daniel Roseman Jan 22 '22 at 11:30
  • I'm not sure how your comment differs from what I've written "dog food is bad, but edible. Software that is dogfood is not ready for release. You don't release dogfood (except perhaps as a beta, but not with a 1.0 badge). Your comment seems to be the same as mine, but if you feel you can edit my answer for clarity, please feel free to. And if you think my answer is wrong, please write your own. – James K Jan 22 '22 at 11:46
  • 6
    If you’re a dog food producer then you certainly do release dog food. If you eat it, then your customers can be assured that the product will be of high quality. – tim-phillips Jan 22 '22 at 20:41
  • 2
    You don't need to be using your own software to produce programs. If you write payroll software, and you use that software to do your own payroll it counts. And it comes from 1988, so it isn't primarily about using web browsers. – DJClayworth Jan 22 '22 at 20:43
  • 9
    As a student, I did spend some time in a dog food factory. The idiom is quite literal there - the product was made to normal food standards, and they were quite proud to have a tasting room open to all employees to verify the quality of what they were making. – Toby Speight Jan 23 '22 at 10:32
6

I always thought the term originated with a dog-food company whose manager advertised that its product was so good, he ate it himself. But there's a bit of a connotation that people in the company aren't using their own product because it stinks, and that's something that needs to change.

(50 years ago I did a vacation job in a Siemens electronics lab. They had two Tektronix oscilloscopes on the bench which they used all the time, and two Siemens oscilloscopes which sat in a corner unused. I was told it was company policy that at least half the equipment they purchased had to be Siemens-manufactured. The reason for the policy wasn't to save money on purchasing, it was to ensure that their own products were as good as the competition. On this occasion, the policy failed.)

It's an excellent principle for software developers because unless you use your own product, you don't experience the frustrations your users do, and you don't fix them. It's one of the reasons it has become commonplace for a compiler for language X to be written in language X. The principle probably long predates the use of the term "dog-food" to describe it.

Michael Kay
  • 1,387
  • 7
  • 7