Hacker News Reader

Comment by breck | Hacker News Reader

I loved the title. Because indeed, I personally thought that Observable was mostly just Javascript. But now I understand it a lot more and more importantly have an idea now of where they are going with it. I love JupyterLab, but I think long-term it is boxed in by its design of being Python/R in the browser. Observable is breaking from Javascript more than I thought, which will allow it to do really cool things and hit an audience that doesn't necessarily care that it's not quite Javascript.

View on HN

Jupyter is above all a kernel. A kernel that works with several languages, and can communicate using a socket with any program, not just the browser.

I think the kernel design is fantastic. I think Jupyter has a lot of legs and will be great for many, many years ahead. But I also think you can make a 10x leap in data science tools, but you need to look beyond the R/Python/Julia style languages. Observable gets to start fresh and build a language that best enables an interactive visual notebook environment, whereas the others are great languages but that kind of notebook environment came later and must be shaped to fit the languages.

It may be an awesome piece of javascript to admire and behold, but to the scientist that has decades of fortran and matlab programs he's collected over the years, it's a tall order to expect him to rewrite everything in Observable.

> it's a tall order to expect him to rewrite everything in Observable.

I didn't say anything of the sort. That's your idea, not mine. I think Matlab and Fortran are great.

I would, however, expect new folks who don't know Fortran or Matlab to instead pick up something like Observable, if it continues to evolve in its present direction.

My point in the comment above is that, although I think Jupyter is fantastically designed, and I love the kernel abstraction, it began and is all about the notebook and graphical UI. So a thing like Observable, where they are similarly committed to the reactive interactive environment, without being committed to legacy languages (and in fact are willing to head down toward a reactive language which are far outnumbered by the languages akin to Python/R), could be very interesting down the line. I am very bullish on hybrid visual/text programming environments in data science, which have been around for a long time, but are becoming particularly more useful now that we have so many great data sources and tools to process that data.

It would be great if people stopped using Matlab for new open source projects (in favor of e.g. Julia or Python/numpy). But nobody is expecting the majority of numerical code to be rewritten for the web anytime soon.

Still, if anyone wants to make their research results as accessible as possible, then publishing an Observable notebook is great, because it’s (a) just a hyperlink so trivial to access from any device without security concerns, need to purchase or even install and run specialized runtimes, etc., (b) very friendly for readers to inspect/modify/reuse, (c) supports rich interaction better than most alternative platforms.

I’m hoping that wasm someday soon becomes a reasonable target for optimized numerical programs written in Fortran, C, Rust, Julia, Halide, ...

I kinda want Observable to be it's own language that can compile to JS... not saying it would be a good general purpose lang by any means, but it would be interesting to experiment with a 'first-class observable' language.

I agree. I also would bet this is where they will go.

And it kinda is. We provide a parser¹ and a runtime², and you can download a copy of any notebook compiled to a JavaScript module: https://observablehq.com/@observablehq/downloading-and-embed...

That said, we’re explicitly designing for the reactivity of the notebook environment. Working on fundamentally reactive code in a traditional text editor is ... alright, I guess. You’re still stuck reloading the whole enchilada any time you make a change. It’s nowhere near as exciting as working on reactive code in an editor that understands and respects the reactivity, and can keep your program running and re-evaluating as you tweak it!

That said, if you're interested something less notebook-y, check out what Rich Harris is doing with Svelte 3. It's totally a not-so-distant cousin.

1. https://github.com/observablehq/parser

2. https://github.com/observablehq/runtime

Thanks for the information. Also, yes, I've been keeping a very close eye on Svelte 3 and have been experimenting with it :)

Reply on news.ycombinator.com