Venture capital funding. The plan is always to do a rug pull. Though if it properly freely licensed and the code is reasonable enough to be forked, it's less worrying but still risky. It's better to work with honest people.
Completely sealing off every good route for the heroine. 😏
Well now I'm properly excited for this series.
From the title I thought this was going to be about making hats for magicians. I love the world building (A+ so far, though the idea of being able to keep magic secret is little hard to accept. I doubt that the series will focus on that so I think that I can lock in going forward.) and the fascination with the magic system (B to A+, depending on how well it explains advanced magic). The pacing so far is great: fast but doesn't feel rushed. I suspect that this will be my favorite show of the season.
I went back to look at the easy-to-see magic circles. It seems that there is a wide variety of sigils. The signs around the sigils seem to have less variety. And there seems to be some variations on the enclosing circles. The floating carriage and the forbidden spell appear to have 2-levels of nested magic circles. If this was a re-incarnation power-fantasy show, the protagonist would probably immediately aim to create 3+-levels of nested magic circles... but judging from the forbidden spell, 3-levels might have the potential to instantly destroy cities.
How the magic circles function with stone formations is a little bit of a mystery for now, I guess you could just say that there's durable special ink (or whatever the ink's made of) in the cracks.
A developer submitted a PR code change for systemd userdb.
My proposals (that's really what PRs are) are to implement a solution that meets the regulatory requirements in several jurisdictions by providing a way to store a self-reported birthdate locally on the machine. These laws also require that this date is collected during account creation (hence why I made PRs against installers) and you can enter any value here, even January 1st, 1900. There is no proof required, no ID scanning, and no external tracking. Nor do I have any desire for that to ever change.
Apparently the developer is confirmed to be just a regular guy. He thinks it'd be worse if every desktop environment implements their own solution to comply with these laws. He's against the various laws related to this incident.
As a fallout for submitting this pull request, he has been extensively harassed. His personal information being repeatedly posted online; his information used to sign up to a lot of sites, groups, churches, car dealerships, ordering food for him; threats of murder; regular textual harassment.
The show does a good job of making me to want to see the progression of Makio and Asa's relationship (also how Asa's mother changed after separating from Makio). I particularly liked the attorney in this episode. The Shingo-Makio pairing is ridiculously wholesome. Also, it definitely felt like they were planning to do a seamless ED transition.
I wanted to learn scheme and perhaps work through SICP. Guille seemed like a reasonable scheme to choose because I've also been considering learning Guix. Guix is a package manager similar to Nix, and it uses Guille as its configuration language.
Scheme/Guile
I was stuck on part 3 for a while, for not taking account that a child scale that I'm evaluating may already be a parent scale in some group.
(import (rnrs io ports (6))
(srfi srfi-1))
#!curly-infix
(define (parse-file file-name)
(let* ((lines (string-split (string-trim-both (call-with-input-file file-name get-string-all)) #\newline))
(split-lines (map (lambda (l) (string-split l #\:)) lines))
(parsed-lines (map (lambda (l) (cons (string->number (car l)) (string->list (cadr l)))) split-lines)))
parsed-lines))
(define (child-score child p1 p2 p1-sim p2-sim)
(if (and-map null? (list child p1 p2))
(* p1-sim p2-sim)
(let ((matches-p1 (eq? (car child) (car p1)))
(matches-p2 (eq? (car child) (car p2))))
(cond
((not (or matches-p1 matches-p2)) #f)
(else (child-score (cdr child) (cdr p1) (cdr p2) (+ p1-sim (if matches-p1 1 0)) (+ p2-sim (if matches-p2 1 0))))))))
(let ((dna-lines (parse-file "notes/everybody_codes_e2025_q09_p1.txt")))
(format #t "P1 Answer: ~a\n\n" (or
(child-score (cdar dna-lines) (cdadr dna-lines) (cdaddr dna-lines) 0 0)
(child-score (cdadr dna-lines) (cdar dna-lines) (cdaddr dna-lines) 0 0)
(child-score (cdaddr dna-lines) (cdadr dna-lines) (cdar dna-lines) 0 0))))
(let ((dna-lines (list->vector (parse-file "notes/everybody_codes_e2025_q09_p2.txt"))))
(let loop ((child 0) (total-sim 0))
(if {child < (vector-length dna-lines)}
(loop (1+ child) (+ total-sim (let loop ((i 0))
(cond
((eq? i child) (loop (1+ i)))
({i >= {(vector-length dna-lines) - 1}} 0)
(else
(or
(let loop ((j (1+ i)))
(cond
((eq? j child) (loop (1+ j)))
({j >= (vector-length dna-lines)} #f)
(else (let ((res (child-score
(cdr (vector-ref dna-lines child))
(cdr (vector-ref dna-lines i))
(cdr (vector-ref dna-lines j)) 0 0)))
(or res (loop (1+ j)))))))
(loop (1+ i))))))))
(format #t "P2 Answer: ~a\n\n" total-sim))))
(define (init-id-to-group dna-lines)
(let ((table (make-hash-table)))
(let loop ((i 0))
(if {i < (vector-length dna-lines)}
(let ((id (car (vector-ref dna-lines i))))
(hash-set! table id id)
(loop (1+ i)))
table))))
(define (init-group-to-ids dna-lines)
(let ((table (make-hash-table)))
(let loop ((i 0))
(if {i < (vector-length dna-lines)}
(let ((id (car (vector-ref dna-lines i))))
(hash-set! table id (list id))
(loop (1+ i)))
table))))
(let ((dna-lines (list->vector (parse-file "notes/everybody_codes_e2025_q09_p3.txt"))))
(let ((id-to-group (init-id-to-group dna-lines)) (group-to-ids (init-group-to-ids dna-lines)))
(let child-loop ((child 0))
(if {child < (vector-length dna-lines)}
(let i-loop ((i 0))
(cond
((eq? i child) (i-loop (1+ i)))
({i >= {(vector-length dna-lines) - 1}} (child-loop (1+ child)))
(else
(let j-loop ((j (1+ i)))
(cond
((eq? j child) (j-loop (1+ j)))
({j >= (vector-length dna-lines)} (i-loop (1+ i)))
(else (let* ((cl (vector-ref dna-lines child))
(pil (vector-ref dna-lines i))
(pjl (vector-ref dna-lines j))
(res (child-score (cdr cl) (cdr pil) (cdr pjl) 0 0)))
(if res
(let* ((i-group (hash-ref id-to-group (car pil)))
(j-group (hash-ref id-to-group (car pjl)))
(child-group (hash-ref id-to-group (car cl)))
(i-group-ids (hash-ref group-to-ids i-group))
(j-group-ids (hash-ref group-to-ids j-group))
(child-group-ids (hash-ref group-to-ids child-group))
(new-group-ids (delete-duplicates (append child-group-ids (or i-group-ids '()) (or j-group-ids '())))))
(map (lambda (id) (hash-set! id-to-group id child-group)) new-group-ids)
(hash-remove! group-to-ids i-group)
(hash-remove! group-to-ids j-group)
(hash-set! group-to-ids child-group new-group-ids)
(child-loop (1+ child)))
(j-loop (1+ j))))))))))
(format #t "P3 Answer: ~a\n\n" (cdr (hash-fold
(lambda (_ id-list prior)
(let ((group-size (length id-list))
(group-sum (apply + id-list)))
(if {group-size > (car prior)}
(cons group-size group-sum)
prior)))
(cons 0 0)
group-to-ids)))))))
Scheme/Guile
Takes about 5 seconds.
(import (rnrs io ports (6))
(srfi srfi-1))
#!curly-infix
(define (parse-file file-name)
(let ((sequence (map string->number (string-split (string-trim-both (call-with-input-file file-name get-string-all)) #\,))))
(zip sequence (cdr sequence))))
(let loop ((sequence (parse-file "notes/everybody_codes_e2025_q08_p1.txt")) (count 0))
(if (null? sequence)
(format #t "P1 Answer: ~a\n\n" count)
(loop (cdr sequence) (+ count (if (and last (eq? (modulo (- (cadar sequence) (caar sequence)) 32) 16)) 1 0)))))
(define (crosses-over? a b)
(let ((a1 (car a))
(a2 (cadr a))
(b1 (car b))
(b2 (cadr b)))
(let ((a2 (modulo {a2 - a1} 256))
(b1 (modulo {b1 - a1} 256))
(b2 (modulo {b2 - a1} 256)))
(and (not (eq? b1 0)) (not (eq? b2 0))
(or
(and {b1 < a2} {b2 > a2})
(and {b1 > a2} {b2 < a2}))))))
(define (count-cross-overs sequence a)
(let loop ((sequence sequence) (count 0))
(if (null? sequence)
count
(loop (cdr sequence) (+ count (if (crosses-over? (car sequence) a) 1 0))))))
(let loop ((sequence (parse-file "notes/everybody_codes_e2025_q08_p2.txt")) (passed '()) (count 0))
(if (null? sequence)
(format #t "P2 Answer: ~a\n\n" count)
(loop (cdr sequence) (cons (car sequence) passed) (+ count (count-cross-overs passed (car sequence))))))
(let ((sequence (parse-file "notes/everybody_codes_e2025_q08_p3.txt")))
(let loop ((i 1) (greatest 0))
(if {i > 256}
(format #t "P3 Answer: ~a\n\n" greatest)
(loop (1+ i) (max greatest (let loop ((j i) (greatest 0))
(if {j > 256}
greatest
(loop (1+ j) (max greatest (count-cross-overs sequence (list i j)))))))))))
Scheme/Guile
You could probably build a (letter, length) => combination-count mapping pretty quickly for part 3, but dealing with overlap in the input elements seems like a pain if handled this way.
(import (rnrs io ports (6)))
#!curly-infix
(define (parse-file file-name) (let*
((lines (string-split (string-trim-both (call-with-input-file file-name get-string-all)) #\newline))
(names (string-split (car lines) #\,))
(rule-lines (cddr lines))
(rules (map (lambda (l) (let*
((sides (string-split l #\space))
(r-left (string-ref (car sides) 0))
(r-right (caddr sides)))
(cons r-left (map (lambda (x) (string-ref x 0)) (string-split r-right #\,))))) rule-lines)))
(cons names rules)))
(define (check-name rules name)
(if (eq? 1 (string-length name))
#t
(let* ((letter (string-ref name 0))
(right (assq-ref rules letter))
(next-letter (string-ref name 1)))
(if (memq next-letter right)
(check-name rules (substring/read-only name 1))
#f))))
(let* ((parsed (parse-file "notes/everybody_codes_e2025_q07_p1.txt"))
(names (car parsed))
(rules (cdr parsed)))
(let loop ((names names))
(let* ((name (car names)) (name-matches (check-name rules name)))
(if name-matches
(format #t "P1 Answer: ~a\n\n" name)
(loop (cdr names))))))
(let* ((parsed (parse-file "notes/everybody_codes_e2025_q07_p2.txt"))
(names (car parsed))
(rules (cdr parsed)))
(let loop ((i 1) (names names) (name-sum 0))
(if (null? names)
(format #t "P2 Answer: ~a\n\n" name-sum)
(let* ((name (car names)) (name-matches (check-name rules name)))
(loop (1+ i) (cdr names) (+ name-sum (if name-matches i 0)))))))
(define discovered-prefixes (make-hash-table))
(define (count-prefixes rules name)
(if (hash-ref discovered-prefixes name)
0
(begin
(hash-set! discovered-prefixes name #t)
(if {(string-length name) >= 11}
1
(+
(apply + (map
(lambda (c) (count-prefixes rules (string-append name (string c))))
(or (assq-ref rules (string-ref name (1- (string-length name)))) '())))
(if {(string-length name) >= 7} 1 0))))))
(let* ((parsed (parse-file "notes/everybody_codes_e2025_q07_p3.txt"))
(names (car parsed))
(rules (cdr parsed)))
(let ((name-count (apply + (map (lambda (name) (count-prefixes rules name)) (filter (lambda (name) (check-name rules name)) names)))))
(format #t "P3 Answer: ~a\n\n" name-count)))
view more: next ›
https://bsky.social/about/blog/03-19-2026-series-b
I didn't know this about bluesky D:, but it makes sense. Thanks for the heads up. The atproto ecosystem seems to have cool features for user empowerment and it seems to work well on the few occasions I've visited atproto sites. I hope they can find an ethical way to persevere, but I can't imagine that being easy.