From abd9795b0cc8eca01117d3077c360056252431ca Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sun, 15 Nov 2026 05:47:39 +0100 Subject: [PATCH 1/5] Landing: Julia cells run (go-notebook main, go-embedded-julia v0.15.0) The notebook blurb still said Julia cells do not run (milestone M3). They run on go-embedded-julia's interpreter in one kernel, from a digest-pinned Base image, with R's limits; variables stay in Julia; the playground does not run them. Claims are copied from go-notebook/notebook#49. Playground blurb unchanged: its Julia cells are still checked, not run. Co-Authored-By: Claude Sonnet 5.5 --- hugo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hugo.toml b/hugo.toml index b136505..4c71226 100644 --- a/hugo.toml +++ b/hugo.toml @@ -41,7 +41,7 @@ disableKinds = ['taxonomy', 'term', 'rss', 'sitemap', '404'] name = "notebook" kind = "kernel · command" href = "https://github.com/go-notebook/notebook" - blurb = "The kernel, the notebook command (run, html, watch, serve, irb) and the HTML export: format parses the Markdown, analysis builds the dependency graph from the syntax, gen writes the Go program, kernel compiles and drives it through runtime and keeps results and values, export writes the page. Ruby cells (```ruby) run on rbgo, a Ruby written in Go, with the go-scikit bindings (Stats, Special, Optimize, Integrate, DataFrame, Plot, NDArray), and share their variables with the Go cells. --timeout and --memory stop a runaway cell in either language. notebook irb is the same Ruby as an interactive session, as irb: => inspect after each input, _, multi-line input decided by rbgo's parser, Tab completion and history in a pure-Go line editor (go-ruby-reline), each input in a worker that --timeout, --memory or Ctrl-C can stop without losing the prompt, and --save to keep the session as a notebook. More → Julia cells (```julia) are parsed with go-embedded-julia's parser and checked: syntax errors at their line with julia's message, names in the dependency graph under Julia's scope rules. They do not run yet (go-embedded-julia's runtime is milestone M3): the cells that read one are blocked and say so. More → R cells (```r) are parsed with go-embedded-r's parser, identical to R 4.6.2 on R's own sources, and checked in the same way: syntax errors at their line in R's words, names in the graph, and a cell that cannot be analysed from its text (<<-, eval, library) depending on every cell above it. They run on go-embedded-r's evaluator in one shared environment (v0.10.0), and since v0.12.0 each cell is bounded: 512 MiB of vectors, 50 million steps, 30 s. The browser playground runs them too (playground v0.14.0), in its second core, with R variables kept apart from the other languages: 512 MiB, 20 million steps, 10 s per cell, and a crash restarts the core with a message on the cell. More → Fortran cells (```fortran) are checked and run with go-embedded-fortran (since go-notebook v0.17.0, go-embedded-fortran v0.17.0: its sema session for the names and errors, its eval.Session for the running; free form, implicit typing off) and highlighted with go-rouge's fortran lexer. The Fortran cells share one session: a cell sees the variables (with the values the earlier cells left), procedures, modules and derived types of the Fortran cells before it. Fortran variables stay in Fortran, as R's do: they are not shared with Go, Ruby, Julia, R or C cells in either direction yet. A cell may make at most 2^32 loop iterations and calls and run 30 s, and a failure is reported at its line and column. The playground does not link the Fortran runtime yet. More →" + blurb = "The kernel, the notebook command (run, html, watch, serve, irb) and the HTML export: format parses the Markdown, analysis builds the dependency graph from the syntax, gen writes the Go program, kernel compiles and drives it through runtime and keeps results and values, export writes the page. Ruby cells (```ruby) run on rbgo, a Ruby written in Go, with the go-scikit bindings (Stats, Special, Optimize, Integrate, DataFrame, Plot, NDArray), and share their variables with the Go cells. --timeout and --memory stop a runaway cell in either language. notebook irb is the same Ruby as an interactive session, as irb: => inspect after each input, _, multi-line input decided by rbgo's parser, Tab completion and history in a pure-Go line editor (go-ruby-reline), each input in a worker that --timeout, --memory or Ctrl-C can stop without losing the prompt, and --save to keep the session as a notebook. More → Julia cells (```julia) are parsed with go-embedded-julia's parser and checked (syntax errors at their line with julia's message, names in the dependency graph under Julia's scope rules), and run by its interpreter (v0.15.0) in one kernel shared by the Julia cells: a global or a function a cell defines is there in the next one, and a failure is julia's own text. The kernel boots from a prebuilt Base image, fetched on the first Julia cell and loaded only if its SHA-256 is the pinned one (cold start about a second). A cell may run 30 s, 50 million statements and 512 MiB of array elements. Julia variables stay in Julia, as R's do: they are not shared with Go, Ruby, R, C or Fortran cells in either direction yet. Known limitations: a loop at the top level of a cell cannot update a global (go-embedded-julia#54). The playground does not run Julia cells yet. More → R cells (```r) are parsed with go-embedded-r's parser, identical to R 4.6.2 on R's own sources, and checked in the same way: syntax errors at their line in R's words, names in the graph, and a cell that cannot be analysed from its text (<<-, eval, library) depending on every cell above it. They run on go-embedded-r's evaluator in one shared environment (v0.10.0), and since v0.12.0 each cell is bounded: 512 MiB of vectors, 50 million steps, 30 s. The browser playground runs them too (playground v0.14.0), in its second core, with R variables kept apart from the other languages: 512 MiB, 20 million steps, 10 s per cell, and a crash restarts the core with a message on the cell. More → Fortran cells (```fortran) are checked and run with go-embedded-fortran (since go-notebook v0.17.0, go-embedded-fortran v0.17.0: its sema session for the names and errors, its eval.Session for the running; free form, implicit typing off) and highlighted with go-rouge's fortran lexer. The Fortran cells share one session: a cell sees the variables (with the values the earlier cells left), procedures, modules and derived types of the Fortran cells before it. Fortran variables stay in Fortran, as R's do: they are not shared with Go, Ruby, Julia, R or C cells in either direction yet. A cell may make at most 2^32 loop iterations and calls and run 30 s, and a failure is reported at its line and column. The playground does not link the Fortran runtime yet. More →" [[params.repos]] name = "playground" kind = "wasm · page" From 12af49f8ca6500ee74f98b41c3dd1e2e2ba746d7 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sun, 15 Nov 2026 06:27:43 +0100 Subject: [PATCH 2/5] Landing: the Julia memory budget and the playground's wording (review of notebook#49) Co-Authored-By: Claude Sonnet 5.5 --- hugo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hugo.toml b/hugo.toml index 4c71226..e32af46 100644 --- a/hugo.toml +++ b/hugo.toml @@ -41,7 +41,7 @@ disableKinds = ['taxonomy', 'term', 'rss', 'sitemap', '404'] name = "notebook" kind = "kernel · command" href = "https://github.com/go-notebook/notebook" - blurb = "The kernel, the notebook command (run, html, watch, serve, irb) and the HTML export: format parses the Markdown, analysis builds the dependency graph from the syntax, gen writes the Go program, kernel compiles and drives it through runtime and keeps results and values, export writes the page. Ruby cells (```ruby) run on rbgo, a Ruby written in Go, with the go-scikit bindings (Stats, Special, Optimize, Integrate, DataFrame, Plot, NDArray), and share their variables with the Go cells. --timeout and --memory stop a runaway cell in either language. notebook irb is the same Ruby as an interactive session, as irb: => inspect after each input, _, multi-line input decided by rbgo's parser, Tab completion and history in a pure-Go line editor (go-ruby-reline), each input in a worker that --timeout, --memory or Ctrl-C can stop without losing the prompt, and --save to keep the session as a notebook. More → Julia cells (```julia) are parsed with go-embedded-julia's parser and checked (syntax errors at their line with julia's message, names in the dependency graph under Julia's scope rules), and run by its interpreter (v0.15.0) in one kernel shared by the Julia cells: a global or a function a cell defines is there in the next one, and a failure is julia's own text. The kernel boots from a prebuilt Base image, fetched on the first Julia cell and loaded only if its SHA-256 is the pinned one (cold start about a second). A cell may run 30 s, 50 million statements and 512 MiB of array elements. Julia variables stay in Julia, as R's do: they are not shared with Go, Ruby, R, C or Fortran cells in either direction yet. Known limitations: a loop at the top level of a cell cannot update a global (go-embedded-julia#54). The playground does not run Julia cells yet. More → R cells (```r) are parsed with go-embedded-r's parser, identical to R 4.6.2 on R's own sources, and checked in the same way: syntax errors at their line in R's words, names in the graph, and a cell that cannot be analysed from its text (<<-, eval, library) depending on every cell above it. They run on go-embedded-r's evaluator in one shared environment (v0.10.0), and since v0.12.0 each cell is bounded: 512 MiB of vectors, 50 million steps, 30 s. The browser playground runs them too (playground v0.14.0), in its second core, with R variables kept apart from the other languages: 512 MiB, 20 million steps, 10 s per cell, and a crash restarts the core with a message on the cell. More → Fortran cells (```fortran) are checked and run with go-embedded-fortran (since go-notebook v0.17.0, go-embedded-fortran v0.17.0: its sema session for the names and errors, its eval.Session for the running; free form, implicit typing off) and highlighted with go-rouge's fortran lexer. The Fortran cells share one session: a cell sees the variables (with the values the earlier cells left), procedures, modules and derived types of the Fortran cells before it. Fortran variables stay in Fortran, as R's do: they are not shared with Go, Ruby, Julia, R or C cells in either direction yet. A cell may make at most 2^32 loop iterations and calls and run 30 s, and a failure is reported at its line and column. The playground does not link the Fortran runtime yet. More →" + blurb = "The kernel, the notebook command (run, html, watch, serve, irb) and the HTML export: format parses the Markdown, analysis builds the dependency graph from the syntax, gen writes the Go program, kernel compiles and drives it through runtime and keeps results and values, export writes the page. Ruby cells (```ruby) run on rbgo, a Ruby written in Go, with the go-scikit bindings (Stats, Special, Optimize, Integrate, DataFrame, Plot, NDArray), and share their variables with the Go cells. --timeout and --memory stop a runaway cell in either language. notebook irb is the same Ruby as an interactive session, as irb: => inspect after each input, _, multi-line input decided by rbgo's parser, Tab completion and history in a pure-Go line editor (go-ruby-reline), each input in a worker that --timeout, --memory or Ctrl-C can stop without losing the prompt, and --save to keep the session as a notebook. More → Julia cells (```julia) are parsed with go-embedded-julia's parser and checked (syntax errors at their line with julia's message, names in the dependency graph under Julia's scope rules), and run by its interpreter (v0.15.0) in one kernel shared by the Julia cells: a global or a function a cell defines is there in the next one, and a failure is julia's own text. The kernel boots from a prebuilt Base image, fetched on the first Julia cell and loaded only if its SHA-256 is the pinned one (cold start about a second). A cell may run 30 s and 50 million statements, within a memory budget of 512 MiB counted as 16 bytes per array element (a floor, not the heap: strings are not counted, and one array may have at most 2^24 elements). Julia variables stay in Julia, as R's do: they are not shared with Go, Ruby, R, C or Fortran cells in either direction yet. Known limitations: a loop at the top level of a cell cannot update a global (go-embedded-julia#54). The playground checks Julia cells and does not run them (Julia cells run in go-notebook, not yet in the browser). More → R cells (```r) are parsed with go-embedded-r's parser, identical to R 4.6.2 on R's own sources, and checked in the same way: syntax errors at their line in R's words, names in the graph, and a cell that cannot be analysed from its text (<<-, eval, library) depending on every cell above it. They run on go-embedded-r's evaluator in one shared environment (v0.10.0), and since v0.12.0 each cell is bounded: 512 MiB of vectors, 50 million steps, 30 s. The browser playground runs them too (playground v0.14.0), in its second core, with R variables kept apart from the other languages: 512 MiB, 20 million steps, 10 s per cell, and a crash restarts the core with a message on the cell. More → Fortran cells (```fortran) are checked and run with go-embedded-fortran (since go-notebook v0.17.0, go-embedded-fortran v0.17.0: its sema session for the names and errors, its eval.Session for the running; free form, implicit typing off) and highlighted with go-rouge's fortran lexer. The Fortran cells share one session: a cell sees the variables (with the values the earlier cells left), procedures, modules and derived types of the Fortran cells before it. Fortran variables stay in Fortran, as R's do: they are not shared with Go, Ruby, Julia, R or C cells in either direction yet. A cell may make at most 2^32 loop iterations and calls and run 30 s, and a failure is reported at its line and column. The playground does not link the Fortran runtime yet. More →" [[params.repos]] name = "playground" kind = "wasm · page" From 31ba0fe0d475c8f24b36ee6217949a7fffba74f1 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sun, 15 Nov 2026 09:55:28 +0100 Subject: [PATCH 3/5] Landing: Julia cells run since go-notebook v0.18.0; the playground at v0.15.0 playground/go.mod still pins v0.14.0: it moves to v0.15.0 when that tag exists. Co-Authored-By: Claude Sonnet 5.5 --- hugo.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/hugo.toml b/hugo.toml index e32af46..163bcf8 100644 --- a/hugo.toml +++ b/hugo.toml @@ -41,7 +41,7 @@ disableKinds = ['taxonomy', 'term', 'rss', 'sitemap', '404'] name = "notebook" kind = "kernel · command" href = "https://github.com/go-notebook/notebook" - blurb = "The kernel, the notebook command (run, html, watch, serve, irb) and the HTML export: format parses the Markdown, analysis builds the dependency graph from the syntax, gen writes the Go program, kernel compiles and drives it through runtime and keeps results and values, export writes the page. Ruby cells (```ruby) run on rbgo, a Ruby written in Go, with the go-scikit bindings (Stats, Special, Optimize, Integrate, DataFrame, Plot, NDArray), and share their variables with the Go cells. --timeout and --memory stop a runaway cell in either language. notebook irb is the same Ruby as an interactive session, as irb: => inspect after each input, _, multi-line input decided by rbgo's parser, Tab completion and history in a pure-Go line editor (go-ruby-reline), each input in a worker that --timeout, --memory or Ctrl-C can stop without losing the prompt, and --save to keep the session as a notebook. More → Julia cells (```julia) are parsed with go-embedded-julia's parser and checked (syntax errors at their line with julia's message, names in the dependency graph under Julia's scope rules), and run by its interpreter (v0.15.0) in one kernel shared by the Julia cells: a global or a function a cell defines is there in the next one, and a failure is julia's own text. The kernel boots from a prebuilt Base image, fetched on the first Julia cell and loaded only if its SHA-256 is the pinned one (cold start about a second). A cell may run 30 s and 50 million statements, within a memory budget of 512 MiB counted as 16 bytes per array element (a floor, not the heap: strings are not counted, and one array may have at most 2^24 elements). Julia variables stay in Julia, as R's do: they are not shared with Go, Ruby, R, C or Fortran cells in either direction yet. Known limitations: a loop at the top level of a cell cannot update a global (go-embedded-julia#54). The playground checks Julia cells and does not run them (Julia cells run in go-notebook, not yet in the browser). More → R cells (```r) are parsed with go-embedded-r's parser, identical to R 4.6.2 on R's own sources, and checked in the same way: syntax errors at their line in R's words, names in the graph, and a cell that cannot be analysed from its text (<<-, eval, library) depending on every cell above it. They run on go-embedded-r's evaluator in one shared environment (v0.10.0), and since v0.12.0 each cell is bounded: 512 MiB of vectors, 50 million steps, 30 s. The browser playground runs them too (playground v0.14.0), in its second core, with R variables kept apart from the other languages: 512 MiB, 20 million steps, 10 s per cell, and a crash restarts the core with a message on the cell. More → Fortran cells (```fortran) are checked and run with go-embedded-fortran (since go-notebook v0.17.0, go-embedded-fortran v0.17.0: its sema session for the names and errors, its eval.Session for the running; free form, implicit typing off) and highlighted with go-rouge's fortran lexer. The Fortran cells share one session: a cell sees the variables (with the values the earlier cells left), procedures, modules and derived types of the Fortran cells before it. Fortran variables stay in Fortran, as R's do: they are not shared with Go, Ruby, Julia, R or C cells in either direction yet. A cell may make at most 2^32 loop iterations and calls and run 30 s, and a failure is reported at its line and column. The playground does not link the Fortran runtime yet. More →" + blurb = "The kernel, the notebook command (run, html, watch, serve, irb) and the HTML export: format parses the Markdown, analysis builds the dependency graph from the syntax, gen writes the Go program, kernel compiles and drives it through runtime and keeps results and values, export writes the page. Ruby cells (```ruby) run on rbgo, a Ruby written in Go, with the go-scikit bindings (Stats, Special, Optimize, Integrate, DataFrame, Plot, NDArray), and share their variables with the Go cells. --timeout and --memory stop a runaway cell in either language. notebook irb is the same Ruby as an interactive session, as irb: => inspect after each input, _, multi-line input decided by rbgo's parser, Tab completion and history in a pure-Go line editor (go-ruby-reline), each input in a worker that --timeout, --memory or Ctrl-C can stop without losing the prompt, and --save to keep the session as a notebook. More → Julia cells (```julia) are parsed with go-embedded-julia's parser and checked (syntax errors at their line with julia's message, names in the dependency graph under Julia's scope rules), and, since go-notebook v0.18.0, run by its interpreter (v0.15.0) in one kernel shared by the Julia cells: a global or a function a cell defines is there in the next one, and a failure is julia's own text. The kernel boots from a prebuilt Base image, fetched on the first Julia cell and loaded only if its SHA-256 is the pinned one (cold start about a second). A cell may run 30 s and 50 million statements, within a memory budget of 512 MiB counted as 16 bytes per array element (a floor, not the heap: strings are not counted, and one array may have at most 2^24 elements). Julia variables stay in Julia, as R's do: they are not shared with Go, Ruby, R, C or Fortran cells in either direction yet. Known limitations: a loop at the top level of a cell cannot update a global (go-embedded-julia#54). The playground checks Julia cells and does not run them (Julia cells run in go-notebook, not yet in the browser). More → R cells (```r) are parsed with go-embedded-r's parser, identical to R 4.6.2 on R's own sources, and checked in the same way: syntax errors at their line in R's words, names in the graph, and a cell that cannot be analysed from its text (<<-, eval, library) depending on every cell above it. They run on go-embedded-r's evaluator in one shared environment (v0.10.0), and since v0.12.0 each cell is bounded: 512 MiB of vectors, 50 million steps, 30 s. The browser playground runs them too (playground v0.15.0), in its second core, with R variables kept apart from the other languages: 512 MiB, 20 million steps, 10 s per cell, and a crash restarts the core with a message on the cell. More → Fortran cells (```fortran) are checked and run with go-embedded-fortran (since go-notebook v0.17.0, go-embedded-fortran v0.17.0: its sema session for the names and errors, its eval.Session for the running; free form, implicit typing off) and highlighted with go-rouge's fortran lexer. The Fortran cells share one session: a cell sees the variables (with the values the earlier cells left), procedures, modules and derived types of the Fortran cells before it. Fortran variables stay in Fortran, as R's do: they are not shared with Go, Ruby, Julia, R or C cells in either direction yet. A cell may make at most 2^32 loop iterations and calls and run 30 s, and a failure is reported at its line and column. The playground does not link the Fortran runtime yet. More →" [[params.repos]] name = "playground" kind = "wasm · page" From b3ddce5830ab0d230694572636d30b3e1ec9f1f8 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sun, 15 Nov 2026 10:41:03 +0100 Subject: [PATCH 4/5] playground v0.15.0 Co-Authored-By: Claude Sonnet 5.5 --- playground/go.mod | 18 ++++++++++-------- playground/go.sum | 36 ++++++++++++++++++++---------------- 2 files changed, 30 insertions(+), 24 deletions(-) diff --git a/playground/go.mod b/playground/go.mod index 1536bd4..7ad7b67 100644 --- a/playground/go.mod +++ b/playground/go.mod @@ -2,7 +2,7 @@ module github.com/go-notebook/go-notebook.github.io/playground go 1.27.3 -require github.com/go-notebook/playground v0.14.0 +require github.com/go-notebook/playground v0.15.0 require ( filippo.io/age v1.3.2 // indirect @@ -80,13 +80,14 @@ require ( github.com/go-dataframe/dataframe v0.1.0 // indirect github.com/go-datetime/dates v0.2.0 // indirect github.com/go-embedded-c/c v0.2.1 // indirect - github.com/go-embedded-julia/julia v0.5.0 // indirect - github.com/go-embedded-r/r v0.13.1 // indirect + github.com/go-embedded-fortran/fortran v0.17.0 // indirect + github.com/go-embedded-julia/julia v0.15.0 // indirect + github.com/go-embedded-r/r v0.17.1 // indirect github.com/go-embedded-r/tre v0.1.3 // indirect github.com/go-embedded-ruby/ruby v0.8.5 // indirect github.com/go-encryptions/unixcrypt v0.1.0 // indirect github.com/go-facter/facter v0.0.0-20260830120958-454b72e642ab // indirect - github.com/go-fft/fft v0.28.6 // indirect + github.com/go-fft/fft v0.28.11 // indirect github.com/go-fleettools/landingkit v0.18.0 // indirect github.com/go-gfx/gfx v0.41.0 // indirect github.com/go-hiera/hiera v0.0.0-20260830144306-f9304f6bec92 // indirect @@ -104,9 +105,9 @@ require ( github.com/go-logr/logr v1.4.4 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/go-mustache/mustache v0.1.0 // indirect - github.com/go-ndarray/ndarray v0.28.0 // indirect + github.com/go-ndarray/ndarray v0.40.3 // indirect github.com/go-nokogiri/nokogiri v0.1.0 // indirect - github.com/go-notebook/notebook v0.15.0 // indirect + github.com/go-notebook/notebook v0.18.0 // indirect github.com/go-numerics/integrate v0.2.0 // indirect github.com/go-numerics/optimize v0.3.1 // indirect github.com/go-numerics/special v0.2.0 // indirect @@ -302,6 +303,7 @@ require ( github.com/go-simd/adler32 v0.1.0 // indirect github.com/go-simd/base64 v0.1.0 // indirect github.com/go-simd/crc32 v0.0.0-20260903220012-5f164e0e0487 // indirect + github.com/go-simd/floats v0.15.0 // indirect github.com/go-simd/hex v0.0.0-20260903220024-a8d22a843218 // indirect github.com/go-simd/highway v0.0.14 // indirect github.com/go-sql-driver/mysql v1.10.1 // indirect @@ -409,10 +411,10 @@ require ( golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa // indirect golang.org/x/image v0.47.0 // indirect golang.org/x/net v0.62.0 // indirect - golang.org/x/sync v0.24.0 // indirect + golang.org/x/sync v0.25.0 // indirect golang.org/x/sys v0.49.0 // indirect golang.org/x/term v0.47.0 // indirect - golang.org/x/text v0.43.0 // indirect + golang.org/x/text v0.44.0 // indirect golang.org/x/time v0.16.0 // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260817212433-ac3dfec99bb1 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260817212433-ac3dfec99bb1 // indirect diff --git a/playground/go.sum b/playground/go.sum index 2eb38fd..460d239 100644 --- a/playground/go.sum +++ b/playground/go.sum @@ -204,10 +204,12 @@ github.com/go-datetime/dates v0.2.0 h1:5zXrMqTgw3ljlQfghRsdJRtXYqnR6jYqTgMvA3kG8 github.com/go-datetime/dates v0.2.0/go.mod h1:FmzSHylloy714Cc8MEkRjREYP7TcslqjmzsFMQXglAg= github.com/go-embedded-c/c v0.2.1 h1:LCNcLHJ1T3Ry0adJwO+jK9RnoFwrMd6yR/0bb0muHIc= github.com/go-embedded-c/c v0.2.1/go.mod h1:MhuXRqUtTZTUnm/3fVjho1HiL6QCFylChzOQ+Tu9eiQ= -github.com/go-embedded-julia/julia v0.5.0 h1:yLdnc0M+qycG8lbkDyH58RYushqdMOp2xdrIZpaIcBo= -github.com/go-embedded-julia/julia v0.5.0/go.mod h1:f8anO/Ngw/UB/9Fj/k9qX/F8LRgh90Bp1VaJ2SQsGgw= -github.com/go-embedded-r/r v0.13.1 h1:dZQNZ9YDug3S0gIZ9JbTOBp+NoomuQoVpMBDfmH0VsY= -github.com/go-embedded-r/r v0.13.1/go.mod h1:+SbBiE9KSTuc1kWNF6009Ixrs2tM2uQCuKxByngTWL4= +github.com/go-embedded-fortran/fortran v0.17.0 h1:jaFE9Nqzqms9NOZDg1+7zQ9qZUGssvEcoOCxuPhIPWY= +github.com/go-embedded-fortran/fortran v0.17.0/go.mod h1:UUtUFdyuO7fWnDoBjbjGZNGXg7bH2fW2DLp1D4QOAkg= +github.com/go-embedded-julia/julia v0.15.0 h1:FcGqZTIYPqBFdA2BDr6HdItbUe4QAf3/HNRW+bZWnJ4= +github.com/go-embedded-julia/julia v0.15.0/go.mod h1:WkSyHRvyKTls2QhqjwORXAcDOJCeoO6zIx2wedBPLpk= +github.com/go-embedded-r/r v0.17.1 h1:raX7Ac9Bvni/pw+A+7lWFO1UkJqm66d4f26uh57DH2w= +github.com/go-embedded-r/r v0.17.1/go.mod h1:+SbBiE9KSTuc1kWNF6009Ixrs2tM2uQCuKxByngTWL4= github.com/go-embedded-r/tre v0.1.3 h1:MuHk9dLUO51F6kr7j8mnu01bUMVBmOpVlrmO16qObjo= github.com/go-embedded-r/tre v0.1.3/go.mod h1:UN9RKw3VLEJpNmxPO+4JRTediME4pYay0iWFUMY2SUc= github.com/go-embedded-ruby/ruby v0.8.5 h1:JGKa6Cz4ihKNVfooeeytuPsT133byK7CkZr04Px9PYQ= @@ -216,8 +218,8 @@ github.com/go-encryptions/unixcrypt v0.1.0 h1:XWk4h9uCDd+T2hovOzgO0B2vOdJvAwi9nb github.com/go-encryptions/unixcrypt v0.1.0/go.mod h1:B1dJSjz3kdxvP7cpi5xSzyxezgBijmtNCUeCKqqDd3o= github.com/go-facter/facter v0.0.0-20260830120958-454b72e642ab h1:bXPxQDhADpiF/S/8jlRFhVisFPRaxPtPgjibLnOzvsE= github.com/go-facter/facter v0.0.0-20260830120958-454b72e642ab/go.mod h1:ghuoOHWXdq5dE3GLPDiz3Uy0ORrvK+1hB7QC997ez2U= -github.com/go-fft/fft v0.28.6 h1:5xI7Ya0+8KwZ3Z2Ku1zmNkC9QqLdN05wkp+SV9YBOe8= -github.com/go-fft/fft v0.28.6/go.mod h1:GN5V4TWCjV05ECqH1ONfjFM6Z1m2shqCdssxKGqQ41s= +github.com/go-fft/fft v0.28.11 h1:ZfT78fSmPjZU2E9PgkSI/0f0E3sesYpl13GHmIFzRGc= +github.com/go-fft/fft v0.28.11/go.mod h1:GN5V4TWCjV05ECqH1ONfjFM6Z1m2shqCdssxKGqQ41s= github.com/go-fleettools/landingkit v0.18.0 h1:XuIzUJunmzMNQGrX980WTBFabj7oDyYp7xU5+6TFYjw= github.com/go-fleettools/landingkit v0.18.0/go.mod h1:gBpbziqFcmcjtNknPjy5+AAzGZ5L+pPr9mIJZHpDlZc= github.com/go-gfx/gfx v0.41.0 h1:MVEnory0Zx8ypzuVDrTIWz4Cekv8hn5ilcYg3glJPrk= @@ -259,14 +261,14 @@ github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/go-mustache/mustache v0.1.0 h1:WvnpPlBn8/v1dwVzp7XvzF5dDC1agYMzPyCl1MdPVzY= github.com/go-mustache/mustache v0.1.0/go.mod h1:jXns/eIBKrnaFbE8BXX44VrTLp92732R0oXBiZC+v/Q= -github.com/go-ndarray/ndarray v0.28.0 h1:9RWfw01uRUH1YqsVUpNllm01XEohqdSfsk4Kw0x18VA= -github.com/go-ndarray/ndarray v0.28.0/go.mod h1:bDbGWswQLmTMh6V3LwvKUbpfHzeG4sZDcvuGnA0GC+s= +github.com/go-ndarray/ndarray v0.40.3 h1:jsQnEKagtYZs484MzLNGbpcttkVvS1m8UrodoWJrd64= +github.com/go-ndarray/ndarray v0.40.3/go.mod h1:O4U0Y5pV0Pakd0iqx5ECW8VP346oxJlvm73FTeQ1rI8= github.com/go-nokogiri/nokogiri v0.1.0 h1:3Q3BewGHK16Bt34ggJeyf9xeIMJyA3dmfbIxARPgR9U= github.com/go-nokogiri/nokogiri v0.1.0/go.mod h1:zjghooYIK8Xfg+fL4/OUhROslx51xGsM3JKtB2TI0tg= -github.com/go-notebook/notebook v0.15.0 h1:YINDiZnu53vd8IYeN+7VBvceSP81SYm8hnWbpP4xrGo= -github.com/go-notebook/notebook v0.15.0/go.mod h1:kVOmlBr0TQt3XZUcJcY1Z4hJnl1UPz+5grPT5fNAK3M= -github.com/go-notebook/playground v0.14.0 h1:UElBr11A4RExGRvAGXcCXFwiIJ8Z29oL1QXVUfzr3bc= -github.com/go-notebook/playground v0.14.0/go.mod h1:+eX/Jd/AX4uE85dSSRRT/5MFuwmKKB/vS08jyuzEquI= +github.com/go-notebook/notebook v0.18.0 h1:D+dUbO7UGntilJgKy0RSe4c8lSM/29L5ATJsGh3vlaQ= +github.com/go-notebook/notebook v0.18.0/go.mod h1:uGGg7forGdvyhc3ohmknC/1mNf3FD7JkEmwj3yAx4s0= +github.com/go-notebook/playground v0.15.0 h1:298KCfPMBsOrpyJvu1OCILN010+snjfCF80MtWrNHAg= +github.com/go-notebook/playground v0.15.0/go.mod h1:n9jKYN6FtJjfP8llbctGgJaHtTykQf4uB+kge7IYyCA= github.com/go-numerics/integrate v0.2.0 h1:IkJhDimTc7nQETCixEvbbHhtOF36GbANBKJI3mJB3Kw= github.com/go-numerics/integrate v0.2.0/go.mod h1:ABjpcWy8ZSOg8j6S+7YRsvMJ2LpVkH4E64/CGet2gCw= github.com/go-numerics/optimize v0.3.1 h1:eYkT9BpORKSwXnDtEJxXfZ19qJT0cI2RH6xEL3VLZSU= @@ -657,6 +659,8 @@ github.com/go-simd/base64 v0.1.0 h1:Pd5aYE5Zuflf8PDvXeYXDZqa27NQ4gvg2PTjWHnPuTQ= github.com/go-simd/base64 v0.1.0/go.mod h1:iPa0zSBQKLgChjjqixi+jckt7kjxTj2p/tG18lHq+lE= github.com/go-simd/crc32 v0.0.0-20260903220012-5f164e0e0487 h1:6JZ4TKf3j6y7xS9meu2MBQZHkkeebFWiQo8x2htKfd0= github.com/go-simd/crc32 v0.0.0-20260903220012-5f164e0e0487/go.mod h1:lickteAl0z3L24ypOqBe0AwoHPMMxxpYcxJu72aO1kw= +github.com/go-simd/floats v0.15.0 h1:0joQTqse6+Ccl78FETksCrrBGdeLhy7ZsxRJRNU6yLU= +github.com/go-simd/floats v0.15.0/go.mod h1:Aq5a6oY5pUqm9Hpi+iV2nrNmaaUb0rwHvUHIerXWSvA= github.com/go-simd/hex v0.0.0-20260903220024-a8d22a843218 h1:TymapuhKzqUf8LNtsv8L4PJY/gz5bAaEbD2cpot1vFI= github.com/go-simd/hex v0.0.0-20260903220024-a8d22a843218/go.mod h1:ZwRN06+N0wTIjn+mxT2NF/CbzTMAlfH/c0CKG8q5cwU= github.com/go-simd/highway v0.0.14 h1:O3HPG00qgLGlrQyYBlMGyLYsuzZrqHA4+XNptPjV5gs= @@ -1101,8 +1105,8 @@ golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.24.0 h1:iqiDrGoDgyuvAKrhLQthUEzU/R378N78gXbBjxed7oA= -golang.org/x/sync v0.24.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= +golang.org/x/sync v0.25.0 h1:dJnifr0nMV8/SBnBvdo4eSGGnrc3O4FFx6IqvtLcmRs= +golang.org/x/sync v0.25.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1139,8 +1143,8 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.43.0 h1:1QivrlhwAsnMOcqgOdl9my7s9OyZl8O5/UGUTJVXoWc= -golang.org/x/text v0.43.0/go.mod h1:hbSIYA/amXcRXTFSZqh8tWHEoqRvvbKPJ2uz/KU+a+s= +golang.org/x/text v0.44.0 h1:YItdp/mQNGnsmrgpcdA5yQ3bnRxCfo/Tj/iByGW9GGo= +golang.org/x/text v0.44.0/go.mod h1:S4FR1waQ9LbjQTls97SyRjDaUUVkaM+cXwwuG/G+MwY= golang.org/x/time v0.16.0 h1:vMb6ptszcQMkcwiRTAuNNU50gom6++Q/6gY2hDM6VDE= golang.org/x/time v0.16.0/go.mod h1:rVKOqvZeKvrDKTQiAHJ7wmwP0RzleSphoEA9RcdLA0s= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= From 4b5778fa117f8ceeec2f96bcf901fd474ccfff74 Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sun, 15 Nov 2026 10:48:57 +0100 Subject: [PATCH 5/5] playground notebooks: the 4-julia example of playground v0.15.0 (no Go cell reads a Julia name) Co-Authored-By: Claude Sonnet 5.5 --- playground/notebooks/4-julia.md | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-) diff --git a/playground/notebooks/4-julia.md b/playground/notebooks/4-julia.md index 93acd80..aa417a8 100644 --- a/playground/notebooks/4-julia.md +++ b/playground/notebooks/4-julia.md @@ -1,27 +1,21 @@ -# Julia cells, checked but not run yet +# Julia cells, checked in the page and run in go-notebook -A cell written in a `julia` fence is **parsed and checked** with [go-embedded-julia](https://go-embedded-julia.github.io/)'s parser, and it is **not run**: go-embedded-julia has no runtime yet (its milestone M3). Until that lands, a Julia cell is checked, not run. There is no external `julia` behind it, and there never will be one. The badge on the cell says so: *Julia · not runnable yet*. +A cell written in a `julia` fence is **parsed and checked** with [go-embedded-julia](https://go-embedded-julia.github.io/)'s parser. In go-notebook itself (`notebook run`, `notebook serve`) it also **runs**, on go-embedded-julia's interpreter in one kernel. In this page it does **not** run yet: the interpreter's Base image is fetched at run time, which a page cannot do. There is no external `julia` behind it. The badge on the cell says so: *Julia · not runnable yet*. -What works today is the checking, and it is worth having: the notebook knows what each Julia cell defines and what it reads, and it knows which Go cells depend on it. Go draws the size; the Julia cell reads `n` and defines `xs` and `total`. +In the page a Julia cell is checked, not run. What works here is the checking: syntax errors come back at the right line, and the cell never reaches the Go evaluator. ```go n := 10 ``` -The Julia cell below is well formed, so it is not an error. It does not run either: its output says why, and no number comes back. +The Julia cell below is well formed, so it is not an error. It does not run in the page: its output says why, and no number comes back. ```julia -xs = [i^2 for i in 1:n] +xs = [i^2 for i in 1:3] total = sum(xs) ``` -This Go cell reads `total`, which the Julia cell defines. The name analysis sees that, so the cell is **blocked**: it waits for the Julia cell, and says so, instead of failing on a name that never arrives. - -```go -m := total + 1 -``` - -A cell that does not read anything from Julia is not held back. It runs as usual, whatever the Julia cells above it do: +Julia variables stay in Julia (they are not shared with Go cells, in either direction), so a cell of another language neither reads `total` nor waits for it. It runs as usual, whatever the Julia cells above it do: ```go n * 2 @@ -34,4 +28,4 @@ A mistake in a Julia cell is caught at the right line, before anything runs, and the page shows ``line 2:8: syntax error: Expected `)` or `,` ``, at line 2, column 8, where the closing parenthesis was expected. Try it: add a Julia cell with `x = (1,` and run the notebook. -When go-embedded-julia's runtime lands, these cells will run and the blocked cell will compute `total + 1`. Follow the progress at [go-embedded-julia.github.io](https://go-embedded-julia.github.io/). +Running them in the browser is a separate question, pending with go-embedded-julia. Follow the progress at [go-embedded-julia.github.io](https://go-embedded-julia.github.io/).