scroll VS fzf

It took me many years to get Scroll (https://scroll.pub/) to the point where I love it and am confident it will be the dominant language for writing going forward (replacing markdown).

I first had to invent Tree Notation (2017), which I got wrong on my first two tries (2012's Note and 2013's Space). Then I needed to invent Grammar (2017), and then I made the predecessor to Scroll called Dumbdown (2019). 2 years after that I shipped the first version of Scroll (2021).

Now we are on Scroll version 58 and it's blazing fast, very simple, extremely extendible, and scales very well.

It was 90% me for a while, but recently been very much a team effort.

It took a while to get right because it's a whole new kind of language, so there were a lot of mistakes that I made and had to undo, and it took a while to figure out exactly what was special about it and how to double down on that.

I recently started 2 new newspapers: https://longbeach.pub/ and http://hawaii.pub/. Very different from traditional newspapers in that they are: public domain, open source (view source on every page), and built using a new language (https://scroll.pub/).

Another cool site I found recently (via the replit guy) is https://www.rootclaim.com/

Very cool way to present arguments.

I'm thinking of taking that, as well as argdown, and building some easy to use keywords in scroll https://scroll.pub/

> Context-free grammars, and their associated parsing techniques, don't align well with real-world compilers, and thus we should deemphasise CFGs (Context-Free Grammars) and their associated parsing algorithms.

I think CFG are highly overrated. Top down recursive descent parsers are simple and allow you to craft more human languages. I think building top down parsers is something every dev should do. It's a simple technique with tremendous power.

I think the source code for Scroll (https://github.com/breck7/scroll/tree/main/grammar) demonstrates how liberating moving away from CFGs can be. Easy to extend, compose, build new backends, debug, et cetera. Parser, compiler, and interpreter for each node all in one place. Swap nodes around between languages. Great evolutionary characteristics.

I'll stop there (realizing I need to improve the docs and write a blog post).

- Uses a new language called Scroll: https://scroll.pub/

Also, put down Markdown and give our Scroll a try: https://scroll.pub

It now powers sites like my own blog (https://breckyunits.com/), knowledge bases like PLDB.com, and our first new public domain daily newspaper called the Long Beach Pub (https://longbeach.pub/1-3-2023.html).

> Java, Go, Javascript, Rust, etc are all regularly written with whitespace, and have tools to enforce such formatting, but they don't derive information from it.

Ah you reminded me. A curious phenomenon I've observed with Prettier in JS and fmt in Go is languages are moving to standardized whitespace, but as you said, not yet deriving information from it. I don't know enough about Java or Rust but I suspect they probably both have adopted a Prettier/fmt like convention where all code is formatted on save. So it seems like we are moving to a world where it will be a simple flip of a switch to then start having popular languages extract meaning from the whitespace.

> Also, Python has existed for decades and still there is little further adoption of indentation-sensitivity. It doesn't seem like a wave of indentation-sensitive languages will be coming any time soon.

I think it's coming big time this year. I think our Scroll (https://scroll.pub/) will catch fire and be the go to language instead of Markdown by the end of the year. Then with the increasing success of TreeBase (powering PLDB and others) we will start to see JSON fall for config formats and document storage databases. A lot more will happen to, data vis will be a big one, but those 2 I'm reasonably certain of happening in 2023.

GoAccess: https://goaccess.io/. I don't miss Google Analytics at all.

Loom. It's not open source I don't think but I'm digging it and excited when a public domain competitor comes out.

Our https://scroll.pub/. It's far beyond markdown at this point. I am able to not only write better but also maintain thousands of pages of content by hand (well, most of the credit for that belongs to Apple M1s, Sublime Text, git, MacOS, and Github). The stuff we are doing with it now would just not be possible with anything else, and what we're coming out with next year is super exciting. It's all public domain.

In addition, I think bash's `operate-and-get-next` can be very helpful. When you go back through your shell history, you can hit Ctrl+o instead of enter and it will execute the command then put the next one in your history on the command line, and keep track of where you are in your history. This way, you can rerun a bunch of commands by going to the first one and Ctrl+o till you are done. And you can edit those commands and hit Ctrl+o and still go to the next previously run command.

Note: fzf's history search feature breaks this. https://github.com/junegunn/fzf/issues/2399

fzf : https://github.com/junegunn/fzf

Those are the most used aliases in my gitconfig.

"git fza" shows a list of modified/new files in an fzf window, and you can select each file with tab plus arrow keys. When you hit enter, those files are fed into "git add". Needs fzf: https://github.com/junegunn/fzf

"git gone" removes local branches that don't exist on the remote.

"git root" prints out the root of the repo. You can alias it to "cd $(git root)", and zip back to the repo root from a deep directory structure. This one is less useful now for me since I started using zoxide to jump around. https://github.com/ajeetdsouza/zoxide

> my history is so noisy I had to find another way

The fzf search syntax can help, if you become familiar with it. It is also supported in atuin [2].

[1]: https://github.com/junegunn/fzf#search-syntax

[2]: https://docs.atuin.sh/configuration/config/#fuzzy-search-syn...

You call it with `n` and get an interactive fuzzy search for your directories. If you do `n ` instead, it’ll start the find with `` already filled in (and if there’s only one match, jump to it directly). The `ls` is optional but I find that I like having the contents visible as soon as I change a directory.

I’m also including iCloud Drive but excluding the Library directory as that is too noisy. I have a separate `nl` function which searches just inside `~/Library` for when I need it, as well as other specialised `n` functions that search inside specific places that I need a lot.

¹ https://github.com/sharkdp/fd

² https://github.com/junegunn/fzf

View on GitHub

I do find the history pager stuff interesting, but ultimately not of tremendous use for me. I rebound all my history search stuff to use fzf[1] (via a fish plugin for such[2]), and so haven't been aware of the issues

[1] https://github.com/junegunn/fzf

[2] https://github.com/PatrickF1/fzf.fish

You can also use fzf with ripgrep to great effect:

[1]: https://github.com/junegunn/fzf/blob/master/ADVANCED.md#usin...