20 minutes in and we’re implementing macros and tailcall optimization (gonna skip screenshots from now on and just record notes and share the full session when we’re done—for some definition of done)
June 2, 2026 at 6:34 AM
20 minutes in and we’re implementing macros and tailcall optimization (gonna skip screenshots from now on and just record notes and share the full session when we’re done—for some definition of done)
ahh really good work on the TailCall() demo
April 25, 2024 at 3:46 PM
ahh really good work on the TailCall() demo
Taking inspiration from the ridiculous microbenchmark, made a LLM generate functions for generating actual nested loops functions after feeding it the #RStats language definition,Luke Cherney's codetools and some gratuitous #tailcall for the connaisseurs
sounkou-bioinfo.github.io/ridiculousBu...
sounkou-bioinfo.github.io/ridiculousBu...
August 14, 2025 at 9:42 PM
Taking inspiration from the ridiculous microbenchmark, made a LLM generate functions for generating actual nested loops functions after feeding it the #RStats language definition,Luke Cherney's codetools and some gratuitous #tailcall for the connaisseurs
sounkou-bioinfo.github.io/ridiculousBu...
sounkou-bioinfo.github.io/ridiculousBu...
tailcallhq / tailcall: A high-performance GraphQL platform ★948 https://github.com/tailcallhq/tailcall
tailcallhq / tailcall
A high-performance GraphQL platform
github.com
February 3, 2024 at 8:44 AM
tailcallhq / tailcall: A high-performance GraphQL platform ★948 https://github.com/tailcallhq/tailcall
#rstats #adventofcode tail recursion for day 07 b
![r code that uses a Tailcall()
#' @rdname day07
#' @export
f07b_add_mul_concat <- function(x) {
crunch <- function(xs, target = NULL) {
crunch_iter <- function(current, rest, target = NULL) {
if (length(rest) == 0) {
current
} else {
r <- rest[1]
# avoid conversions
concat <- current * 10 ^ nchar(r) + r
current <- c(current + r, current * r, concat)
# discard dead-ends
if (!is.null(target)) {
current <- current[current <= target]
}
rest <- rest[-1]
Tailcall(crunch_iter, current, rest)
}
}
crunch_iter(xs[1], xs[-1])
}
l <- f07_helper(x)
l$parts |>
map2(l$targets, crunch) |>
map2(l$targets, function(x, y) y[is.element(y, x)]) |>
unlist() |>
sum()
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:tpgnsvgqsu5b752uud3wmtja/bafkreicprvgpfyqmnscvug3ackhbpngrhcr76kjzqsyrub6fdu5n7n3cda)
December 7, 2024 at 9:23 PM
#rstats #adventofcode tail recursion for day 07 b
Make n high enough and you’ll get the famed ‘stack overflow’. I think its about 10000. That’s why you don’t see it in the wild.
However there is s technique to avoid the overflow, see Tailcall().
However there is s technique to avoid the overflow, see Tailcall().
November 6, 2025 at 8:36 PM
Make n high enough and you’ll get the famed ‘stack overflow’. I think its about 10000. That’s why you don’t see it in the wild.
However there is s technique to avoid the overflow, see Tailcall().
However there is s technique to avoid the overflow, see Tailcall().
After seeig some recent commits on the #Rstats source tree around R_TailCall github.com/r-devel/r-sv... , this post from stackoverflow was quite interesting to read #esoterica stackoverflow.com/questions/78...
Optimization of tail recursion in R
Since version 4.4.0, R supports tail recursion through the Tailcall function. I automatically assumed that it means an improvement for codes that use tail recursion.
However, consider the following
stackoverflow.com
May 6, 2026 at 1:25 AM
After seeig some recent commits on the #Rstats source tree around R_TailCall github.com/r-devel/r-sv... , this post from stackoverflow was quite interesting to read #esoterica stackoverflow.com/questions/78...
i was wondering how the recursive iteration stuff works out on javascript since you don't get guaranteed tailcall optimization. But turns out, you should use the `gleam/list` or `gleam/iterator` modules instead anyway. though tailcall optimization works great on the beam from what i can tell
March 14, 2025 at 6:33 AM
i was wondering how the recursive iteration stuff works out on javascript since you don't get guaranteed tailcall optimization. But turns out, you should use the `gleam/list` or `gleam/iterator` modules instead anyway. though tailcall optimization works great on the beam from what i can tell
![In OCaml, TCO is guaranteed. Ever since its inception, Cameleers have unanimously agreed to guarantee the optimisation of tail-calls. While the compiler's support for TCO has been a thing from the beginning, an attribute, [@tailcall] was later added to help users ensure that their calls are in tail position.](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:qcjmkxk5v4o33pd4z7na6wmw/bafkreigpl3244wvbfkxp4wvihauxijewqtzck6dykrzvktfwlcxyooidfq)
Yes it is, and we don't need a specific keyword.
On the other hand there is currently no guarantee of tail-call optimization I think.
A RFC is in progress about this: github.com/rust-lang/rf...
And there is a crate: docs.rs/tailcall/lat...
So I'm for now a bit lost as a functional programmer...
On the other hand there is currently no guarantee of tail-call optimization I think.
A RFC is in progress about this: github.com/rust-lang/rf...
And there is a crate: docs.rs/tailcall/lat...
So I'm for now a bit lost as a functional programmer...
July 18, 2025 at 1:45 PM
Yes it is, and we don't need a specific keyword.
On the other hand there is currently no guarantee of tail-call optimization I think.
A RFC is in progress about this: github.com/rust-lang/rf...
And there is a crate: docs.rs/tailcall/lat...
So I'm for now a bit lost as a functional programmer...
On the other hand there is currently no guarantee of tail-call optimization I think.
A RFC is in progress about this: github.com/rust-lang/rf...
And there is a crate: docs.rs/tailcall/lat...
So I'm for now a bit lost as a functional programmer...
dev version of #rstats has experimental TailCall support. Here's what that means. Suppose we have a recursive function for reversing a function. The recursive idea is that you reverse a vector by moving the first element to the start of a new vector until you are all out of elements.
January 4, 2024 at 6:56 PM
dev version of #rstats has experimental TailCall support. Here's what that means. Suppose we have a recursive function for reversing a function. The recursive idea is that you reverse a vector by moving the first element to the start of a new vector until you are all out of elements.
Here is the function with Tailcall(). Only 1 line changes
tc_rev <- function(xs) {
tc_rev_iter <- function(acc, xs) {
if (length(xs) == 0) {
acc
} else {
acc <- c(xs[1], acc)
# recursion!!!
Tailcall(tc_rev_iter, acc, xs[-1])
}
}
tc_rev_iter(xs[0], xs)
}
tc_rev <- function(xs) {
tc_rev_iter <- function(acc, xs) {
if (length(xs) == 0) {
acc
} else {
acc <- c(xs[1], acc)
# recursion!!!
Tailcall(tc_rev_iter, acc, xs[-1])
}
}
tc_rev_iter(xs[0], xs)
}
January 4, 2024 at 7:06 PM
Here is the function with Tailcall(). Only 1 line changes
tc_rev <- function(xs) {
tc_rev_iter <- function(acc, xs) {
if (length(xs) == 0) {
acc
} else {
acc <- c(xs[1], acc)
# recursion!!!
Tailcall(tc_rev_iter, acc, xs[-1])
}
}
tc_rev_iter(xs[0], xs)
}
tc_rev <- function(xs) {
tc_rev_iter <- function(acc, xs) {
if (length(xs) == 0) {
acc
} else {
acc <- c(xs[1], acc)
# recursion!!!
Tailcall(tc_rev_iter, acc, xs[-1])
}
}
tc_rev_iter(xs[0], xs)
}
Scaling #GraphQL from thousands of requests to 500M/min! Watch Tushar Mathur break down how their team of 1000+ engineers handled massive growth without federation, plus unveil an open-source solution for optimal API design. youtu.be/RVBxFi88H1o
Lessons from Scaling GraphQL to Half a Billion Requests per Minute
Tailcall CEO & Founder @tusharmath shares the scaling challenges they faced within a hyper-growth startup, focusing on the infrastructure, organizational ch...
www.youtube.com
April 7, 2025 at 3:34 PM
Scaling #GraphQL from thousands of requests to 500M/min! Watch Tushar Mathur break down how their team of 1000+ engineers handled massive growth without federation, plus unveil an open-source solution for optimal API design. youtu.be/RVBxFi88H1o
A tail-call interpreter in (nightly) Rust
https://www.mattkeeter.com/blog/2026-04-05-tailcall/
https://news.ycombinator.com/item?id=47650312
https://www.mattkeeter.com/blog/2026-04-05-tailcall/
https://news.ycombinator.com/item?id=47650312
A tail-call interpreter in (nightly) Rust
Exploring tail-call-style interpreter implementation with an optimized Uxn emulator, on ARM, x86, and WebAssembly
www.mattkeeter.com
April 5, 2026 at 9:00 PM
A tail-call interpreter in (nightly) Rust
https://www.mattkeeter.com/blog/2026-04-05-tailcall/
https://news.ycombinator.com/item?id=47650312
https://www.mattkeeter.com/blog/2026-04-05-tailcall/
https://news.ycombinator.com/item?id=47650312
lying in bed, about to fall asleep, my mind blurts out, "hey do you think the experimental tail call optimization in #RStats devel works on mutual recursion?" Let's see... Yes!
![Screenshot of the canonical is_even()/is_odd() example working with Tailcall().
# Naive mutual recursion
naive_is_even <- function(n) {
# Include the number of frames to show position on call stack
if (n == 0) list(TRUE, sys.nframe()) else naive_is_odd(n - 1)
}
naive_is_odd <- function(n) {
if (n == 0) list(FALSE, sys.nframe()) else naive_is_even(n - 1)
}
naive_is_odd(30)
#> [[1]]
#> [1] FALSE
#>
#> [[2]]
#> [1] 31
# Tailcall mutual recursion
# bc the parameters of each function are the same (`n`),
# the jump should work...
is_even <- function(n) {
if (n == 0) list(TRUE, sys.nframe()) else Tailcall(is_odd, n - 1)
}
is_odd <- function(n) {
if (n == 0) list(FALSE, sys.nframe()) else Tailcall(is_even, n - 1)
}
is_odd(30)
#> [[1]]
#> [1] FALSE
#>
#> [[2]]
#> [1] 1
naive_is_even(10000)[[1]]
#> Error: C stack usage 15923408 is too close to the limit
is_even(10000)[[1]]
#> [1] TRUE](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:tpgnsvgqsu5b752uud3wmtja/bafkreidbpopukxflihyprlppgvl2uu4oxhmipkged6acpdwfl7eayuacfe)
January 5, 2024 at 2:41 PM
lying in bed, about to fall asleep, my mind blurts out, "hey do you think the experimental tail call optimization in #RStats devel works on mutual recursion?" Let's see... Yes!
JIT: Count `EXPLICITTHIS` args correctly in tailcall stress (114368) https://github.com/dotnet/runtime/pull/114368
JIT: Count `EXPLICITTHIS` args correctly in tailcall stress by jakobbotsch · Pull Request #114368 · dotnet/runtime
The validation that checks if tailcall stress is allowed to kick in was not handling EXPLICITTHIS correctly.
Fix #114213
github.com
April 8, 2025 at 8:31 AM
JIT: Count `EXPLICITTHIS` args correctly in tailcall stress (114368) https://github.com/dotnet/runtime/pull/114368
JIT: Disable recursive tailcall to loop opt in OSR methods (113625) https://github.com/dotnet/runtime/pull/113625
JIT: Disable recursive tailcall to loop opt in OSR methods by jakobbotsch · Pull Request #113625 · dotnet/runtime
OSR is meant to be used when we can't escape, but these tailcalls are natural points where we're actually able to escape. So prefer call counting + tiering + potential transition into the t...
github.com
March 17, 2025 at 8:11 PM
JIT: Disable recursive tailcall to loop opt in OSR methods (113625) https://github.com/dotnet/runtime/pull/113625
JIT: Consider moving tailcall-to-loop opt to happen earlier (113623) https://github.com/dotnet/runtime/issues/113623
JIT: Consider moving tailcall-to-loop opt to happen earlier · Issue #113623 · dotnet/runtime
Currently the tailcall-to-loop opt happens in morph, and it creates a loop back to the first IL block. That seems wrong because other phases (like physical promotion) may have introduced IR in the ...
github.com
March 17, 2025 at 8:11 PM
JIT: Consider moving tailcall-to-loop opt to happen earlier (113623) https://github.com/dotnet/runtime/issues/113623
see also Recall() and Tailcall()
April 1, 2025 at 6:37 PM
see also Recall() and Tailcall()
Design a GraphQL Schema So Good, It'll Make REST APIs Cry Discussion
Design a GraphQL Schema So Good, It'll Make REST APIs Cry | Tailcall
Learn how to design a robust, scalable GraphQL schema. Best practices and considerations to build a schema that can evolve with your application's needs.
tailcall.run
July 17, 2024 at 9:00 AM
Design a GraphQL Schema So Good, It'll Make REST APIs Cry Discussion
A tail-call interpreter in (nightly) Rust
https://www.mattkeeter.com/blog/2026-04-05-tailcall/
[comments] [28 points]
https://www.mattkeeter.com/blog/2026-04-05-tailcall/
[comments] [28 points]
April 5, 2026 at 5:03 PM
A tail-call interpreter in (nightly) Rust
https://www.mattkeeter.com/blog/2026-04-05-tailcall/
[comments] [28 points]
https://www.mattkeeter.com/blog/2026-04-05-tailcall/
[comments] [28 points]
CVE-2025-38723 - LoongArch: BPF: Fix jump offset calculation in tailcall
CVE ID : CVE-2025-38723
Published : Sept. 4, 2025, 4:15 p.m. | 56 minutes ago
Description : In the Linux kernel, the following vulnerability has been resolved:
LoongArch: BPF: Fix jump offset calcu...
CVE ID : CVE-2025-38723
Published : Sept. 4, 2025, 4:15 p.m. | 56 minutes ago
Description : In the Linux kernel, the following vulnerability has been resolved:
LoongArch: BPF: Fix jump offset calcu...
CVE-2025-38723 - LoongArch: BPF: Fix jump offset calculation in tailcall
In the Linux kernel, the following vulnerability has been resolved: LoongArch: BPF: Fix jump offset calculation in tailcall The extra pass of bpf_int_jit_compile() skips JIT context initialization which essentially skips offset calculation leaving out_offset = -1, so the jmp_offset in emit_bpf_tail_call is calculated by "#define jmp_offset (out_offset - (cur_offset))" is …
cvefeed.io
September 4, 2025 at 7:30 PM
CVE-2025-38723 - LoongArch: BPF: Fix jump offset calculation in tailcall
CVE ID : CVE-2025-38723
Published : Sept. 4, 2025, 4:15 p.m. | 56 minutes ago
Description : In the Linux kernel, the following vulnerability has been resolved:
LoongArch: BPF: Fix jump offset calcu...
CVE ID : CVE-2025-38723
Published : Sept. 4, 2025, 4:15 p.m. | 56 minutes ago
Description : In the Linux kernel, the following vulnerability has been resolved:
LoongArch: BPF: Fix jump offset calcu...