gophernotes VS gonb

https://github.com/gopherdata/gophernotes

I've had this bookmarked for some time and just havent gotten around to it.

Gopher Notes Kernel for jupyter notebooks? Could be useful :)

I started this because gophernotes was not working for another project I'm slowing working on -- it is interpreted, and not up-to-date (generics, etc).

A go kernel is available at https://github.com/gopherdata/gophernotes

> You do know that statically typed languages have REPLs too? Like the ML family, including Haskell.

I do, but that I don't see how that relates to the bit of my post which you've quoted. I certainly didn't claim or imply that REPL and static type systems were mutually exclusive, only that REPLs are a poor substitute for many static analysis tasks.

> And when using something like a Jupyter notebook with a kernel for your compiled language https://github.com/gopherdata/gophernotes you can do similar interactive programming.

Yeah, I'm aware. I operate a large JupyterHub cluster (among many other things) at work. :)

> Lisp REPLs take that a step further, as you interact with and in your whole actually running program.

That sounds nice, but it's too abstract to persuade IMHO.

If you are coming from python,jupyter notebook, gophernotes is a great library to setup your own playground.

Why can't you just build libraries to make Go a better language for data science? There's already Go support for a Jupyter Notebooks kernel: https://github.com/gopherdata/gophernotes

I've had these strong feelings and the OP describes it really well. Despite being a polyglot programmer, I really struggle with Python, both in expression and performance (unless it's just config for GPUs).

Some of this frustration was recently an "Unpopular Opinion" on the Go Time Podcast regarding Python being great for "data exploration" but not for "data engineering": https://changelog.com/gotime/304#t=3196

I've been yearning for better interactive tooling and ML-related libraries bridge this gap and started using some even in just the last week:

* GoNB (Golang-support for Jupyter notebooks, also from a Googler) https://github.com/janpfeifer/gonb

* That uses Go-Plotly for graphs/UI: https://github.com/MetalBlueberry/go-plotly

* GoMLX (GoNB author is also on that project, many thanks Jan!) https://github.com/gomlx/gomlx

* Hidden at the end of OP is LangChainGo for LLMs, which I haven't used yet: https://github.com/tmc/langchaingo

Pick those up and let's make the Go community stronger together!

When I created a new Jupyter file in Go, I faced a challenge trying to replicate the development process I usually follow with Python. In Python and Jupyter Notebook I can conveniently run code in separate parts, saving previous values in memory and using cells to organize code. This flexibility was missing in Go, and it took me some time to figure out a solution. However, I came across a helpful tutorial that explained how to use caching with the Go Kernel, making the process smoother with gonb.

I needed one more thing to make myself feel at home, something I usually use with Python. When working with data, I often turned to the Jupyter VSCode extension for its convenience. To my relief, I discovered that a Go kernel existed, tailored perfectly for my needs.

Training library, with some pretty-printing. Including plots for GoNB Jupyter notebook.

Tutorial (and demo) here. Source code in github.com/janpfeifer/gonb.