Wouter van Oortmerssen

I have used many open source notes taking apps. My goto used to be Zim Desktop Wiki [0] but its just a desktop app and the was no built in sync solution. On mobile I used Markor [1] which understood Zims syntax, as well as markdown. Due to lack of mobile client and built in sync options I moved to Joplin [2]. Its markdown, cross platform, and i can sync with WebDav. People don't like that its SQLite based, but honestly worse com to worse your notes are an export away, or you can just open the database yourself. Im happy with it. I always recommend Treesheets [3] though, excellent for brainstorming/rapid note taking. [0] https://zim-wiki.org/ [1] https://f-droid.org/packages/net.gsantner.markor/ [2] https://joplinapp.org/ [3] https://strlen.com/treesheets/

The following are not exactly what you have asked for. https://gephi.org/ This implements lots of graph visualization algorithms. https://strlen.com/treesheets/ Excel for tree data.

I would suggest looking into the following areas for inspiration as well: - Xanadu and related systems for linking information - CardboardWM (how it does user's working canvas) - Desktop Neo – (https://desktopneo.com/) & Muse — dive into big ideas(https://museapp.com/) - The ecosystem of templates and tooling for Notion - TreeSheets (https://strlen.com/treesheets/) My gut feeling is that going deep into interoperations within apps will be very challenging and require intrinsic knowledge of each platform (always evolving) interfaces.

Have you tried lobster[0]? I think it took a lot of inspiration from Smalltalk in how it handles closures and control structures, in that it tries to make function call syntax work like control structures[1]. Actually, looking at it's design history[2] it took a lot of inspiration from a lot of languages before ending up where it is now (or maybe "where it's taking a break for now" is a better way of putting it). So it's no surprise that Van Oortmerssen tried to keep the best bits of every language he visited. [0] https://strlen.com/lobster/ [1] https://aardappel.github.io/lobster/language_reference.html (scroll down to function calls) [2] https://aardappel.github.io/lobster/philosophy.html

I seem to recall that Dice-C was faster than Lattice/SAS. If C compatibility wasn't required, then Amiga-E was possibly the best option if one wanted a (very) fast compiler paired with a high lever powerful language. https://strlen.com/amiga-e/

I like the part where you can do calculations like in classic spread sheet apps, but visualize what your are doing, instead of hiding it behind formula fields. (see this screenshot: http://strlen.com/treesheets/docs/images/screenshots/screenshot_sales.… But functionality and especially usability of this application is quite limited. It feels more like a proof of concept, than an application for daily use.

Want to see what happens falls too much in love with DRY? He invents an "automatic refactoring system" that automatically DRY-ifies a whole program: http://strlen.com/restructor/ (not that great an idea in hind-sight, as the page explains). Interesting to see all the comments here that make it seem obvious that "fanatic DRY" is bad. Historically, there was a wave of OO love where a lot of people went crazy with wrapping every program element in deep layered class hierarchies. DRY (and OAOO, YAGNI etc) was maybe a backlash to that, and some go too far with it. Now we all seem in love with "leave the redundancy in the code", which is another backlash. What's the next backlash? Maybe we'll finally focus on how to balance these factors rather than seeing some extreme as the silver bullet?

It's pretty amazing to see this project still going. I remember Sauerbraten more because of its unique engine. Maps are basically a big octree with something like marching-cubes applied, and can be edited in realtime (and in multiplayer). The developers have many notable side projects in the gaming space, too. Aardappel has a programming language, Lobster[0]. And eihrul created the ENet library for UDP networking[1]. I think Sauerbraten itself uses ENet. [0] http://strlen.com/lobster/ [1] http://enet.bespin.org/

This is my favorite: http://strlen.com/treesheets/ The navigation system is great to use with keyboards.

Yes, I've bought every alleged outliner since and nothing compares. What's amazing is that Ecco had 100% reliable cross-device syncing in 1990s, both PC-PC and PC-PalmPilot. So it has enough metadata in the database. TreeSheets (http://strlen.com/treesheets/) is an open-source cross-platform codebase (wxWidgets) with fast graphics, since it was designed by a game developer. That's one possible starting point for cloning Ecco. NoteLynx on Android has the ability for an item to be in two places within the outline, https://www.appbrain.com/app/notelynx-pro-outliner-mindmap-wiki/com.as… as does Mindscope on iOS, https://itunes.apple.com/us/app/mindscope-thought-organizer/id90151302…

My other favorite Quake experiment was PanQuake http://strlen.com/gfxengine/panquake/ and FisheyeQuake http://strlen.com/gfxengine/fisheyequake/index.html. Running through the world with 360° view is quite trippy.

TreeSheets: http://strlen.com/treesheets/ - infinitely nestable spreadsheets, great for organizers TreeProjects Personal Database: http://personaldatabase.org/ - searchable, inter-linkable, hierarchical notes and media tracking for projects Godot Game Engine: https://godotengine.org/ - the scene graph system wherein a "scene" is just a saved subtree of nodes and can be instantiated at any point within a parent scene is so far beyond the clumsy scene/prefab split in eg. Unity

One thing I love is how it reads the whole source file into RAM and operates on it as an array. So many compilers (including my own...) avoid this, which I guess ostensibly lets them handle huge machine generated source files (but that's an extreme outlier, and really I'd be inclined to let people depending on that use something else or work around it). The first compiler I saw that didn't was Wouter van Oortsmerssen's AmigaE compiler [1], which demonstrated that it was a viable strategy even when your compiler is expected to run on a machine with 512KB RAM. It's one example of where we often over-abstract for dubious benefits. [1] http://strlen.com/amiga-e

Simply beautiful, beautifully simple idea. Takes the best of two worlds: paper and calculator. Somehow reminds me http://strlen.com/treesheets/ I was also impressed by the creative approach to the centuries-old task.

Worth reading the philosophy page: http://strlen.com/files/lang/lobster/philosophy.html "The most important over-arching reason behind everything in Lobster was to make it a pleasant language to use for one single person: me, the author." When these sorts of personal side projects come up on HN, it seems inevitable that people question whether anyone should want to use them... You probably don't most of the time. They're cool to look at, but I think the judgment of being cool comes more from a PL designer viewpoint than an end-user viewpoint...

In the comments in the article somebody mentioned this: http://strlen.com/treesheets/ Looks really cool. I always felt spreadsheets were too grid-oriented and flow charts too much about vectors and nodes. Treesheets looks like a great mashup of those two.

It reminds me of the False programming language (http://strlen.com/false-language), versions of which I've implemented on small micros I've worked on for similar purposes. False is a tiny but fairly powerful stack-based language the author originally implemented a compiler for in 1024 bytes of 68k machine code. False pulls some great ideas from Forth and (anachronistically) Factor. Perhaps it's because of the AT90USB162's RAM restrictions (512 bytes), but it seems having a "stack" of just one item and non-nestable loops is pretty restrictive. Oh, and no + - * / operators. I don't think adding nestable loops and a stack of say 5 items (10 bytes of RAM) and math operators would hurt much, and it'd certainly add to the power of a language like this -- perhaps changing it from a tiny debugging tool to a useful "scripting" language.

He must be referring to https://dl.acm.org/doi/pdf/10.1145/2935323.2935331 ? Just looking at refs for the moment: Henglein and Hinze's discriminators are interesting, whenever you come back up for air. (are they also amenable to sorting codata?) The oft-cited R Bernecky is, IIRC, also known as "Boolean Bob" for his SWAR-style algos. EDIT: nope, confused him with R Smith: https://aplwiki.com/wiki/Bob_Smith (I once asked Boolean Bob if any of his tricks went back to the card processing days —I could even believe the keyed tree* might?— but he was too young to know, and the people he'd have liked to ask are no longer available.) EDIT: Aardappel also has some interesting languages: https://strlen.com/#programming-languages * for manipulating Bills of Materials despite the linearity of card decks? EDIT2: compare "§3.2.1 Constructing Node Coordinates" (p34) with [T in "Table 1.19 Full list matrices of the tree of Fig. 1.16" in A Programming Language (p50): https://archive.org/details/aprogramminglanguage1962/page/n66/mode/1up Fc 1 0 0 0 0 1 1 0 0 0 1 1 1 0 0 1 1 1 1 0 1 1 1 1 1 1 1 1 1 2 1 1 1 1 3 1 1 2 0 0 1 1 2 2 0 Ec 1 0 0 1 1 0 1 1 1 1 1 2 1 1 3 1 2 0 1 3 0 1 3 4 1 3 5 1 3 6 [all three appear to be 1-origin, probably due to the phenomenon mentioned in the footnote on p49 of APL]

I think the future is in languages that offer "opt-in" borrow checking, so you can use it where it makes sense. After all, most of a program should prefer simplicity over performance, and only optimize where it matters. I think this is the path towards a more Pythonic Rust. Some languages that are going this direction, including D [0] and Vale [1]. Vale's particular insight is that we can get the benefits of borrow checking with isolates (from Pony) and integrating "pure blocks" and pure functions into the type system, so to speak. > ... breaks ownership is automatically transformed in a reference counted object ... Some languages actually do this! Lobster [2] uses borrow-checker-like semantics and falls back on reference counting. And worth mentioning is HVM [3], which falls back to cloning. [0] https://dlang.org/blog/2019/07/15/ownership-and-borrowing-in-d/ [1] https://verdagon.dev/blog/zero-cost-memory-safety-regions-part-1-immut… [2] https://www.strlen.com/lobster/ [3] https://github.com/HigherOrderCO/HVM

Also recommend http://strlen.com/treesheets/

Changing jobs in 2005 caused me to switch from taking notes on paper to doing it electronically. My new employer provided a tablet PC with a stylus running Windows and [OneNote](https://products.office.com/en-US/onenote). Taking notes on that system with excellent handwriting recognition was a revelation. The tablet was pretty clunky by today's standards, but it worked well. It was particularly useful for generating meeting notes in real time and projecting them during meetings. After moving to another employer, I no longer had access to such a tablet but used [TiddlyWiki](https://tiddlywiki.com) to keep my notes. It was great until the number of notes became large (in the thousands). After that, I became an early adopter of [Evernote](https://evernote.com). It was an adequate note-taking app, but the killer feature for me was searching for text in images. At that time, we put meeting notes up on a whiteboard. After the meeting, I could take a picture of the whiteboard, insert it in Evernote, and search it any time after that. I maintained a subscription to Evernote until the end of 2016 until they got squirrely about their subscriptions and some privacy issues. After several years absence, I went back to TiddlyWiki. It was very much improved. But after importing thousands of notes, it became too slow at editing. The search was on for another system. I looked at several open-source tools under active development: * [TreeSheets](http://strlen.com/treesheets/) has been…

This is great, and I'll definitely be playing with this tomorrow. I also can't seem to stop myself going off half-cocked and writing language interpreters[1][2] and virtual machines[3]. It's really quite addictive, and gives you a "I really made something" feeling that a new backup script or CRUD app doesn't quite provide. I too actually started off writing a stack/RPN-style language for the exact reason that I didn't want to do a proper parser, but then realized that, for properly recursive structures like in Joy[4], it really makes it easier to just write a parser. And it turns out that a recursive descent parser really isn't that difficult, conceptually, once you spend the brain-time to work one out yourself[5]. Like most things programmatic, it's tough to wrap your mind around until you've done it once, then it's just a matter a typing and bugfixing. Along with the aforementioned Joy (which is a stunningly elegant language), some other languages I find inspiring are rhoScript (http://www.rhoscript.com/), Pico Lisp (http://picolisp.com/wiki/?home), and the very clever WadC editor (http://strlen.com/wadc-editor), which implements a DSL and interactive environment for describing Doom levels in code, rather than by dragging vertices in a purely graphical editor (This isn't as crazy as it sounds if you're unfamiliar with the limitations of Doom levels, since they are constrained to certain types of simplified geometry that lend themselves well to this). In short, keep it…

Do you know TreeSheets[1]? It kind of sounds similar to your notebook idea. https://strlen.com/treesheets/

Dutch is aardappel. Fun fact: there's a programming language called Aardappel: https://strlen.com/aardappel-language/

Hmm, you might want to rename that: https://strlen.com/bla-language/ An interpreter and editor in 1K sounds very challenging! Do you mean 1K of Squeak bytecode? Including vectors of literals and selectors?

Arcan seems like https://strlen.com/treesheets/ for the OS-level.

Descended from FOVquake and Pan(oramic)Quake. https://strlen.com/gfxengine/panquake/ Changing the lens projection is a little different than changing the value of pi, but it plays in the same "visually wrong" space.

I think lobster does this. "Compile time reference counting / lifetime analysis / borrow checker."[1] "Reference Counting with cycle detection at exit, 95% of reference count ops removed at compile time thanks to lifetime analysis."[1] [1] https://strlen.com/lobster/

Maybe Lobster could be an option. https://strlen.com/lobster/ https://aardappel.github.io/lobster/memory_management.html It uses compile-time reference counting / lifetime analysis / borrow checking. Which is mostly inlined to the point that there is none of the sort in the compiled output and objects can even live on the stack. It basically looks like Python but is nothing like it underneath, and of course with no GIL. You can run it on JIT or compile it to C++. There's also Koka with the Perceus algorithm on compile time and looks like a much cleaner language than Rust. It also tracks side effects of every function in a type where pure and effectful computations are distinguished. https://github.com/koka-lang/koka

> program was born out of the observation that many problems are commonly solved with a calculator, a pencil, and a sheet of paper Few apps for Linux and Android: TreeSheets[0], µMath+[1], Xournal++[2]. [0] https://strlen.com/treesheets/ [1] https://f-droid.org/en/packages/com.mkulesh.micromath.plus/ [2] https://xournalpp.github.io/