are digital gardens blogs
This commit is contained in:
parent
5721cb1a51
commit
7d533545aa
|
|
@ -1,40 +1,33 @@
|
|||
---
|
||||
title: "Hi, I’m Wouter Groeneveld"
|
||||
subtitle: "And I'm currently a level 35 multiclass ..."
|
||||
subtitle: ""
|
||||
bigimg: About Me.jpg
|
||||
accent: purple
|
||||
disableComments: true
|
||||
---
|
||||
|
||||
## ... Baker
|
||||
And I'm currently a level {{< lvl >}} multiclass ...
|
||||
|
||||
* I hold a [professional bread baker's degree](/post/learning-to-become-a-baker/) so naturally I love to think of myself as a real baker. I highly respect the craft and enjoy kneading dough with my hands.
|
||||
* I specialize in _sourdough bread_, as you can read at my [bread baking blog](https://redzuurdesem.be). I love to rekindle the interest in sourdough by organizing workshops.
|
||||
* I've written a book on [the science of sourdough bread](https://redzuurdesem.be/het-boek).
|
||||
### ... Baker
|
||||
|
||||
## ... Researcher
|
||||
I hold a professional bread baker's degree so naturally I love to think of myself as a real baker. I highly respect the craft and enjoy kneading dough with my hands. I specialize in _sourdough bread_, as you can read at my [bread baking blog](https://redzuurdesem.be). I've written a book on [the science of sourdough bread](https://redzuurdesem.be/het-boek) (in Dutch).
|
||||
|
||||
* I am a PhD researcher at the [Faculty of Engineering Technology](https://iiw.kuleuven.be/english), KU Leuven.
|
||||
* My academic research focuses on identifying and amplifying non-technical skills in software engineering education, primarily targetting _creative problem solving_.
|
||||
* I mainly employ qualitative methods and prefer to mix disciplines such as computing education, cognitive psychology, and architecture.
|
||||
### ... Researcher
|
||||
|
||||
## ... Programmer
|
||||
I am a PhD researcher at the Faculty of Engineering Technology, KU Leuven. My academic research focuses on identifying and amplifying non-technical skills in software engineering education, primarily targetting _creative problem solving_. I sometimes [blog about my work](/tags/phd).
|
||||
|
||||
- I'm an experienced software engineer and took on various roles from agile coaching to technical lead. I hold a Master of Computer Science from [Hasselt Univeristy](https://www.uhasselt.be/edm). Take a look at my [<svg class='icon'><use xlink:href='#github'></use></svg>Github account](https://github.com/wgroeneveld).
|
||||
- I’m a heavy Test Driven Development fan and I bark at those who don’t. I taught agile software engineering techniques in both industry and academia.
|
||||
- I dislike specializing in one particular programming language: the more there is to learn, the better, although I prefer dynamic languages.
|
||||
### ... Programmer
|
||||
|
||||
I'm an experienced software engineer and took on various roles from agile coaching to technical lead. I hold a Master of Computer Science. I also dabble in open source through my [<svg class='icon'><use xlink:href='#github'></use></svg>Github](https://github.com/wgroeneveld) account. I’m a big Test Driven Development advocate. I teach software engineering techniques in both industry and academia.
|
||||
|
||||
|
||||
## ... Writer
|
||||
### ... Writer
|
||||
|
||||
* I'm a [fountain pen addict](/post/fountain-pens-first-look/) and avid [<svg class='icon icon-text'><use xlink:href='#book'></use></svg>journaler](/post/journaling-in-practice/). I love jotting down stuff.
|
||||
* [This blog](/post) is the ideal place to write down my _freshly baked thoughts_ about virtually anything, primarily intended to amuse myself, and hopefully also others.
|
||||
* Oh, and as said, I've published a book on [the science of sourdough bread](https://redzuurdesem.be/het-boek) and occasionally take part in [National Novel Writing Months](https://nanowrimo.org) - with varying results.
|
||||
I like fountain pens and [<svg class='icon icon-text'><use xlink:href='#book'></use></svg>journaling](/tags/journaling/). I love jotting down stuff and possibly converting that into blog posts, academic articles, books, or any other medium where I can express my enthusiasm.
|
||||
|
||||
## ... Teacher
|
||||
### ... Teacher
|
||||
|
||||
* Transforming knowledge into well-digestible material is my mission. As they say: _the best way to learn something is to teach it_ - I couldn't agree more.
|
||||
* Besides various formal teaching assignments at KU Leuven, I've also coached software developers in different companies, and occasionally organize bread baking workshops.
|
||||
Transforming knowledge into well-digestible material is my mission. As they say: _the best way to learn something is to teach it_ - I couldn't agree more. Besides various formal teaching assignments at KU Leuven, I've also coached software developers in different companies, and occasionally organize bread baking workshops.
|
||||
|
||||
---
|
||||
|
||||
|
|
|
|||
|
|
@ -224,9 +224,9 @@ Dat wil zeggen dat wanneer je twee keer x probeert toe te kennen aan een getal
|
|||
|
||||
!! Uitzondering: een formeel argument met naam `arguments` heeft voorrang op lang-defined `arguments`. Bad practice...
|
||||
|
||||
##### Itereren over properties van objecten #####
|
||||
##### Itereren over properties van objecten
|
||||
|
||||
Vergeet niet dat in Javascript alle objecten (zowel object literals als instanties van functies) zich gedragen als een {{< wp "Associative array" >}} - en dat we dus ook kunnen lopen over alle keys:
|
||||
Vergeet niet dat in Javascript alle objecten (zowel object literals als instanties van functies) zich gedragen als een Associative array - en dat we dus ook kunnen lopen over alle keys:
|
||||
|
||||
```javascript
|
||||
var N = { one: 1, two: 2 };
|
||||
|
|
@ -270,13 +270,13 @@ f(1, 2) // == 3
|
|||
|
||||
Indien er geen argumenten gespecifiëerd zijn, zijn ze allemaal *optioneel*! Dit wil zeggen dat een functie aangeroepen kan worden zonder het aantal argumenten 100% te laten overeen komen.
|
||||
|
||||
###### anonymus functions en recursie ######
|
||||
###### anonymus functions en recursie
|
||||
|
||||
`arguuments` heeft nog een speciale property: `arguments.callee(...)` dat de huidige functie voorstelt, hiermee kan je jezelf aanroepen!
|
||||
|
||||
!! Dit gaat een syntax error geven bij ECMA Script standaard 5 in *strict* mode
|
||||
|
||||
###### verplicht alle argumenten invullen ######
|
||||
###### verplicht alle argumenten invullen
|
||||
|
||||
```javascript
|
||||
function f(x, y, z) {
|
||||
|
|
@ -289,7 +289,7 @@ f(1, 2) // == 3
|
|||
|
||||
Het is natuurlijk makkelijker om `!= 3` hardcoded te plaatsen, maar dit kan extracted worden naar een aparte functie.
|
||||
|
||||
###### Function overloading ######
|
||||
###### Function overloading
|
||||
|
||||
Overloading bestaat niet in JS aangezien de tweede definitie van de functie de eerste overschrijft (de property "functienaam" in het object, zeg maar). <br/><br/>
|
||||
Het is wel mogelijk om één functie te maken die delegeert, zie http://ejohn.org/blog/javascript-method-overloading/
|
||||
|
|
@ -447,7 +447,7 @@ Pitfalls:
|
|||
|
||||
De assertion functiepointers die meegegeven worden met `runs()` worden intern opgeslaan en bijgehouden totdat de closure van `waitsFor()` `true` retourneert. Daarna wordt ook alles pas meegegeven met de Jasmine reporter (logging, output etc). Redelijk omslachtig, aangezien 3+ async calls dan `waitsFor()` moeten wrappen. Geen oplossing.
|
||||
|
||||
##### Asynchroon testen met QUnit #####
|
||||
##### Asynchroon testen met QUnit
|
||||
|
||||
```javascript
|
||||
asyncTest("should be green, right??", function() {
|
||||
|
|
@ -468,7 +468,7 @@ Pitfalls:
|
|||
* Ge moet een speciale test method gebruiken, `asyncTest()`
|
||||
* Ge moet na uw assertions `start()` aanroepen (??)
|
||||
|
||||
##### De oplossing #####
|
||||
##### De oplossing
|
||||
|
||||
https://github.com/willconant/flow-js e.a. (of iets zelfgemaakt in die aard).
|
||||
|
||||
|
|
@ -503,7 +503,7 @@ Pitfalls:
|
|||
|
||||
flow.js geeft het resultaat van closure1 mee als argument aan closure2 (via `arguments`) en zo maar door, dat is mega handig.
|
||||
|
||||
##### Synchrone code code combineren met asynchrone in flow.js #####
|
||||
##### Synchrone code code combineren met asynchrone in flow.js
|
||||
|
||||
Enige minpunt is dat de callback `this()` moet expliciet aangeroepen worden om van closureX naar closureY over te stappen! <br/><br/>
|
||||
Los dit op met een utility functie:
|
||||
|
|
@ -532,11 +532,11 @@ flow.exec(
|
|||
);
|
||||
```
|
||||
|
||||
##### In een asynchrone closure parallel werken #####
|
||||
##### In een asynchrone closure parallel werken
|
||||
|
||||
Gebruik `this.MULTI()` als callback ipv `this` (zie voorbeeld hieronder)
|
||||
|
||||
##### flow.js combineren met Jasmine #####
|
||||
##### flow.js combineren met Jasmine
|
||||
|
||||
Om de smeerlapperij van `waitsFor()` weg te werken kunnen we ook `flow.exec` gebruiken.
|
||||
|
||||
|
|
@ -597,7 +597,7 @@ describe("plaatsen domein", function() {
|
|||
|
||||
Merk op dat de closure meegeven in `then()` (slechts 1 mogelijk voor assertions) als **argument** het resultaat van de laatste closure in `when()` meekrijgt!
|
||||
|
||||
##### jQuery 1.6: Deferred en piping #####
|
||||
##### jQuery 1.6: Deferred en piping
|
||||
|
||||
Vanaf **jQuery 1.6** is het mogelijk om met `$.Deferred` te werken, dat het mogelijk maakt om een closure uit te voeren op het moment dat "werk" gedaan is. Met werk bedoelen we:
|
||||
|
||||
|
|
@ -605,7 +605,7 @@ Vanaf **jQuery 1.6** is het mogelijk om met `$.Deferred` te werken, dat het moge
|
|||
2. http: `.ajax` ea
|
||||
3. custom code die zelf een `$.Deferred` object retourneren
|
||||
|
||||
##### Promising stuff #####
|
||||
##### Promising stuff
|
||||
|
||||
Alle async operaties worden aan een *queue* toegevoegd van het jQuery element zelf. Je kan op eender welk moment vragen aan dat queue object, dat wanneer alle items zijn verwerkt er iets speciaals uigevoerd wordt:
|
||||
|
||||
|
|
@ -617,7 +617,7 @@ $('#blink').fadeOut().promise().done(function() {
|
|||
|
||||
Dit kan dus ook met `$.ajax`.
|
||||
|
||||
##### Zelf Deferred code schrijven #####
|
||||
##### Zelf Deferred code schrijven
|
||||
|
||||
Maak een deferred object aan door `$.Deferred()` aan te roepen. Op dat moment kan je `done()` hierop zoals in het vorige voorbeeld aanroepen. Bijvoorbeeld:
|
||||
|
||||
|
|
@ -637,7 +637,7 @@ startStuff().done(function() {
|
|||
});
|
||||
```
|
||||
|
||||
##### Multiple elements in queue: piping #####
|
||||
##### Multiple elements in queue: piping
|
||||
|
||||
Stel dat eerst element #1 animatie triggert, dan #2, en daarna nog logica dient te gebeuren. Dit kan ook met `$.Deferred`, door `.pipe()` te gebruiken om verder te breiden aan de queue.
|
||||
|
||||
|
|
@ -706,7 +706,7 @@ Eender welke functie heeft een `prototype`. Een "lege" functie bevat een dynamis
|
|||
(function(){}).prototype
|
||||
```
|
||||
|
||||
##### Gewenst gedrag - wat waar plaatsen #####
|
||||
##### Gewenst gedrag - wat waar plaatsen
|
||||
|
||||
* Indien ik een functie of een variabele heb die anders kan zijn naargelang de implementatie (definiëer de "naamgeving"), plaats deze dan in de **constructor** functie.
|
||||
* Indien ik een functie of een variabele heb die specifiek voor die functie is en niet gaat veranderen, plaats deze dan **in het concreet object** via `this.`.
|
||||
|
|
@ -714,7 +714,7 @@ Eender welke functie heeft een `prototype`. Een "lege" functie bevat een dynamis
|
|||
|
||||
Typisch bevatten constructor functies ook *geen* return waarden ((dit retourneert dus impliciet `undefined`)) - we gebruiken deze functies toch altijd in combinatie met de `new` operator, dus kennen de nieuwe instantie van het object direct toe aan een variabele.
|
||||
|
||||
##### prototype gebruiken als inheritance #####
|
||||
##### prototype gebruiken als inheritance
|
||||
|
||||
-> Meer informatie inclusief grafen met uitgebreide uitleg hoe prototype en constructors werken: zie http://joost.zeekat.nl/constructors-considered-mildly-confusing.html
|
||||
|
||||
|
|
@ -773,7 +773,7 @@ dier.aantalPoten = 2;
|
|||
new Ezel().aantalPoten ###### 4; // false
|
||||
```
|
||||
|
||||
##### Properties overriden #####
|
||||
##### Properties overriden
|
||||
|
||||
Prototypal inheritance werkt omdat JS bij elke property lookup kijkt in welk object die referentie gedefiniëerd is. Is dat het huidig object, neem dan die waarde. Indien neen, kijk in het `prototype` object. Indien neen, kijk in het `prototype` object van dat object, en zo maar door tot op `Object` niveau. We kunnen zo ook een property van een prototype zelf overriden, door ander gedrag te definiëren, of zelfs de super aan te roepen:
|
||||
|
||||
|
|
@ -787,7 +787,7 @@ Ezel.prototype.eetIets = function() {
|
|||
}
|
||||
```
|
||||
|
||||
##### Built-in JS types extenden #####
|
||||
##### Built-in JS types extenden
|
||||
|
||||
:exclamation: Extend **nooit** `Object.prototype`! Waarom? Omdat Eender welk object een instantie van `Object` is, dus zijn prototype heeft, en met een `for(x in prop)` deze property nu ineens toegankelijk is voor elk object. Een leeg object `{ }` wordt verwacht géén properties te hebben!
|
||||
|
||||
|
|
@ -798,7 +798,7 @@ for(x in {}) {
|
|||
}
|
||||
```
|
||||
|
||||
##### Checken op inheritance #####
|
||||
##### Checken op inheritance
|
||||
|
||||
Met Javascript kan men door middel van `typeof` controleren van welk type een variabele is. Dat komt neer op:
|
||||
|
||||
|
|
@ -815,9 +815,9 @@ ezeltje instanceof Ezel == true
|
|||
new Vierpotige() instanceof Ezel == false
|
||||
```
|
||||
|
||||
##### Zelf inheritance afchecken met prototype #####
|
||||
##### Zelf inheritance afchecken met prototype
|
||||
|
||||
###### met constructors ######
|
||||
###### met constructors
|
||||
|
||||
Dit is een zeer beperkte manier dat geen rekening houdt met "inheritance":
|
||||
|
||||
|
|
@ -831,7 +831,7 @@ instanceOf(Ezel, Vierpotige) // true
|
|||
|
||||
Aangezien elk object een `.constructor` property heeft die afgeleid werd vanuit de constructor functie die aangeroepen werd, kan men op deze manier een simpele check afwegen. Een praktischer voorbeeld is `(typeof (new Date()) ###### object) && (new Date().constructor ###### Date)`.
|
||||
|
||||
###### met __proto__ ######
|
||||
###### met __proto__
|
||||
|
||||
Het `instanceof` keyword kijkt natuurlijk naar de `prototype` properties van beide objecten om te controleren of object a van object b komt. Dit kan men ook zelf doen:
|
||||
|
||||
|
|
@ -854,11 +854,11 @@ De betere oplossing: **`isPrototypeOf()`**! Zie magic properties.
|
|||
|
||||
:exclamation: **`_ _proto_ _` is een __instance__ property, `.prototype` een constructor function property**
|
||||
|
||||
###### met properties ######
|
||||
###### met properties
|
||||
|
||||
Door `hasOwnProperty()` te gebruiken kan je nagaan of een property overgenomen is of niet. Vanaf JS 1.5.
|
||||
|
||||
##### call als inheritance #####
|
||||
##### call als inheritance
|
||||
|
||||
De klassieke inheritance structuur zoals in Java en C++ kan beter benaderd worden door `call` te gebruiken. Herbekijk onze ezels:
|
||||
|
||||
|
|
@ -883,7 +883,7 @@ ezeltje.eetIets(); // aha! outputs omnom
|
|||
|
||||
Door als eerste statement in de constructor functie van `Ezel` een `call` te plaatsen naar onze "parent", *kopiëren* we alle keys en values die daarin gedefiniëerd staan. In tegenstelling tot prototypal inheritance kost dit dus veel meer geheugengebruik, en is dit beperkter om uit te breiden. We linken eigenlijk impliciet twee functies aan elkaar door waarden over te nemen, maar iets aanpassen aan `Vierpotige` gaat de `Ezel` op geen ekele manier doen veranderen.
|
||||
|
||||
##### prototypal inheritance toepassen #####
|
||||
##### prototypal inheritance toepassen
|
||||
|
||||
In plaats van `new` overal te gebruiken zonder te weten wat hierachter ligt, kan men `create` ook gebruiken:
|
||||
|
||||
|
|
@ -900,7 +900,7 @@ newObject = Object.create(oldObject);
|
|||
|
||||
Zie http://javascript.crockford.com/prototypal.html
|
||||
|
||||
##### Een minder verbose manier om extra properties te definiëren #####
|
||||
##### Een minder verbose manier om extra properties te definiëren
|
||||
|
||||
Zie http://howtonode.org/prototypical-inheritance -
|
||||
|
||||
|
|
@ -918,7 +918,7 @@ Object.defineProperty(Object.prototype, "spawn", {value: function (props) {
|
|||
|
||||
Op die manier kan je `BaseObj.spawn({'extraProp': 'extraValue'});` gebruiken, zonder de relatieve verbose manier van extra properties te moeten gebuiken die `Object.create` [handhaaft](https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/create#Classical_inheritance_with_Object.create).
|
||||
|
||||
##### Prototype JS en Class.create #####
|
||||
##### Prototype JS en Class.create
|
||||
|
||||
Javascript frameworks proberen altijd inheritance makkelijker te maken voor klassieke OO developers door functies te modelleren als klassen. In [Prototype JS](http://www.prototypejs.org/api/class) kan men zoiets doen:
|
||||
|
||||
|
|
@ -1124,13 +1124,13 @@ function foo() {
|
|||
}
|
||||
```
|
||||
|
||||
##### Scope chain #####
|
||||
##### Scope chain
|
||||
|
||||
Elke JS Executie context heeft een **scope chain** toegekend. Dit is een lijst van objecten waar de interpreter door gaat om een variabele x op te kunnen zoeken (Dit proces heet *variable name resolution*). Men begint met de huidige context van de functie die opgeroepen wordt. Indien variabele x daar niet gedefiniëerd is, ga een scope hoger, en zo voort.
|
||||
|
||||
In *top-level* JS (op window scope) bevat de scope chain slechts één object, het "globaal" object. (`window`)
|
||||
|
||||
##### Event handler scope chain #####
|
||||
##### Event handler scope chain
|
||||
|
||||
Bij het uitvoeren van events in de DOM Tree zitten er buiten `window` nog enkele andere objecten op de scope chain: het object dat het event zelf triggerde. Het is dus mogelijk om rechtstreeks vanuit een `onclick` event van een `input` tag, een ander `form` element aan te spreken zonder dit eerst te resolven via de klassieke `getElementById()`:
|
||||
|
||||
|
|
@ -1187,7 +1187,7 @@ function Iets(e) {
|
|||
|
||||
```
|
||||
|
||||
##### Scope tijdelijk aanpassen #####
|
||||
##### Scope tijdelijk aanpassen
|
||||
|
||||
```javascript
|
||||
with(window.screen) {
|
||||
|
|
@ -1227,7 +1227,7 @@ Zodra we `this` gebruiken om members in een constructor functie te steken wordt
|
|||
Merk op dat we aan `privateMember` kunnen zonder `this` te gebruiken om naar iets te refereren. Dit komt omdat die members in de context van het object zitten.<br/><br/>
|
||||
Een probleem dat zich voordoet is dat de `this` pointer binnen private functions natuurlijk weer gereset wordt tot op `window` scope. Om dit op te lossen kunnen we een private variabele voorzien die refereert naar `this`, daarvoor dient `me`.
|
||||
|
||||
###### Private, Public en prototype functies ######
|
||||
###### Private, Public en prototype functies
|
||||
|
||||
Een **private** functie is een functie die in de constructor functie gedefiniëerd is als *member variabele*, en dus geldig is binnen de context van die functie. <br/><br/>
|
||||
Een **privileged** functie is een functie die in de constructor functie gedefiniëerd is met de *this accessor*. Deze functies kunnen private functies aanroepen omdat ze binnen de context van de constructor functie leven, en zijn ook aanroepbaar van buitenaf.<br/><br/>
|
||||
|
|
@ -1324,7 +1324,7 @@ new Ezel().balk.call(); // iaia met mijn 100 poten
|
|||
|
||||
Hoezo 100? `this` wordt dan `window`, de hoogst mogelijke scope, en daar is net toevallig ook een poten variabele op gedefiniëerd. Als dat niet zo was gaf dit als output "iaia met mijn undefined poten".
|
||||
|
||||
##### Impliciete unbound objecten #####
|
||||
##### Impliciete unbound objecten
|
||||
|
||||
Het vorige voorbeeld toont aan hoe je expliciet `this` kan "unbinden". Dit gebeurt ook regelmatig intern impliciet, bijvoorbeeld met `setTimeout` of met events zoals `blabla.onclick`. <br/><br/>
|
||||
De oplossing hiervoor is **closures** gebruiken. Bekijk dit voorbeeld:
|
||||
|
|
@ -1369,7 +1369,7 @@ function SomeClass() {
|
|||
new SomeClass().startLooping();
|
||||
```
|
||||
|
||||
##### loop closures #####
|
||||
##### loop closures
|
||||
|
||||
Een ander voorbeeld waar het mis kan gaan (ref. http://trephine.org/t/index.php?title=JavaScript_loop_closures !):
|
||||
|
||||
|
|
@ -1633,7 +1633,7 @@ console.log(obj[key1]); // ##### yo???
|
|||
|
||||
#####= arguments #####=
|
||||
|
||||
##### arguments on-the-fly veranderen #####
|
||||
##### arguments on-the-fly veranderen
|
||||
|
||||
Zonder `use strict` (ES5) kan je een binnenkomend argument ook toekennen aan een andere waarde. Hierdoor verandert de waarde van `arguments[0]`! De `arguments` lijst houdt dus een pointer bij naar de variabele die de value van het argument vasthoudt, en niet naar de value zelf. In strict mode wel. Voorbeeld:
|
||||
|
||||
|
|
@ -1645,7 +1645,7 @@ function bla(a) {
|
|||
bla(1); // 5, in strict mode 1
|
||||
```
|
||||
|
||||
##### arguments is geen array #####
|
||||
##### arguments is geen array
|
||||
|
||||
Snel "effe" lopen over alle argumentjes:
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@ categories:
|
|||
tags: ['braindump', 'learning', 'baking', 'bread' ]
|
||||
---
|
||||
|
||||
Originally posted on [Medium](https://medium.com/this-happened-to-me/learning-to-become-a-baker-99c0d2c3388a).
|
||||
|
||||
#### Addendum
|
||||
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ send -- "<br/>r"
|
|||
expect eof
|
||||
```
|
||||
|
||||
([bron](http://nixcraft.com/shell-scripting/4489-ssh-passing-unix-login-passwords-through-shell-scripts.html)) - voor meer uitleg zie {{< wp "Expect" >}} wiki.
|
||||
([bron](http://nixcraft.com/shell-scripting/4489-ssh-passing-unix-login-passwords-through-shell-scripts.html)) - voor meer uitleg zie Expect wiki.
|
||||
|
||||
### Synchronizing/backupping/file copying
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,49 @@
|
|||
---
|
||||
title: Are Digital Gardens Blogs?
|
||||
date: 2021-10-06T10:00:00+02:00
|
||||
categories:
|
||||
- journaling
|
||||
---
|
||||
|
||||
I've missed the latest IndieWeb popup gathering on [digital gardens and streams](https://indieweb.org/2021/Pop-ups/Gardens_and_Streams_II) (thanks [Frank](https://diggingthedigital.com/17204-2/) for bringing that up). Thankfully, they are intricate note-takers, and it always pays off to poke around in those. As avid journaler, the subject naturally appeals to me. In fact, you could say that _Brain Baking_ is my _digital garden_. Or is it?
|
||||
|
||||
First, what's a digital garden? Simply put, it is your (1) personal (2) online space to (3) write down notes and (4) connect them---as [Dennis Seidel](http://dennisseidel.de/digital-garden) defined it in his garden. Those four things are important:
|
||||
|
||||
1. _Personal_: These are your own private thoughts. But are they private? Once the community starts discussing digital gardens, they tend to want to share them. The rise of Roam and Obsidian made it easy to (self-)publish these, but even before that, people have been setting up wikis and blogs for the very same reason.
|
||||
2. _Online_: It's called a _digital_ garden for a reason.
|
||||
3. _Write down notes_: the collecting part.
|
||||
4. _Connect notes_: the value-creating part.
|
||||
|
||||
Collecting thoughts isn't exactly new. Cicero did it, Michelangelo did it, John Locke did it, Charles Darwin did it. Their methods do not differ much from modern digital gardeners. Or do they? Which of the above four things is essential? Only the last two are: find a way to write down your thoughts and go through them and manage to create novel insights.
|
||||
|
||||
### Why digital is overrated
|
||||
|
||||
Whether they are [codexes, memexes, or genexes](http://www.cs.umd.edu/hcil/trs/97-21/97-21.html): it all boils down to store knowledge outside of your brain and (regularly) reprocess them. I dare to say that technology, such as the World Wide Web that features linked documents, aren't all that compelling. I just as easily reference to other pages and books on the analog notes I write down. Sure, refactor and move tools greatly simplify structure, and digital text is easily searchable. But for every `[[linked]]` article you produce, clutter is introduced that is called syntax. Furthermore, a lot of people struggle with actually _tending_ to the garden: cutting branches, moving plants. The end result is usually a mess.
|
||||
|
||||
One of the biggest disadvantages of digital gardens, to me, is exactly the fact that it's structured. That is, articles---whether they are blog posts or wiki pages do not matter---are still mainly text-based. You can't quickly draw rectangles or arrows next to your notes. You can't draw an eukaryote and point to its nucleus to explain that that's where the DNA chromosome strings are coiled up (sorry, I've been doing some yeast cell research). You can't print photos or cut out parts from newspapers to paste it besides a schematic. You can't grab your watercolor paint and brighten up a page. You can't paste your cat's whisker in your notebook (for research purposes, of course!). You can't smear out a blueberry or wet tea leaf to try and capture its smell and color.
|
||||
|
||||
Another advantage that tends to be dismissed is (s)low tech: off-screen time. I already spend way too much time clutched behind a PC. I prefer to go through my notes on a bench in the park without the artificial light of an LCD screen. Speaking about benches: capturing fleeting thoughts only works if you hold on to your writing tools at all times. I hope you leave your technological trinkets outside the bedroom, but I suspect few of us do.
|
||||
|
||||
I've been using a combination of Sublime Text and Obsidian extensively for my PhD research, so don't get me wrong, I love digital editors and connectors. But compared to my fountain pen and my notebook, they severely hamper my thoughts. Of course, to get anything published, whether it is an academic paper or a blog article, you'll need to convert your thoughts to ASCII.
|
||||
|
||||
I do not refactor my analog notes. That's impossible unless you bring out the scissors. Instead, I rewrite things, cross things through, and reference to both previous pages and previous books a lot. To do that, I [digitize and annotate my journal pages](/post/2021/01/digitizing-journals-using-devonthink/). So _digital_ does help to _archive_, but it is far from the best way to assist my thinking.
|
||||
|
||||
### Why public is overrated
|
||||
|
||||
Public digital gardens are overrated. They are very hard to navigate. Time and time again, I get lost in the jungle of mystical links, in the _check-ins_ drowned in the _bookmarks_ and the _quotes_. Fancy IndieWeb sites that boast 5 separate RSS feeds to "help" navigate the labyrinth do not make it better. I've tried following multiple interesting people that pump loads and loads of seemingly cool looking stuff into their site. It always ends in confusion. Yes, sometimes I discover a link to another published article (external to the garden, by the way!) that is interesting. As admiring as the garden is, the things they grow there are almost always puzzling.
|
||||
|
||||
But the most important reason why I think they're not that useful to others, is exactly that: they're _personal_. That is, you'll have to make the translation between _their_ context and _your_ context. And that always and inevitably means important messages get lost in translation. It's fun to fool around in someone's garden, but if you have no clue what to do with tropical seeds in your own temperate climate powered garden, then don't bother.
|
||||
|
||||
Many famous journals were never meant to be published and have to be heavily edited to produce an interesting coherent text. Hilarious letters from [Madame de Sévigné](https://fr.wikipedia.org/wiki/Madame_de_S%C3%A9vign%C3%A9) or depressing ones from Vincent van Gogh are the exception, since they were written to be read by others, although not the general public.
|
||||
|
||||
### Digital Gardens or Blogs?
|
||||
|
||||
That is why I think that most digital gardens are not blogs. Again, there are exceptions, like some articles in [Tracy Durnell's](https://tracydurnell.com/2021/09/26/gardens-and-streams-ii/), but on average, digital gardens contain slices of context-heavy information processed by someone else's mind. Only after the translation into something publishable, like a blog post, they become interesting for others to read. I have little use for countless of "collected" links and likes. Published [Obisidan Vaults](https://obsidian.md/publish) look cool, but the initial excitement wears off pretty quickly.
|
||||
|
||||
Cory Doctorow has been calling his blog [his Outboard Brain](https://web.archive.org/web/20040616003452/http://www.oreillynet.com/pub/a/javascript/2002/01/01/cory.html) since 2002. _Outboard brain_, not _Second brain_. He must have had notes---either in his head, on paper, or digitally---before being able to put the message _out_ there. Quite a few people reach for Wordpress to build their digital garden nowadays, and although Wordpress is the de facto blogging tool, the result is all but a blog.
|
||||
|
||||
I much prefer others' blogs, in the classic sense of the word (let's ignore parasitic corporate blogs). These are interesting because they are coherent---or at least, should be. They are about others' passion for whatever that drives them. Which might spike my own interest. And then, perhaps, maybe, could end up in my own notebook.
|
||||
|
||||
With the help of a pen, of course.
|
||||
|
||||
|
||||
|
|
@ -0,0 +1 @@
|
|||
{{ .Site.Params.level }}
|
||||
|
|
@ -1 +0,0 @@
|
|||
<a href="https://en.wikipedia.org/wiki/{{ index .Params 0 }}" target="_blank">{{ index .Params 0 }}</a>
|
||||
Loading…
Reference in New Issue