Man, we should've actually used `+` sign for command line flags instead of `-`. Like this
> foo +arg1 +arg2 ...
And instead we should've interpreted `-` as "ignore this flag for now", so I we could quickly enable/disable the flags as we run the same command via up and enter.
> foo +arg1 +arg2 ...
And instead we should've interpreted `-` as "ignore this flag for now", so I we could quickly enable/disable the flags as we run the same command via up and enter.
September 10, 2025 at 12:06 PM
Man, we should've actually used `+` sign for command line flags instead of `-`. Like this
> foo +arg1 +arg2 ...
And instead we should've interpreted `-` as "ignore this flag for now", so I we could quickly enable/disable the flags as we run the same command via up and enter.
> foo +arg1 +arg2 ...
And instead we should've interpreted `-` as "ignore this flag for now", so I we could quickly enable/disable the flags as we run the same command via up and enter.
What I find amusing about Jai syntax is that the signature of a procedure is
(arg1, arg2, ...) -> result
Args are optional. Result's too. So the procedure with no args and result must be just (). And it is!
(arg1, arg2, ...) -> result
Args are optional. Result's too. So the procedure with no args and result must be just (). And it is!
August 8, 2025 at 11:40 AM
What I find amusing about Jai syntax is that the signature of a procedure is
(arg1, arg2, ...) -> result
Args are optional. Result's too. So the procedure with no args and result must be just (). And it is!
(arg1, arg2, ...) -> result
Args are optional. Result's too. So the procedure with no args and result must be just (). And it is!
fun fact there is no difference between these two
args @ { arg1, arg2, ...}: {}
and
{ arg1, arg2, ...} @ args: {}
despite me giving myself a seeming mandela effect of the second format allowing defaults to apply
args @ { arg1, arg2, ...}: {}
and
{ arg1, arg2, ...} @ args: {}
despite me giving myself a seeming mandela effect of the second format allowing defaults to apply
April 9, 2025 at 6:53 PM
fun fact there is no difference between these two
args @ { arg1, arg2, ...}: {}
and
{ arg1, arg2, ...} @ args: {}
despite me giving myself a seeming mandela effect of the second format allowing defaults to apply
args @ { arg1, arg2, ...}: {}
and
{ arg1, arg2, ...} @ args: {}
despite me giving myself a seeming mandela effect of the second format allowing defaults to apply
xcrun xctrace record -t "Time Profiler" --output 'profile.trace' --launch -- /path/to/program arg1 arg2
open -a Instruments profile.traceI
open -a Instruments profile.traceI
October 13, 2025 at 2:02 PM
xcrun xctrace record -t "Time Profiler" --output 'profile.trace' --launch -- /path/to/program arg1 arg2
open -a Instruments profile.traceI
open -a Instruments profile.traceI
Ok, I've got an idea. How about `-/` for "ignore this flag for now"?
> foo -arg1 -/arg2 -arg3 ...
That way to toggle the flag you just add or remove one character.
> foo -arg1 -/arg2 -arg3 ...
That way to toggle the flag you just add or remove one character.
September 10, 2025 at 2:43 PM
Ok, I've got an idea. How about `-/` for "ignore this flag for now"?
> foo -arg1 -/arg2 -arg3 ...
That way to toggle the flag you just add or remove one character.
> foo -arg1 -/arg2 -arg3 ...
That way to toggle the flag you just add or remove one character.
Arg2 Eng 1.
Oh dear how sad, never mind.
Oh dear how sad, never mind.
Military Man: Oh Dear, How Sad, Never Mind
ALT: Military Man: Oh Dear, How Sad, Never Mind
static.klipy.com
July 15, 2026 at 9:07 PM
Arg2 Eng 1.
Oh dear how sad, never mind.
Oh dear how sad, never mind.
I like how named and anonymous functions are symmetrical in their syntax.
Compare
let fun_name arg1 arg2 = …
fun arg1 arg2 ->
Not having names is actually fun!
So anonymous function is just like the ordinary one except you use a different keyword and don’t write name!
(and replace = with ->)
Compare
let fun_name arg1 arg2 = …
fun arg1 arg2 ->
Not having names is actually fun!
So anonymous function is just like the ordinary one except you use a different keyword and don’t write name!
(and replace = with ->)
November 19, 2024 at 3:05 PM
I like how named and anonymous functions are symmetrical in their syntax.
Compare
let fun_name arg1 arg2 = …
fun arg1 arg2 ->
Not having names is actually fun!
So anonymous function is just like the ordinary one except you use a different keyword and don’t write name!
(and replace = with ->)
Compare
let fun_name arg1 arg2 = …
fun arg1 arg2 ->
Not having names is actually fun!
So anonymous function is just like the ordinary one except you use a different keyword and don’t write name!
(and replace = with ->)
TIL — JavaScript default parameters can use earlier defined parameters. 🤯
Alex MacArthur shared how to use this feature to write the least readable `reduce` loops ever. 😅
macarthur.me/posts/siblin...
Alex MacArthur shared how to use this feature to write the least readable `reduce` loops ever. 😅
macarthur.me/posts/siblin...
![Two JavaScript code snippets.
```
// reuse `arg1` and set it as `arg2`
function myFunc(arg1, arg2 = arg1) {
console.log(arg1, arg2);
}
myFunc("arg1!"); // "arg1!" "arg1!"
```
```
const numbers = [1, 2, 3];
// don't do this 😅
const total = numbers.reduce(
(acc, value, _index, _array, result = acc + value) => result
);
```](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:w2nz7d2phfbrzyembuw7oxjj/bafkreiajovrkpbsfrfl3dw4si4kp3txl2mgn4ox7hpxubjoyqojz4ar3fy)
November 3, 2024 at 7:43 PM
TIL — JavaScript default parameters can use earlier defined parameters. 🤯
Alex MacArthur shared how to use this feature to write the least readable `reduce` loops ever. 😅
macarthur.me/posts/siblin...
Alex MacArthur shared how to use this feature to write the least readable `reduce` loops ever. 😅
macarthur.me/posts/siblin...
Where were you when you first learned about the cursed syntax?
October 31, 2024 at 4:32 PM
Where were you when you first learned about the cursed syntax?
would you ever recommend/consider defining functions through these lambdas?
e.g
let fun_name = fun arg1 arg2 -> ...
instead of
let fun_name arg1 arg2 = ...
e.g
let fun_name = fun arg1 arg2 -> ...
instead of
let fun_name arg1 arg2 = ...
November 20, 2024 at 12:01 AM
would you ever recommend/consider defining functions through these lambdas?
e.g
let fun_name = fun arg1 arg2 -> ...
instead of
let fun_name arg1 arg2 = ...
e.g
let fun_name = fun arg1 arg2 -> ...
instead of
let fun_name arg1 arg2 = ...
If I had stayed in virology, I would have been an early mover in the field now named "nascent-peptide regulatory uORFs." Examples of this are: fungal Arg2, CPA1, mammalian ATF4 regulatory uORFs, bacterial SecM stalling peptides.
My work was among the early mechanistic demonstrations in viruses.
My work was among the early mechanistic demonstrations in viruses.
March 9, 2026 at 2:24 PM
If I had stayed in virology, I would have been an early mover in the field now named "nascent-peptide regulatory uORFs." Examples of this are: fungal Arg2, CPA1, mammalian ATF4 regulatory uORFs, bacterial SecM stalling peptides.
My work was among the early mechanistic demonstrations in viruses.
My work was among the early mechanistic demonstrations in viruses.
Okay you know all those APIs like
f = \(..., .arg1 = "foo", .arg2 = "bar") { body }
with names like .arg1 or ARG1 or whatnot to mitigate collisions with names in `...` - which is ugly (and can still clash!)
But what about:
f = \(...) \(arg1 = "foo", arg2 = "bar") { body }
= no way to clash!
f = \(..., .arg1 = "foo", .arg2 = "bar") { body }
with names like .arg1 or ARG1 or whatnot to mitigate collisions with names in `...` - which is ugly (and can still clash!)
But what about:
f = \(...) \(arg1 = "foo", arg2 = "bar") { body }
= no way to clash!
February 27, 2025 at 7:37 AM
Okay you know all those APIs like
f = \(..., .arg1 = "foo", .arg2 = "bar") { body }
with names like .arg1 or ARG1 or whatnot to mitigate collisions with names in `...` - which is ugly (and can still clash!)
But what about:
f = \(...) \(arg1 = "foo", arg2 = "bar") { body }
= no way to clash!
f = \(..., .arg1 = "foo", .arg2 = "bar") { body }
with names like .arg1 or ARG1 or whatnot to mitigate collisions with names in `...` - which is ugly (and can still clash!)
But what about:
f = \(...) \(arg1 = "foo", arg2 = "bar") { body }
= no way to clash!
do_smth(arg)
do_smth(arg1, arg2)
do_smth(one, two, three)
do_smth(potato, potato [, arg1, arg2])
це просто дурка
do_smth(arg1, arg2)
do_smth(one, two, three)
do_smth(potato, potato [, arg1, arg2])
це просто дурка
July 30, 2024 at 12:10 PM
do_smth(arg)
do_smth(arg1, arg2)
do_smth(one, two, three)
do_smth(potato, potato [, arg1, arg2])
це просто дурка
do_smth(arg1, arg2)
do_smth(one, two, three)
do_smth(potato, potato [, arg1, arg2])
це просто дурка
i can unpack some more. there is a pattern where you can name a function and pass its additional args on the side like
lapply(list, f, arg2, arg3)
purrr::map(list, f, arg2, arg3)
but that pattern has been deprecated in across()
lapply(list, f, arg2, arg3)
purrr::map(list, f, arg2, arg3)
but that pattern has been deprecated in across()
April 4, 2025 at 8:15 PM
i can unpack some more. there is a pattern where you can name a function and pass its additional args on the side like
lapply(list, f, arg2, arg3)
purrr::map(list, f, arg2, arg3)
but that pattern has been deprecated in across()
lapply(list, f, arg2, arg3)
purrr::map(list, f, arg2, arg3)
but that pattern has been deprecated in across()
open System.Diagnostics
Process.Start("pathtoprogram","arg1 arg2")
Process.Start("pathtoprogram","arg1 arg2")
December 10, 2024 at 4:50 PM
open System.Diagnostics
Process.Start("pathtoprogram","arg1 arg2")
Process.Start("pathtoprogram","arg1 arg2")
Programming deprecations are always stuff like:
We're removing simple(arg1) in favor of ComplexFactory.Builder(arg1, arg2).compile().show(arg3)
And never the other way around.
We're removing simple(arg1) in favor of ComplexFactory.Builder(arg1, arg2).compile().show(arg3)
And never the other way around.
June 18, 2025 at 4:31 PM
Programming deprecations are always stuff like:
We're removing simple(arg1) in favor of ComplexFactory.Builder(arg1, arg2).compile().show(arg3)
And never the other way around.
We're removing simple(arg1) in favor of ComplexFactory.Builder(arg1, arg2).compile().show(arg3)
And never the other way around.
I suspected this for years, then this ARG2 came along & provided some potential evidence supporting that idea. Plus it might explain why Toby released these two chapters together. And maybe the improved ability to go between chapters due to LTS updates feeds into that.
May 10, 2025 at 5:53 AM
I suspected this for years, then this ARG2 came along & provided some potential evidence supporting that idea. Plus it might explain why Toby released these two chapters together. And maybe the improved ability to go between chapters due to LTS updates feeds into that.
Я з тих часів коли RPC використовували у форматі { func_name, arg1, arg2 } в одну хвіртку 🤣
January 17, 2025 at 12:38 PM
Я з тих часів коли RPC використовували у форматі { func_name, arg1, arg2 } в одну хвіртку 🤣
Noticing a common cause of bugs for me:
def foo(arg1, arg2):
if arg1 == 'special_case':
return foo('other_case', transform(arg2))
else:
...
This works, but then I'll add another argument to foo(), and forget to pass it when I call foo() in the special case.
def foo(arg1, arg2):
if arg1 == 'special_case':
return foo('other_case', transform(arg2))
else:
...
This works, but then I'll add another argument to foo(), and forget to pass it when I call foo() in the special case.
February 14, 2025 at 4:50 PM
Noticing a common cause of bugs for me:
def foo(arg1, arg2):
if arg1 == 'special_case':
return foo('other_case', transform(arg2))
else:
...
This works, but then I'll add another argument to foo(), and forget to pass it when I call foo() in the special case.
def foo(arg1, arg2):
if arg1 == 'special_case':
return foo('other_case', transform(arg2))
else:
...
This works, but then I'll add another argument to foo(), and forget to pass it when I call foo() in the special case.
An LLM fetches the content and gets the tool definitions shoved into it's context on the next call. If it "decides" to invoke a tool, it essentially writes out "tool_name(arg1, arg2)" and the surrounding system invokes it and appends the result to the next call.
April 18, 2025 at 11:12 PM
An LLM fetches the content and gets the tool definitions shoved into it's context on the next call. If it "decides" to invoke a tool, it essentially writes out "tool_name(arg1, arg2)" and the surrounding system invokes it and appends the result to the next call.
this week i discovered someone has ported fennel to computercraft and i've been having a blast learning lisp syntax by programming turtles
modrinth.com/modpack/pyth...
modrinth.com/modpack/pyth...
![(local turtle _G.turtle)
(fn step [n move ?dig]
;; "dig" and "move" are method calls
(if (= 0 n) true
(do
(when (not ((. turtle move)))
(when ?dig
((. turtle ?dig)))
(if (not ((. turtle move)))
false))
(step (- n 1) move ?dig))))
(fn go [?arg1 ?arg2]
(var ?n 1)
(var ?dir :forward)
(each [_ a (ipairs [?arg1 ?arg2])]
(if (= :number (type (tonumber a)))
(set ?n (tonumber a))
(set ?dir (or a :forward))))
(let [n ?n
dir ?dir]
(case dir
:up (step n :up :digUp)
:down (step n :down :digDown)
:back (step n :back)
:left (do
(turtle.turnLeft)
(step n :forward :dig))
:right (do
(turtle.turnRight)
(step n :forward :dig))
(where (or :forward nil))
(step n :forward :dig)
___ (print "valid directions:
up, down, back, left, right, forward")
))
(print (.. "dir: " ?dir ", n: " ?n)))
(go ...)](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:zunc3ki5hdrgqadatljl7znn/bafkreiatwlbod4wois6vqd6uc24q46b3ik3okwtjhqrqxk5lwffab6eijy)
January 15, 2025 at 1:22 PM
this week i discovered someone has ported fennel to computercraft and i've been having a blast learning lisp syntax by programming turtles
modrinth.com/modpack/pyth...
modrinth.com/modpack/pyth...
weirdly my brain doesn't work half as hard to understand these functions. it's all just (function-name arg1 arg2) no matter where you are or what you're doing. you don't suddenly call a function by starting with an open curly brace or define a tuple with a parenthesis
December 30, 2024 at 6:08 AM
weirdly my brain doesn't work half as hard to understand these functions. it's all just (function-name arg1 arg2) no matter where you are or what you're doing. you don't suddenly call a function by starting with an open curly brace or define a tuple with a parenthesis
"true" is kind of weird? normally comparators return a number, such that if the args were numbers then "return arg1 - arg2" should sort ascending. The return value being negative means sort arg1 before arg2, which happens when arg1 is smaller than arg2
June 4, 2026 at 1:22 AM
"true" is kind of weird? normally comparators return a number, such that if the args were numbers then "return arg1 - arg2" should sort ascending. The return value being negative means sort arg1 before arg2, which happens when arg1 is smaller than arg2