selfdogfood

From IndieWeb
(Redirected from selfkoolaid)
Jump to: navigation, search

selfdogfood is the act of using your own creations and depending on them personally yourself, beyond just self-testing or dogfooding a work project; on the IndieWeb, it means using your creations on your personal site as an aspect of your primary online identity, day to day.

Build what you need. Use what you build.John Seely Brown quoted at eLearning 2015[1]
Metaphorically speaking, a person's ideas must be the building he lives in - otherwise there is something terribly wrong. SĂžren Kierkegaard, introduction to Provocations

Why

Get started faster. What do you really need? Selfdogfooding helps you better understand what you really need rather than just what you think you need.

  • By building what you need, it constrains what you think you need with the practical limits of time, ability, and cost, thus forcing you to come up with a more efficient design than you likely thought you needed originally.

Prioritization. Fix more important problems first. Selfdogfooding helps you empathize as a user and fix the important problems first.

  • By using what you build, you see and feel the impact of problems in what you have built, and in particular feel the difference between minor problems and major problems, thus helping you prioritize fixing the more important problems.

Faster iteration. Fix the more important problems faster. Selfdogfooding helps motivate you to fix the important problems faster.

  • By using what you build as your personal identity on the public web, when there are visible problems, you will feel self-conscious about it, and strongly motivated to fix them quickly.

If you don't build it, you're just talking theory.

  • If you design/architect etc. without building, you'll likely come up with ever higher level abstractions, AKA the architecture astronomy anti-pattern. That being said, it's helpful to publicly brainstorm what you're thinking of building because others can review, provide feedback, help you simplify, etc.

If not you, then who? [should bother using your stuff]

  • If you're not willing to use your creation on your own primary personal website, why should anyone else use it on their primary personal website?

Creations tend to break (stay broken), when their creators don't use them.

  • In general it is a good idea to use code that the author is using themselves. Those are less likely to be broken.
  • ...

How to

Selfdogfooding has several required components, one of which is dogfooding, but the other is the essential self part of selfdogfooding:

  1. dogfooding
    • active creation - whether code, UX, interactive/visual/graphic design, being an active creator
    • use of what you create (e.g. by your company, on your company's site, your club's site, etc.)
  2. self - what you must do above and beyond dogfooding, to be selfdogfooding
    • personal - use of that creation - you yourself personally using your creation for your own personal uses - it's not (just) a job use (i.e. that you can shut off when you go home), it's a personal use.
    • identity - use of that creation in what you identify as your self. The act of creation alters an aspect of the public "self" of the creator. On the web, this means use of that creation actively on your personal website that you primarily use to identify yourself to others. I.e. not on a test site, nor a hobby site, nor an occasional use site, but your primary personal site and thus as part of your primary identity on the web.

IndieWeb Examples

In rough order of when IndieWeb community members started selfdogfooding at least some part of what they build, using their own primary web identity presence with their own domain.

Tantek

Tantek Çelik selfdogfoods his personal publishing software Falcon, including its open source functions in CASSIS live on his own site tantek.com since 2010-01-01.

  • He often deploys and tests CASSIS updates on his own site as a final live test before committing them to the cassis github repo, figuring if its going to break in production, he'd rather it break first on his site, than someone else's site who is depending on CASSIS.

Kartik Prabhu

Kartik Prabhu selfdogfoods his website code Bundle on his site kartikprabhu.com since sometime in 2013

Dmitri Shuralyov

Dmitri Shuralyov selfdogfoods his issue tracker on his personal website. He uses it as the canonical issue tracker for the issue tracker itself, as well as to drive his blog (source), and a list of idiomatic Go suggestions (source).

He also selfdogfoods his notification tracker, using it on his personal site to read all his notifications. Notifications come from GitHub and additional sources.

  • add yourself...

Criticism

For criticism of the term "selfdogfood", especially with respect to "dog" or "dogfood", see:

Limitations

  • Beware of this trap: "only the people who wrote it can reliably use it" that OpenID fell into per twitter.com/elforesto/status/976177015958261762

FAQ

Use and development

Are there two dimensions to selfdogfooding: use and development?

A: There are many required aspects of selfdogfooding, use and development only two of them.

Content updates but no commits

Would a site that is regularly updated with posts but not have commits for a while qualify as selfdogfooding?

A: At some point if there are no creative (code, UX, design) commits by the self-identified primary user of said site, then they've shifted from dogfooding (which requires a creation/use feedback loop) to simply being a user. No, eventually, after "a while", that should not be considered selfdogfooding.

Unverifiable commits

What about sites that are running non-open-source software (no way to directly verify commits)?

A: Even web sites running software that is either little or not at all open sourced can still be analyzed for what features they use in terms of :

  • outward visual appearance and user interface
  • external notifications (e.g. PuSH and webmention behaviors)

Thus even if specific code commits are not transparently visible, there are plenty of other direct and indirect sources of evidence for creative (code, UX, design) changes, and thus the create/use pairing can still be verified to some extent.

