1. 55

  2. 8

    As an occasional used of notebooks I agree with almost everything he said in those slides. Kind of want to see a recording of the talk now.

    1. 9

      Yea I’d rather see a recording. The slides aren’t really getting the full point across on their own (which means they’re actually good slides and are just an addition visual aid like they should be, vs something you just read point by point while on stage).

      1. 7

        If you look at the speaker notes (if Google Slides lets you) you’ll get the bulk of what I actually said.

        (You’ll still miss out on the two livecoding pieces and my impeccable comedic timing.)

      2. 5

        They did record it and supposedly will put it up on YouTube at some point.

        1. 1

          I had no idea this stuff existed before this post. Are they actually widely used?

        2. 8

          Great presentation! I was actually woefully unaware of these hidden state things. I rarely use notebooks and treat them more as ‘test.sh,’ akin to when I’m just messing around with shell scripts; usually to just learn how new libraries I’m playing with work.

          1. 5

            Notebook folks want many things:

            1. A way to share table/csv data along with a program that runs, excluding data that they can’t share.
            2. A way to view their data & visual analysis through a browser that can execute.
            3. A way to share code, with documentation built in.

            This is the push & pull of executing/running a program vs. publishing a program. Sounds like literate programming problems, and can be addressed with better literate programming tooling for python folks. There are many better formats, Org-mode even lets you share data between languages :)

            But there is hope! Notebooks are the single largest group pushing for better literate programming environments. While the current iteration is rather poop, looks like all of these issues are pretty fixable, even using a notebook-style UI.

            1. 4

              I had no idea notebooks worked like that, I assumed they’d maintain a dependency graph and re-run cells like a spreadsheet. That’s…. awful.

              1. 3

                Mathematica supports that through Dynamic cells, though they aren’t the default type of cell.

                1. 3

                  I started on this with my jupyter-like-thing-for-micropython WebPad, although at the moment it is just a linear chain of blocks. A dependency graph is a great idea though.

                  1. 2

                    That sounds like an interesting way to do notebooks, but it would either require a different language than python or an explicit way of tracking cell dependencies.

                    In Excel it works because the expression language is built with dependency tracking as a consideration. You could theoretically use event handlers or an FRP-style setup for doing the dependency tracking, but either seems like it’d be awkward in python, due to it’s lack of elegant ways of expressing multiline anonymous functions.

                  2. 3

                    I find R Studio notebooks (Rmd) to be better than Jupyter notebooks. My reasons are:

                    1. A transparent markdown format unlike the JSON for jypyter notebooks
                    2. No state (or at least not as dependent on state as Jupyter)
                    3. Gives you almost the same interface (support multiple languages including bash, python etc.)
                    4. Fast!
                    1. 2
                      1. First-class support for rendering to a report/immutable form. I like having one version of the source code, with earlier versions in version control; but I also like having analyses side-by-side in a folder, for easy comparison. Rendered reports give me both.

                      (Jupyter does support rendering to HTML. Rmd lets you write the text in, and render chunk outputs to, LaTeX, Sweave, HTML, Listings, Markdown, Jekyll, and ReStructuredText.)

                    2. 1

                      Notebooks make it easy to retry parts of the code you’re writing, which is very helpful if you have a bunch of steps that each take some time to compute. You can pretty easily write helpers to dump the state, and maybe pick up where you left off, but that still requires you to load the data again and define an appropriate entry point. Is there a good solution for that outside of notebooks?

                      1. 6


                        1. 1

                          Those don’t allow you to edit & rerun blocks of code, so that makes them less useful

                      2. 0

                        Really enjoyed this.