Guix absolutely supports ZFS[1] without root or /home on it.
The user-space daemon for auto-mounts might take some setup, but there's a guide[2]*. I've personally gone all-in and use Guix with ZFS-on-Root, but this isn't an officially supported configuration due to an unfortunate cluster-truck[3] of an issue, and I haven't shared my configuration publicly yet (might soon for other reasons, but it's just not there yet).
Funnily enough, I picked up the habit of using graves for my opening quotes from working with old Unix software like ELisp without any context. I think it's a fine practice, particularly when used as markup that's transformed into curly-quotes on the user-faceing side, and it's even seeped into my handwriting as exaggerated opening quotes. I'll still draw nice curly quotes or mirrored ticks when writing neatly, but for sloppy writing and markdown alike, I find the clear distinction between opening and closing delimiters to be more readable than using just single quotes. On this, reasonable minds may differ c:
> I find the clear distinction between opening and closing delimiters to be more readable than using just single quotes.
The correct characters to use are ‘/“ and ’/”. There is a clear distinction between opening and closing delimiters. I think you're falling for a false dilemma brought on by outdated software that is limited to ASCII (i.e., stuck in the 1960s).
I keep a list of these sorts of creative-writing-programming posts here[1] (forgive the bare and broken theme, i dont actually post so work on the site has not been started, let alone finished)
please let me know if you have any suggestions thet might fit in, and I'd be glad to even include less mystical folklore like the story of mel but clearly have a theme goin here
The tough choice was to exclude projects without prose; I myself am more comfortable writing code. My own contribution is still down the road, and I bear a great respect for those who have put their words (and themselves) into the world.
I find it interesting to compare Janet to Guile Scheme because they
both claim to be fit as embed-able scripting languages.
Haven't done any practical comparison yet bc Janet has only caught my
eye recently (;p), but it appears to have a culture of vendoring and
an edge in implementation size and complexity which (ideally) enable
diving into the language's implementation to scratch your own itches,
learn how it (and the stack in general) work more throughly, and allow
eg. low level code optimizations with less FFI boilerplate.
I wonder how executable size and performance pan out, but with C FFI
available in each language (and the reality of how much time
optimization is worth), I feel that comforts matter more.
Hi! I'd be really interested in checking out what you put together c:
The personal site in my bio hasn't had an email address on it because I thought I'd have one running on my own domain by now, but I'll go stick a gmail address on there like right now in case you're willing share
Definitely. This is a lr parser playground i put together. Again very simple (I am not a ui person so pardon the cringe ui). Happy to share repo too (has lots of tests but need to put together documentation etc). I am even using this lr parser generator for a couple of my hobby apps for a couple of years.
First, just some context, to be sure I've got my facts straight:
'call/cc' allows you to capture the continuation which invokes it. That continuation is represented as a procedure passed into a unary function. That function usually uses 'set!' to export the continuation into a broader scope before returning an initial value to call/cc's caller. Later, invoking that continuation with a value tosses your current continuation and returns you to the call-site of call/cc, where the call/cc form now returns to it's caller again but with the provided value.
In contrast, 'call-in-continuation' takes a procedure and some arguments. It tosses the current continuation, returning to the call-site of call/cc, but then instead of returning a supplied value directly to call/cc's caller, it returns the result of evaluating the given procedure (applying it to any other supplied arguments) here at the call/cc call-site.
Supplied arguments are evaluated before returning to the continuation, just like when invoking the continuation itself with some values.
Mirroring the example from Guile's docs[1]:
(define kont #f)
(let ((x 1))
(format #t "the return is ~a\n"
(call/cc (lambda (k)
(set! kont k)
(1+ x)))))
⇒ the return is 2
(kont 3)
⇒ the return is 3
(kont (+ x 3))
⇒ Unbound variable: x
(kont (lambda () (+ x 3))
⇒ the return is #<procedure 1d823a8 at <unknown port>:5:6 ()>
(call-in-continuation kont (lambda () (+ x 3)))
⇒ the return is 4
(call-in-continuation kont (lambda (y) (+ x y)) 4)
⇒ the return is 5
Oh, and a note on why you'd want this: while you may be able to construct a superficially similar example by expecting call/cc to return a thunk and evaluating it at the call-site, you can't always control the call-site and might be using one continuation in multiple contexts.
The try/catch implementation on page two of A Better API for First Class Continuations show-cases a specific use-case (albeit in the form of continuation-graft), though I'm still staring at it and trying to figure out if a few more parens and thunks wouldn't do the trick (more verbosely) in that context.
As a totally off-topic aside, I spent (too much) time last night making my personal site a dark-mode switch (link in profile), and it came out looking a lot like yours. I'd tried centering U+1F506 in the switch but wasn't happy with it by the time I cut myself off, so I've gone ahead and retro-fitted in your SVG's and now have a switch which looks an awful lot like yours (wasn't much else to set them apart) but is totally JS-free; the approach involves a template that wraps page content in no less than 3 divs, and still needs cleaned up a lot (eg. better ID names), in particular there's a block of CSS that could be DRY'd out in my SSG. Might eventually adopt plausible.io too (thanks!). Do you know where your SVG's came from (sun just looks like the unicode char), and are you using a SSG yourself?
Edit: lol, broke the mobile layout in the process, no way I've got time to fiddle with that right now :p
The user-space daemon for auto-mounts might take some setup, but there's a guide[2]*. I've personally gone all-in and use Guix with ZFS-on-Root, but this isn't an officially supported configuration due to an unfortunate cluster-truck[3] of an issue, and I haven't shared my configuration publicly yet (might soon for other reasons, but it's just not there yet).
1: https://packages.guix.gnu.org/packages/zfs/
2: https://www.reddit.com/r/GUIX/comments/s7qu25/guide_using_zf...
3: https://issues.guix.gnu.org/45692
*: Accessing ZVOLS through `/dev/zvol/foo/bar` takes additional setup.