silos do it too

CaUkTFuUcAEDcim.png
@benward: Great moments in [Twitter] code review

Brainstorming

It has come up in discussion several times that a more appealing term should be used.

Goal: Let’s continue to garden this page, documenting criticism/limitations, and hopefully we can get it sufficiently cleaned-up to then get a consensus from the community about a replacement from the below choices, then switch/move page and note "selfdogfood" as historical.

No consensus has been reached yet. Please add your opinion/reaction to the below options, and/or additional options you prefer.

Please add IRC links and summarize discussion...

eat your cooking

As discussed: https://chat.indieweb.org/meta/2019-02-05, related suggestions:

  • eating what you make
  • Cooking your Own Dinner
  • eating our own cooking - From: https://en.wikipedia.org/wiki/Eating_your_own_dog_food#Alternative_terms:
    Developers of IBM's mainframe operating systems have long used the term "eating our own cooking".
  • eat your cooking
    • +1 Tantek Çelik nice parallel structure with "own your data". And the noun for the actual practice could be eating your cooking ("your own" seems redundant). How do you "verb" this without a pronoun?
      • We can replace wiki usage of "selfdogfooding" as an adjective (e.g. on project pages listing the author as an IndieWeb Example) with "eating her own cooking" / "eating his own cooking"
    • +1 Eddie Hinkle: this is nice because it doesn’t use specific food or drink. A challenge is the length, there is no way to really shorten it. But it is simple which means it should be easy to remember.
    • +0 Aaron Parecki sounds a little funny to me but I like the sentiment
    • -0.5 gRegor Morrill sounds funny to me too
    • +0 Marty McGuire has a "eat your vegetables" ring for me.
  • eat what you cook
    • +1 Kevin Marks: monosyllables are more emphatic. we'll need to update the dogfood + self explanation above
    • +1 Jeremy Cherfas I like this version too.
    • +1 Tantek Çelik I like this as an emphatic call to action. Would still want a noun for the actual practice, e.g. eating what you cook, and a verb that can be inged (but can't think of one).
    • +1 Aaron Parecki I like this version best
    • +0 gRegor Morrill I'm not totally sold on the food/cooking options, but out of them I like this one best
    • Michael Bishop the reality is when you cook for a living, you rarely eat what you cook. I'd go as far as to say historically even in the home the main food maker rarely eats everything they cook. Also feels very close to the "eat what you kill" idiom
    • +1 Jacky AlcinĂ© Personally, this aligns with me more. Also in the realm of consumption of content, it makes sense; we should be the ones creating and at least sampling what we put out there.
    • +1 Marty McGuire Agree w/ the folks who voted for this one before. Quite like it!

use what you create

gRegor Morrill: The more I think about it, I'm wondering if we actually need a metaphor. It feels like an unnecessary abstraction. The current definition isn't too long - "use your own creations and depend on them yourself" - and I think "use what you create" works as a reasonable shorthand.

  • Advantage: no metaphor needed, directly conveys the principle

Opinions:

  • +1 Tantek Çelik - this is worth considering in the running. It may not be as emotionally compelling as "eat your cooking" or "eat what you cook" yet it may be more effective in reaching some broader audiences.
  • +1 gRegor Morrill in addition to my initial thoughts, this is easier to translate to other languages. Currently I like the create/build/make variants of this equally.
  • ...

use what you build

Similarly, Cathie LeBlanc has proposed in her 2019 article An Alternative to the Corporate Web:

Build what you need, use what you build

In the context of different which has a point on "Selfdogfood" which also references "Scratch your own itch".

Opinions:

use what you make

On her home page, Cathie uses the variant "Use what you make" as a deliberate summary replacement for "selfdogfood", which has explicity been the summary of this in our principles since the revision as of 2017-09-24.

Opinions:

walk your talk

Ben WerdmĂŒller: this is often used in non-product circles. It's defined as "you should do what you tell other people to do". In a software development context, this can easily be extended to mean "you should use what you create".

  • +0 Tantek Çelik While I appreciate this sentiment I think something like this "create what you suggest" is a distinct principle IMO that can be used before "use what you create".

Rejected Alternatives

Alternatives to "selfdogfood" that have been discussed and sufficiently rejected to not bother considering as an actual replacement.

If you would like to one of these reconsidered, please start a discussion about it in the meta discussion channel.

use your own product

  • http://indiewebcamp.com/irc/2014-06-09#t1402337824
    • gRegor Morrill likes the simple phrase "use your own product" or UYOP if an acronym is preferred. It's simple and to the point.
    • -0 Tantek Çelik: It's better than "selfdogfood" but it's also just vague enough to fail to capture the making/creating aspect, e.g. even "user your own creations" would better capture that. Also "product" feels a bit too corporate rather than indie.
    • -0 gRegor Morrill this is really old at this point and was probably more off-the-cuff comment at the time. Agreed on "product" now, and wondering how necessary a metaphor is.
    • -0 Aaron Parecki agreed, too vague
    • -1 Chris Aldrich also reminiscent of the drug culture phase (with negative connotations) of "don't get high on your own supply"

drinking our own champagne

From: https://en.wikipedia.org/wiki/Eating_your_own_dog_food#Alternative_terms

  • Drinking your own champagne, or self-champagneing
    • or just champagneing; doesn't need distinguish it from a preexisting term
    • Eddie Hinkle: this seems potentially appealing because it touches on the food/drink area but can easily be shortened with “champagneing”.
    • -1 Jeremy Cherfas If we're going to be sensitive about how some people respond to dog, should we not also be aware that there are those who respond badly to being encouraged to drink alcohol?
    • Kevin Marks: There's a nice connection with Homebrew Website Club, but drinking our own beer may make this even more confusing with actual brewing clubs.
      • It also sounds like a euphemism for drinking your own urine.
      • Tantek Çelik: drink your brew (could be tea, coffee, kombucha etc.) would be more inclusive, yet may still have the problem mentioned above.
    • -1 Tantek Çelik: I personally like occasional champagne, however this feel exclusionary and/or triggering of anyone who is a recovering alcoholic. Also as Jeremy Cherfas says, it implies an encouragement to drink alcohol which is widely seen (lots of articles) as a negative aspect of many tech/OSS subcultures. "self-champagneing" sounds like it could mean pouring champagne over yourself and making a mess.
    • -1 Aaron Parecki: while I am definitely a fan of champagne, I agree that it's not inclusive
    • -1 Ben WerdmĂŒller: lots of people don't drink for all kinds of personal reasons. I definitely wouldn't want to accidentally exclude devoutly muslim developers, for example. Alcohol-based metaphors (along with alcohol-based events) should probably be avoided.

self-kool-aiding

Lightsaber

In the Star Wars mythology about lightsabers, you (a Jedi) have *only* one, that you are expected to have *built* it *yourself*, and that you *depend* on as an extension of your *self*.

Contrasting examples:

  • dogfood: In Ep1, Anakin is merely dogfooding C3P0, which he built to also help his mom. Even though he cares about it, C3P0 is not part of Anakin. No aspect of identity/self.
  • selfdogfood: In RoJ, Luke is selfdogfooding his own lightsaber that he made. It's his only lightsaber, he made it, he depends on it as an extension of himself.
  • Eddie Hinkle: this is fun but too niche.
  • -0 Tantek Çelik agreed. I like this analogy a lot, however it is both a bit dated, and a bit too insidery. Could be good as a blog post anecdote/analogy for explaining the concept though.

Pull yourself up by your own bootstraps


Perspectives

  • "Is its creator living and breathing it in his day-to-day online life? If so, awesome, if not, yawn." - Tantek 2013-01-03 11:05 (PST) (originally posted as a comment on a Google+ post).
  • "any web server software that isn't actively selfdogfooded by its creators on their own personal domains is fragile and should not be trusted. and if web software creators themselves don't have a personal domain they use on the web then the web software is categorically untrustworthy." (speaking to the unfortunate demise of Open Photo, e.g. on Barnaby's site, and the screenshots on there that he'd linked to from patterns/note-list#Documented_Examples & patterns/note#Documented_Examples) Tantek Çelik 2014-05-12 in IRC
  • If I make software for [someone else], am I ever going to rely on it? Unlikely
    If I make software which solves my own problems in a useful way, might others find it useful? Much more likely. - Barnaby Walters (2013-08-21 in iRC)
  • I have a higher tolerance for my own stupidly designed interfaces than [another person] would, but at some point I'm going to get frustrated by inefficiencies in my interface and make it better for me, which then makes it better for everyone. - Aaron Parecki (2013-08-21 in IRC)
  • "Another shift happened a few years ago, when I decided it was okay to develop just for myself, with no intention of ever releasing the stuff I was working on. That led to a new style of product, and a happier developer. I was always doing it for myself, and fooling myself into believing it was for other people. I'm no less a narcissist than anyone else. Once you own that, you get a lot more powerful I have found. 🚀" - Dave Winer on 2017-08-07
  • ...

testing your code in production

5616559901_8ca0186c11_z.jpg

Whilst testing your code in production is a good part of selfdogfooding, security precautions should still be taken. Showing errors, warnings and notices usually reserved for dev environments is a huge security risk due to the fact that things like paths, usernames, secret keys, etc. might be inadvertently shown to anyone who cares to look. It’s also not a great idea to have confusing error messages intermingled with content.

Rather, you should log all such messages somewhere where only you can see them, or only show them in-page if you’re logged in as an admin.

In PHP, there are several ways to go about this.

  • Setting display_errors off in your php.ini
  • Within PHP: ini_set('display_errors', 'off');
  • For a single line: @codeWhichIsCausingErrors();
  • If you’re logged in as an admin: 
    if ($user->isAdmin()) ini_set('display_errors', 'on');

Examples:

See Also

Retrieved from "https://indieweb.org/wiki/index.php?title=selfdogfood&oldid=71463"