weblog

For what it's worth it, I'm still developing and using exclusively my own text-based editor/IDE: https://github.com/alefore/edge I wrote recently a bit about my conclusions after ten years of developing it: https://github.com/alefore/weblog/blob/master/edge/README.md

Agree. I try hard to push the validation to static checks, but it can't always be done. For example: - a "probability" represented as a double must always be between 0 and 1 - A vector of values given to some group of functions must always be sorted (by some given order) But even in those cases, using types allows me to ensure that this validation always happens (when the type instance is created). It also let's me avoid having to explicitly validate this inefficiently (e.g. redundantly in preconditions in functions that receive these values). This doesn't change the fact that static validation is a better approach, but compliments it. I wrote a bit about it here: https://github.com/alefore/weblog/blob/master/edge/correctne...

Very cool! I've also been writing my own terminal text editor for a while (just crossed the ten years mark!), so I know how much dedication this takes. :-) One thing I did recently was start writing the lessons I've learned in my journey, I figured I'd share it in case it helps you, maybe you'll find one or two ideas interesting: https://github.com/alefore/weblog/blob/master/edge-lessons.m...

> When type errors occur in production, the end result is the program crashing, nothing you can do about it. Uh, you can catch the type error and recover (e.g., as with any other runtime failures, fail the incoming request that triggered the failure, unwinding the stack and reclaiming memory). And, even if you didn't, crashing may be the ideal reaction: https://github.com/alefore/weblog/blob/master/software-corre... There are many reasons to prefer static type checks; I just find this specific argument against runtime type checks flawed. Yeah, static type checks are vastly better than runtime type checks; but runtime type checks are vastly better than, uh, no type checks.

I like the idea of Notion, but one of things keeping me is that it seems like it'd be a pain to export one's data if Notion ever went out of business. But just keeping folders of Markdown notes is also inflexible, but on the opposite side of the scale. Obsidian looks like a great balance! I've requested beta access as well. Edit: Obsidian seems to make it easy to create a Zettelkasten, sort of like https://github.com/alefore/weblog/blob/master/zettelkasten.m... but with automation baked in.

I've been writing a lot on my Zettelkasten. I've been very productive! I published an article about Zettelkästen: https://github.com/alefore/weblog/blob/master/zettelkasten.m... I'm also working on an article about software correctness, summarizing my experience working on infrastructure software at Google for about 13 years. It's very incomplete and I'll probably end up restructuring it significantly (not very happy with the current logical structure). I only started working on this two or three weeks ago (as a side project), so I'm satisfied with the progress I've been able to make: https://github.com/alefore/weblog/blob/master/software-corre... I'm also working on other similar articles on other topics (Bitcoin, Stoicism, Bauhaus), but those are even less complete. Lastly, I've continued to make significant improvements to my text edit

Aww, thank you! Yeah, that entire article is generated from the set of notes. There's one note for each subsection (down to the finest level of granularity) and it just extracts the article directly based on the links. I described this in a set of notes that end up here: https://github.com/alefore/weblog/blob/master/zettelkasten.m... The images (e.g., distribution of back links per file, semilattice view, etc.) are also just generated programmatically from the repository of notes. The code that extract it is here: https://github.com/alefore/edge/blob/master/rc/editor_comman... (function zke, which receives the output path, the path to the initial note, and a string listing space separated paths of notes to ignore). Here's another example of an article generated from my notes (this is way longer and is very incomplete, and probably contain

I do the same, using the Zettelkasten method. I've found it very useful. I write many small notes as markdown files and link them together, storing them in a git repository. I wrote a bit about Zettelkästen (and the practices I follow), in case others find it useful: https://github.com/alefore/weblog/blob/master/zettelkasten.m...

Interesting. :-) I recently posted a brief document I wrote about a similar structure, immutable AVL trees. I find AVL trees a very nifty structure, I think they don't get as much credits as they deserve: logn (which in practice is about the same as "constant" for most values of n one encounters in practice) insertion, lookup, deletion and even append (for position-based trees, with some assumptions). Incredibly simple implementation. And, if immutable (based on shared memory), allows trivial snapshotting, having multiple "concurrent" trees sharing most of their memory. Anyhow, it's here: https://github.com/alefore/weblog/blob/master/immutable-avl-... I have a small implementation here (which I use, among other things, to hold all lines in a file, in my text editor): https://github.com/alefore/edge/blob/master/src/const_tree.h