1. 65

I’ve been extending and improving my personal wiki for 1 year now and it has been one of the best things I’ve done. I found writing blog posts was too high friction and very often didn’t finish things because there is so much you can talk about in any given article. But a wiki is just a living document containing your notes and thoughts on things. I also use it as my public bookmark manager as I collect interesting to me links under each topic.

For my wiki, I render everything to the web first with GitBook. And I have a macro I run that automatically commits any changes I’ve made with Sublime Text on the mac and Ulysses on the phone so everything is super easy to edit and publish.

Does anyone else keep their own wiki here? Or you think a blog is enough for you?

  1.  

  2. 13

    I’ve heard some people raving about tiddly wiki for this which seems like it has a lot of flexible interfaces. I don’t share my notes publicly as often, but I take tons of notes, and I almost always have this tui mind map that I wrote open in a tmux pane.

    1. 4

      Why don’t you share your notes publicly? I think there is so much value to be had if everyone shared their notes in public.

      1. 14

        I have a lot of personal info in there that I don’t need to share. But I am often thinking “I should be writing more for public consumption” and I also started making a gitbook, with sort of a long plan of turning it into a sort of “designing data intensive applications” but with an eye toward actually building the underlying infrastructure that supports data intensive applications. Sort of a missing guide for modern database and distributed systems implementation. But it’s been hard for me to overcome the friction of really building a durable habit of writing for others.

        1. 5

          That’s the cool thing about a wiki. You write the notes for yourself. Just share it with others.

          Would love to read your book. I’d release it gradually too as the topic of building the infrastructure for data intensive apps is vast.

          1. 2

            Not to discourage you from writing, because I do believe that there’s always room for new takes on a topic, but Martin Kleppman’s Designing Data-Intensive Applications may be of interest to you, if you haven’t seen it. I’m not sure that it goes into “underlying infrastructure”, as you’re thinking, though.

            1. 1

              I love that book! I want to do something similar but targeting people building infrastructure instead of the applications on top.

              1. 1

                Gotcha. That sounds useful, though I’d think less evergreen because the technology on which the infrastructure is built will keep changing.

                I’ve seen a lot about the virtues of event sourcing, but a lot less about how one implements event sourcing at different scales. Am I correct that’s the kind of thing you’d dig in to?

          2. 1

            No software I tried supported tagging things as public or private. So I am forced to make everything private.

            1. 1

              Cowyo is a wiki with public and private pages. Fairly straightforward codebase.

          3. 3

            @icefall This void reminds me a lot of maxthink, an old DOS personal organizer (http://maxthink.com) I’ll take a deep look, thanks for sharing.

            @nikivi, your gitbook is a prime. Very well crafted. I also try to keep notes on a similar structure but yours are way more strucutred.

            1. 1

              The simplicity that was TiddlyWiki has unfortunately been mostly lost in the name of security. It used to be a single file that you could open and edit, and everything would save automatically and transparently.

              Now you have to install a browser extension for it to save correctly, which makes TiddlyWiki much harder to transfer between browsers.

              Edit: I’m not taking sides on the security-functionality tradeoff, to forestall any off-topic discussion. However, TiddlyWiki has been along a looooong time (at least 10 years) now, and I assume that this would mean the Wiki portion of the software is superb.

            2. 8

              I keep text files. They’re a horrible mess. They work so long as I know which ones to search in.

              I want to write my own wiki-like software to manage the information, as soon as possible, so within a year or two. I have some specific requirements and won’t settle for anything less. Such as fully automatic infinite history of all edits, one-keypress-away incremental fulltext search, GUI, VIM controls, automatic link archival. It must have sub-100ms response times in general.

              It would be nice to have the search feature also use a thesaurus/related words, do translation dictionary lookups and recursive searches, and try some additional read-only sources like chat logs, the filesystem (mlocate.db) or DuckDuckGo. I want to share my cognitive load with the machine. It’s better at remembering and brute-force processing of huge amounts of data. I do patterns and fuzzy relations.

              1. 2

                I keep text files. They’re a horrible mess. They work so long as I know which ones to search in.

                I want to write my own wiki-like software to manage the information, as soon as possible, so within a year or two.

                I do the same thing with the same problem. Been thinking of various ways to fix that which don’t tie me to a complex app. I’m thinking of just a master copy/index or backup generated from an app people recommend. Essentially, I want it structured hierarchically and/or with tags in a way that I can export it to various formats that give benefits of many tools such as better search, presentation, and so on.

                Still in occasionally popping into and out of my mind stage for now. Except for my bookmarks and citations disappearing: I’ll deal with that soon since it’s gotten out of hand.

                1. 2

                  I am in your same position. I used to keep my writing in a private WordPress instance, but I wanted a way to ensure that my writing would exist for as long as possible. So I migrated everything to text files with TOML frontmatter as metadata.

                  Then I wanted something more useful and I am writing a tool to help me write and review things I’ve written. Right now it just views a structured directory of files, but I plan on more features, like indexing, searching, connecting related material. A personal wiki that is focused on being a private journal.

                  You can check it out here: https://github.com/ukiahsmith/north

                2. 7

                  I guess it depends on what you consider to be a wiki. I’ve got an org-mode knowledge base in ~/Notes that I treat like a wiki in the sense that I create in-line hyperlinks whenever the name of an “article” occurs in a sentence. It’s nice and structured to satisfy my obsession with everything being orderly, but in most situations I just use ag.el to find what I’m looking for.

                  1. 1

                    How do you add new stuff? Using captures, and if yes what’s your system? If not, what do you do?

                    I’ve been maintaining a “notes.org” file that consists of 90% stuff I looked up on the Internet when I needed it, in case I don’t have a connecting, and it’s basically just a list of headers. What I’m wondering is how to get started with a org-mode wiki.

                    1. 3

                      I’ll bite. My org usage has evolved, and what I describe will at best be the penultimate way of how i use it (i’m using penultimate ironically here, i’ve evolved my note usage so many times I can’t count).

                      What I do is use org like so (note, I use use-package heavily, adapt to fit, most of this crazy is me making things prettier):

                        (use-package org
                          :ensure org-plus-contrib
                          :bind (("C-c a" . org-agenda)
                                 ("C-c b" . org-iswitchb)
                                 ("C-c c" . org-capture)
                                 ("C-c l" . org-store-link)
                                 ("C-c p" . org-latex-export-to-pdf))
                         :config
                         (progn
                           (custom-set-variables
                            '(org-log-done t)
                            '(org-hide-leading-stars t)
                            '(org-hide-emphasis-markers t)
                            '(org-confirm-babel-evaluate nil)
                            '(org-capture-templates
                              '(("t" "Todo" entry (file+headline "~/src/bitbucket.org/mitchty/org/gtd.org" "Tasks")
                                 "* TODO %?\n  %i\n  %a")
                                ("n" "Note" entry (file+datetree "~/src/bitbucket.org/mitchty/org/notes.org")
                                 "* %?\nRandom Note entered on %U\n  %i\n  %a")
                                ("m" "Todo from email" entry (file+headline "~/src/bitbucket.org/mitchty/org/gtd.org" "INBOX")
                                 "* TODO %?, Link: %a")
                                ("u" "Url" entry (file+headline "~/src/bitbucket.org/mitchty/org/urls.org" "Urls")
                                 "* %u\n\n %i" :prepend t)
                                 ))
                            )
                      
                           ;; typing stuff like the mode for a snippet is for chumps
                           (add-to-list 'org-structure-template-alist '("el" "#+BEGIN_SRC emacs-lisp\n?\n#+END_SRC" ""))
                           (add-to-list 'org-structure-template-alist '("hs" "#+BEGIN_SRC haskell\n?\n#+END_SRC" ""))
                           (add-to-list 'org-structure-template-alist '("pl" "#+BEGIN_SRC perl\n?\n#+END_SRC" ""))
                           (add-to-list 'org-structure-template-alist '("py" "#+BEGIN_SRC python\n?\n#+END_SRC" ""))
                           (add-to-list 'org-structure-template-alist '("sh" "#+BEGIN_SRC sh\n?\n#+END_SRC" ""))
                      
                           (org-babel-do-load-languages 'org-babel-load-languages
                                                        (append org-babel-load-languages
                                                                '(
                                                                  (C . t)
                                                                  (plantuml . t)
                                                                  (ditaa . t)
                                                                  (emacs-lisp . t)
                                                                  (haskell . t)
                                                                  (latex . t)
                                                                  (perl . t)
                                                                  (python . t)
                                                                  (ruby  . t)
                                                                  (shell . t)
                                                                  )))
                           (add-hook 'after-init-hook (lambda () (org-reload)))
                           )
                         )
                        (use-package org-bullets
                          :after org
                          :init
                          (custom-set-variables '(org-bullets-bullet-list '("・" "◦" "•" "◉")))
                          :config
                          (progn
                            (add-hook 'org-mode-hook (lambda () (org-bullets-mode 1)))
                            (when window-system
                            (let* ((variable-tuple (cond ((x-list-fonts "Source Sans Pro") '(:font "Source Sans Pro"))
                                                         ((x-list-fonts "Lucida Grande")   '(:font "Lucida Grande"))
                                                         ((x-list-fonts "Verdana")         '(:font "Verdana"))
                                                         ((x-family-fonts "Sans Serif")    '(:family "Sans Serif"))
                                                         (nil (warn "Cannot find a Sans Serif Font."))))
                                   (base-font-color     (face-foreground 'default nil 'default))
                                   (headline           `(:inherit default :weight bold :foreground ,base-font-color)))
                              (custom-theme-set-faces 'user
                                                      `(org-level-8 ((t (,@headline ,@variable-tuple))))
                                                      `(org-level-7 ((t (,@headline ,@variable-tuple))))
                                                      `(org-level-6 ((t (,@headline ,@variable-tuple))))
                                                      `(org-level-5 ((t (,@headline ,@variable-tuple))))
                                                      `(org-level-4 ((t (,@headline ,@variable-tuple :height 1.1))))
                                                      `(org-level-3 ((t (,@headline ,@variable-tuple :height 1.25))))
                                                      `(org-level-2 ((t (,@headline ,@variable-tuple :height 1.5))))
                                                      `(org-level-1 ((t (,@headline ,@variable-tuple :height 1.75))))
                                                      `(org-document-title ((t (,@headline ,@variable-tuple :height 1.5 :underline nil)))))))
                            (font-lock-add-keywords 'org-mode
                                                    '(("^ +\\([-*]\\) "
                                                       (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "•"))))))
                            )
                          )
                        (use-package ox-reveal
                          :after org)
                        )
                      

                      I store that all in a private git repo I host on my own site. I keep work and home separated in general.

                      Then I just link to files (the captures let me link to where I was in a file when I took the note, aka say i’m reading some source and have a “is this variable unsigned int or not, doesn’t matter, can check later” moment I can quick capture that and refile that away later.

                      Basically, I just capture notes and move them around so the agenda deals with things later. Tag stuff as appropriate so it shows up in the agenda and move on with life. YMMV though, I’m only 4 years into my org journey, so still at the beginner stage.

                      1. 1

                        I add new material by going to wherever I feel it belongs and writing a few sentences. The notes system I have is a little bit more flushed out than a knowledge dump, since I use it as a medium for exercising the philosophy that “if you can’t explain it simply, you don’t understand it well enough.” I suppose I do indirectly use captures, as that’s my way of adding to my GTD inbox, but I spend time processing any facts I put in there - either condensing them into something coherent for my notes, or creating an org-drill card.

                        My system might not be the best starting point if you’re looking to make a wiki using org-mode, since it’s largely tailored towards satisfying my obsessiveness. If you have issues with a single “notes.org” file, I’d recommend writing them down and thinking about how you might design an organizational system that doesn’t have those issues. Alternatively, you could look into packages that do the organization for you (e.g. org-brain). Best of luck in finding something that works for you.

                    2. 6

                      An interesting collection of topics your notes cover: Weed, vegansim and functional programming.

                      Thanks for sharing these very personal notes.

                      I use news.arc (what HN is running on) for my personal “wiki”. I’m running my own fork where I’ve added a search engine because PG’s original Arc release didn’t include one. In terms of features it’s a bit limited (no proper markdown, etc), but I find it very easy to hack on, so it might catch up some day.

                      1. 6

                        https://github.com/zimbatm/wiki acts as a journal + wiki experiment.

                        The wiki is edited with vimwiki which makes it easy for me to jump into since vim is my main editor. I had to patch it a bit to align itself with GFM and Jekyll for web rendering. The main downside for me is that changes aren’t synced automatically with GitHub.

                        1. 1

                          That last bit is easily fixed with a touch of shell, maybe the ‘watchman’ tool.

                        2. 5

                          Wiki: https://wiki.lacto.se
                          Built with Sphinx: https://github.com/polyzen/wiki

                          The source will be moved to GitLab once I figure how to convert from Travis to GitLab CI. A number of projects and people use Sphinx for their wikis. I had started with Dokuwiki, and built up a fairly complex setup. It worked, but it lacked elegance. Eventually I switched to Gollum, and converted the rest to YAML files. This got me better acquainted with reStructuredText, but I disliked having to pepper in Gollum’s syntax – and the Gollum devs seem to have a dislike for rST. The project also seemed to die down quite a bit after GitHub decided to move their development to a private fork. Now I have the holy grail of wikis: Sphinx. I probably ought to make mine more inviting.

                          There’s another separate, private Sphinx repo for “notes”. Some pages at some point get “exported” to the wiki.

                          1. 2

                            “Why is it ‘the holy grail’,” you ask?

                            • Static-site builds, which you can host for free on something like GitLab pages

                            • Written in Python, and not PHP nor Ruby (not trying to disrespect)

                            • Supports CommonMark and reStructuredText (and I imagine more of the markup languages we love)

                            • Numerous plugins, of which I am only using a built-in so I can create links from my notes repo to my wiki

                            • You can screen changes through pull requests or you could setup some bot to automatically merge when tests pass

                            • Edit: With CI, you get automated builds, tests, and (eventually) deployment

                            1. 2

                              Zim ticks almost all your boxes!

                          2. 4

                            I used to use a Trac instance that I ported from MoinMoin (via my own scripts). It was heavily customized with better full text search. Now I just use a shell script that generates new notes files in a directory, adds some tags and then opens the result in VSCode. I miss a lot of features, but it is zero infra. I used NVAlt but drifted away from it over time.

                            I have a bunch of ideas for the Total Note/Memex but nothing really gels yet.

                            1. 4

                              I use org-mode for that. I tried all kinds of solutions, like GitBook, TiddlyWiki and what have you, but the thing that stuck were org-mode, possibly because it covers both as a wiki solution as well as a todo/task-manager, project-manager, invoicing manager, as well as much more, and does it better than anything else I’ve tried.

                              1. 1

                                Is it possible to have this online too like a wiki so that others can see, or is it a local-only solution?

                                1. 2

                                  It most certainly is!

                                  Org-mode is able to export everything in all kinds of imaginable ways. I often write my technical documents in org, including everything from latex to source code which org-mode automatically is able to handle. Via org-mode, I can write code in the document that creates a plot via for example matplotlib and org(-babel) automatically run the code and embed the resulting graphic in the document as I have told it to, automatically updated as I change the source code of the plot directly in the document.

                                  And when I’m done writing my document, I can just tell org to export it to html, pdf, word, ascii, whatever format you’d like. This can easily be automated if you wish so org automatically exports to f.eks. html on save. You can also provide your own stylesheet and so on so it exports html exactly as you wish. Just search for keywords: org-mode export html blogging.

                                  Also check out this page: https://orgmode.org/worg/org-blog-wiki.html

                              2. 4

                                I use Zim, which has a nice GUI, but an annoying markup (rST). It can also generate websites automatically and has Got/Hg integration. It’s the least worst solution I’ve found for personal knowledge base (Evernote was not helping me).

                                1. 2

                                  Agreed, zim is sort of the best I could find.

                                2. 3

                                  I settled on a public blog. I had my own self-rolled notes manager which was basically a wiki but I got lost in all the cross linking. Now it’s all just a flat list - blog posts, or a page with links to articles and references. I did find that link rot is super annoying.

                                  1. 3

                                    Over the years I’ve had several(along with the requisite text files scattered everywhere), which is why I’m working on unifying them.

                                    I had an installation of DokuWiki years ago on a hosted server, but it became too much of a pain to keep logging in since I kept it in private mode by default. Most times I’m in a capture mood, and I don’t like having internal thoughts public.

                                    I’ll note that I’ve tried switching to Emacs at least three times in the past 10 years for org-mode, only to switch back to vim in a month or so. Since then every machine I’ve worked on has had a vimwiki for various notes, some of which are job-specific. All of them have diverged from each other(or have NDA’d information) before I thought about using a shared git repo.

                                    I even tried signing up for Evernote earlier this year to keep a daily diary, and while it helps to have mobile clients, Evernote itself is too clunky and enterprise-y for a permanent solution.

                                    At this point I’ve been documenting the internals of fedwiki, as I’ve loved the concept ever since Ward released it, but really need a TUI for quickly dropping notes to it.

                                    1. 1

                                      Wow. fedwiki about.fed.wiki/neighborhoods just blew my mind. Thank you for pointing out.

                                    2. 3

                                      Yes, I do, in CherryTree.

                                      1. 1

                                        CherryTree

                                        +1 for CherryTree

                                      2. 3

                                        I migrated text file notes into a local MediaWiki instance on my laptop several years ago, that was fun at first, but I grew unhappy with the editing process being too slow. At some point I moved the contents with the help of pandoc into gitit (Markdown files kept in a Git repo with a MediaWiki like interface). That allowed occasional edits through the console and proper history management (e.g. reverting on squashing edits). I was still unhappy with the inconvenience of editing text in a web browser and increasingly missed the editing facilities I have with running emacs in a terminal. So I switched the setup once more.

                                        I’m now using a simple Python script that uses asciidoctor (or pandoc) to render md or adoc files from a Git repo as HTML and serves that at a localhost port for FF or Chrome. It adds an invisible one-liner ‘…/page?edit’ link element at the end of each HTML page (with an accesskey=“e”) that triggers the Python script to start up a terminal window with emacs and the md/adoc source of the page I’m currently browsing. Emacs is using git-auto-commit mode for the Git repo directory. Put together, that means I can browse through my Git repo in a Wiki-like fashion and at the press of Shift+Alt+e get an emacs terminal window right into the current document where edits are auto-tracked in Git. Interaction is instant and this combines all the benefits of wiki browsing, Git and text editing through emacs for me.

                                        1. 2

                                          I was running a gitit installation as a daemon on my laptop for years, set it up initially for my software engineering studies at TU Vienna, but eventually dropped out and stopped using gitit. Gitit is/would be nice - but isn’t maintained a lot, notably by pandoc developing further than gitit - but there are still sometimes contributions.

                                          Today I’d probably go with something that integrates with emacs, provides a nice web/mobile/kindle-view and has good search capabilities.

                                          At some point I’ve setup a blog with Ikiwiki, but I really can’t recommend this tool.

                                        2. 3

                                          Since I needed to have a space to write some code snippets, configuration settings, etc… I made a page for that on my (recently made) blog (built with Jekyll). It’s just a beginning, not really made for others: things need to be improved, it misses a menu for example.

                                          1. 2

                                            I use Notes.app for marginalia as I read books / watch talks. It works very well for me. I also have a big folder on Dropbox with PDF versions of interesting blog posts / papers / case studies / etc.

                                            1. 2

                                              I have several org documents I keep my brain backed up in. Serves the same purpose.

                                              1. 2

                                                Sort of. I organize my information using FreeMind. It’s a mind-mapping tool with a tree hierarchy and rich text formatting.

                                                1. 2

                                                  I started pretty much exactly the same thing about 5 months ago, starting on kb-wiki, putting my public instance at idea.junglecoder.com. It’s something I created mostly for myself, and it was born out of a list of ideas I’d started collecting onto a server in a text file. It’s a place where I currently keep a fair amount of personal ideas that I don’t mind others reading about.

                                                  1. 2

                                                    I keep a Mediawiki instance around. It’s the standard wiki, I don’t know why I’d bother with something else.

                                                    1. 2

                                                      Yes I do, but it’s not “lab notes”, also most of it is not public.

                                                      It’s mostly stuff I researched once and may need to look up every once in a while: hardware specs of all the computers/laptop in the house, a list of all my vacation destinations (with year and month), several lists: what movies I watched, etc.pp. I usually write a “this was last year” blog post and I grab the movies from there for example.

                                                      Of course I also have a horrible mess of text files, but those are mostly volatile.

                                                      1. 2

                                                        Right now it’s just a collection of notes on my phone and laptop that occasionally become articles that are sometimes published on my blog. But I’m starting a bullet journal and am considering moving from markdown to mandoc. That way I can keep an analog journal and synthesize notes and accomplishments into guides that can be easily used on my laptop or compiled to html for public viewing.

                                                        The reason for mandoc is because of all the tools in *bsd that allow you to search for info in man pages.

                                                        1. 1

                                                          because of all the tools in *bsd that allow you to search for info in man pages.

                                                          Exactly this. I mean the reason I keep everything on disk as a text file (.md or whatever) is that it integrates seamlessly with the rest of the system. I can search with grep. I can track, synchronize, and roll back changes with version control.

                                                        2. 2

                                                          Right now I’m trying to reimplement GTD,and have landed on:

                                                          • Notes.app for really temporary notes (like stuff that’s only valuable for a couple hours)
                                                          • using Notion for reference material

                                                          Notion works very well as a wiki, it supports rich content and linking, as well as building trees of documents. I try to avoid having too much fun with it but it works nicely for keeping more permanent notes

                                                          1. 1

                                                            Notion is indeed very good, I’d be curious about your experience with it. Would you mind going into more detail? Do you also use it to store code snippets/examples?

                                                          2. 2

                                                            I’m looking for something which can be both expressed by raw text files with some specific markup as well as database (with tags, relations between documents, storing binary data, and so on). It would be nice to have an (un)official iOS client, as I’ve recently switched to iPad Pro 10 w/ leyboard as main EDC computer.

                                                            But the more important problem with taking notes and maintaining personal wiki is… how to push myself to do this? I often fall for the decisions like „I wouldn’t need this thing anymore”, „I can just look it up on the web again and again, Web Archive is a thing” and most importantly „It’s not productiive and doesn’t add any value, so instead of writing things or doing another productive work, I’ll just sit here and think about it over and over”.

                                                            1. 2

                                                              I have a knowledge base section on my website. It’s really just a blog category, except its index page is not chronological and shows names only in a dense list.

                                                              There’s… not much knowledge in there right now :D

                                                              1. 2

                                                                I started off keeping a set of interlinked files in org mode on my machine, but eventually got annoyed that I couldn’t easily sync between work and home, so I built a webserver that hosts notes and allows me to post things through a GUI/bookmarklet[0]. Since most of what I save is links with an (optional) short summary/commentary, whenever I add a link, the system fetches the content, saves it in a database, and uses the Mercury Web Parser to extract the content.

                                                                The notebooks are private, and the way I use them is a mix between a wiki and a read-later service (I’ll post links with no content or minimal content to a section of each page called “heap”, then later decide whether to include them in the permanent content).

                                                                I sometimes polish the notebooks and publish them to my personal site, which is static. Right now, the biggest pain point is that the publication process is super manual. I’d like to make it push button, so that I can use one-click to publish.

                                                                [0] Bookmarklets seem to be getting harder and harder to implement properly with new browser updates, so I’ll write a proper extension when I get a chance.

                                                                1. 2

                                                                  I keep a bunch of markdown files. Its not really a wiki like the one shown here. Its mostly notes on how to redo things I’ve figured out before or (I’m hoping) short amount of text I can read to quickly get back up to speed. They are disjoint and don’t link much to each other.

                                                                  I later made a web interface for it but then pretty much never used it.

                                                                  1. 1

                                                                    I keep mine on a Github repo wiki: http://github.com/wuz/grimoire/

                                                                    Not a lot in there, and I tend to forget to add stuff. I should really use it more.

                                                                    1. 1

                                                                      Seeing your wiki really impacted me, it has a lot of useful information. I would like to ask if you usually get comments and feedback about what you put there. I’m always taking a lot of notes to write blog posts, but writing them is a much greater hassle and I just see the point if a discussion is generated and I can see other’s opinion about it, what usually doesn’t happen with the posts.

                                                                      1. 1

                                                                        I’m curious how important publish to the public is, versus privacy through encryption, for most people here?

                                                                        1. 1

                                                                          I’ve started using https://notion.so and really like it

                                                                          1. 1

                                                                            Out of curiosity, what do you like about Notion? Do you use it to store code or just text (I asked the same question to rtpg in the thread).

                                                                            1. 1

                                                                              It’s not particularly rigid so I’ve got all sorts of things stored in it. My main space is sort of “list of lists” on the left and my “Inbox” on the right, just being a link dump. I’ve got a space for programming notes which does include useful code snippets.

                                                                              The main two things I like about it is that aesthetically I find it pleasing to look at, which I value because if I’m going to be spending a lot of time in an app, I want to enjoy it. That and it’s easy to move things around. I was at a workshop recently and it wasn’t particularly hard to get something nice looking out of a few notes rather than just a big dump of text.

                                                                              1. 1

                                                                                Thanks a lot, super interesting to see that UI design plays a big role. I also find that moving things around , both within a page and withing the tree is super easy. Knowledge is malleable, so reorganization should be straightforward. They definitely nailed this. Anything that bothers you with it, though?

                                                                          2. 1

                                                                            I’ve been considering starting a personal wiki after reading The Garden and the Stream: A Technopastoral by Mike Caulfield a while back. His article has some great set up and philosophy about the wiki versus blog. I’ve been using my own website/blog as a commonplace book for quite a while now to collect everything from what I’m listening to to what I read and even what I’ve highlighted/annotated online. I’ve documented a lot of the pieces I use to create/customize it. (Not everything I write is public either.)

                                                                            Ultimately, I think that either way, having a solid search functionality becomes important regardless of which direction one chooses.

                                                                            (Reply originally published at boffosocko.com)

                                                                            1. 1

                                                                              I use Quiver Notebook. It stores everything in files that I can easily add to a git repo (Keybase).

                                                                              If people don’t want to buy Quiver I normally recommend Boostnote or Jrnl.sh since they both store files in a way that can easily be added to version control or exported to another format.

                                                                              1. 1

                                                                                I keep most of my writing on GitHub as well. A generic tech one here: https://github.com/danburzo/toolbox, then specific ones tagged with as-we-learn https://github.com/topics/as-we-learn

                                                                                I love that they’re living documents, and are easier to edit — either locally or on GitHub directly, and also I have the luxury to write (mostly) for myself. So I wouldn’t say a blog is enough for me, but rather I don’t think I’m there yet. (The actual blog http://danburzo.ro has seen very infrequent updates in comparison).

                                                                                1. 1

                                                                                  At home, text files for long-form notes. I used to use (and still like) http://zim-wiki.org but at some point felt I wasn’t really doing enough with it to justify reinstalling after a clean build. I’d like to build that habit back up.

                                                                                  At work, I keep project notes in tickets or Confluence.

                                                                                  I also recently started using https://dnote.io for small things - I don’t use the cloud sync but I like having a simple CLI interface for quick snippets.

                                                                                  dnote add bash -c "pushd and popd for stack-based navigation of directory history"

                                                                                  …is lovely and very simple.