sogaiu

2025-02-12

problem

not all items listed in the "table" here result in successful searches. one example item that does not yield any search results is: #fl(

exploration

background

Anders Schau Knatten Videos

2021 - From Program to Process - What Happens After the Compiler
2022 - How to Start a Program
2022 - Just Enough Assembly for Compiler Explorer
2023 - How Symbols Work and Why We Need Them
2024 - The Two Memory Models

https://sfconservancy.org/news/2024/nov/29/openwrt-one-wireless-router-now-ships-black-friday/

janet-lang/janet#1550

https://en.wikipedia.org/wiki/Hexadecimal#Hexadecimal_exponential_notation

1	+0x1.0000000000000p+0000	+1.0000000000000000e+000
+0	+0x0.0000000000000p+0000	+0.0000000000000000e+000
-0	-0x0.0000000000000p+0000	-0.0000000000000000e+000
1/3	+0x1.5555555555555p-0002	+3.3333333333333331e-001
-4/7	-0x1.2492492492492p-0001	-5.7142857142857140e-001

How to find the Git commit that introduce a string in any branch
```
git log -S <string> --source --all
```
How to find the commit in which a given file was added?

git log --diff-filter=A -- foo.js

initially added as thoughts.txt

https://github.com/janet-lang/janet/commit/57f88ba28ab8640594b5619e114dc06493b63812

renamed thoughts.txt to thoughts.md

https://github.com/janet-lang/janet/commit/eee453d2c086f3c88d8ba84d4d53fb1680ca873a

ultimate removal

https://github.com/janet-lang/janet/commit/b5ed4a875fa7abc56dc3e4ed647186aefa5815f1

Like all programmers, DSL users deserve proper abstractions, that is, constructs that do not expose the underlying, reused components. In other words, host language details should not leak into uses of the DSL, including in error messages. Racket’s syntactic abstraction capabilities builds on the innovations of its Scheme and Lisp roots, but these predecessors never cared about writing true abstractions. At best, Lisp and Scheme programmers write low-level validation code that clutters the implementation; more commonly, validation is omitted, leaving Lisp and Scheme macros that resemble naive rewrite rules that do not distinguish the DSL from the host language. Racket helps the creation of robust linguistic abstractions with a declarative DSL for writing syntax transformers [Culpepper 2012]. Instead of low-level validation code, programmers write high-level specifications, which is compiled to produce error messages in terms of the surface language.

issues

how to handle matching macroexpansions... identifiers in expansions typically vary each time an expansion is performed. there doesn't appear to be a way to "reset" things such that specific identifiers are used.
how to handle checking for certain numeric values like floating point... expressing an exact value for an expected value seems non-trivial / impractical not too infrequently, e.g. (= 0.3 (+ 0.1 0.2)) is false
how to handle (def ...), (var ...), etc.... the code transformation step could have an initial phase that

	$ rg hort \| rg and
	janet.1:Execute a single Janet expression as a Janet short-fn, passing the remaining command line arguments to the expression. This allows
	test/suite-parse.janet:(assert (= '(1 2 3) (quote (1 2 3)) (tuple 1 2 3)) "quote shorthand")
	CHANGELOG.md:- Add function literal short-hand via `\|` reader macro, which maps to the
	test/suite-boot.janet:# Function shorthand
	test/suite-boot.janet:(assert (= (\|(+ 1 2 3)) 6) "function shorthand 1")
	test/suite-boot.janet:(assert (= (\|(+ 1 2 3 $) 4) 10) "function shorthand 2")
	test/suite-boot.janet:(assert (= (\|(+ 1 2 3 $0) 4) 10) "function shorthand 3")
	test/suite-boot.janet:(assert (= (\|(+ $0 $0 $0 $0) 4) 16) "function shorthand 4")
	test/suite-boot.janet:(assert (= (\|(+ $ $ $ $) 4) 16) "function shorthand 5")