Desde mediados/finales de los noventas no uso Mathematica, e incluso en ese momento era un gran sistema, altamente integrado y coherente. Sin embargo, en la medida en que me decanté por el software libre, empecé prontamente a buscar alternativas e inicié con TeXmacs, del cual traduje la mayor parte de su documentación al español, como una de mis primeras contribuciones a un proyecto de software libre (creo que aún la traducción es la que se está usando y por aquella época usábamos SVN para coordinar cambio e incluso enviábamos archivos compresos, pues el control de versiones no era muy popular).Por ejemplo el bonito y minimalista Yacas, con el que hiciera muchas de mis tareas en pregrado y colocara algunos talleres y corrigiría parciales cuando me convirtiese en profesor del departamento de Matemáticas

TeXmacs, a diferencia de sistemas monolíticos como Mathematica, se conectaba ya desde ese entonces con una gran variedad de Sistemas de Álgebra Computacional (o CAS, por sus siglas en inglés) exponiéndonos a una diversidad de enfoques y paradigmas CAS, con sus sintaxis e idiosincracias particulares, en una riqueza que Mathematica nunca tendrá.

TeXmacs también me expondría a ideas poderosas, como poder cambiar el software fácilmente a partir de pequeños scripts (en Scheme), que lo convirtieron en el primer software libre que modifiqué, y las poderosas S-expressions que permitían definir un documento y su interacción con CAS externos, si bien TeXmas ofrecía un lenguaje propio mas legible y permitía pasar de Scheme a este y viceversa.

En general esa es la diferencia de los sistemas privativos con los libres: una monocultura versus una policultura, con las conveniencias de la primera respecto a los enfoques unificantes contra la diversidad de la segunda. Si miramos lo que ha ocurrido con Python y las libretas computacionales abiertas como Marimo y Jupyter, estos han ganado en la conciencia popular con respecto a Mathematica y han incorporado funcionalidad progresiva que Mathematica tenía, mientras que otra sigue estando aún presente en los sistemas privativos y no en los libres y viceversa. Yo no diría que las libretas computacionales libres están donde estaba Mathematica en los 90's, sino que han seguido rutas históricas diferentes, cada una con sus valores y riquezas.

Como he documentado en mi blog, antes de Grafoscopio, mis primeros intentos por crear flujos y herramientas de documentación interactiva a medida fueron en IPython, pero me cansé de lidiar con la complejidad incidental del stack con el que IPython y luego Jupyter estaban hechos, encontrando en Pharo Smalltalk una plataforma más coherente, simple, entendible y adaptable.

Como he explicado en otros apartados, si bien Grafoscopio mezcla herramientas distintas de nuestros flujos de documentación y publicación, ahora Cardumem surge con la idea de crear una interfaz web y una experiencia unificada para las integraciones, con una sintaxis minimalista y sin los requerimientos conceptuales de la programación orientada a objetos.

3 ways of running jupyter notebook in a container

https://web.archive.org/web/20230502181156/https://notebooks.vires.services/notebooks/01a__intro-jupyter-python

Seems a useful description of what Jupyter books are.

https://www.complexityexplorer.org/courses/162-foundations-applications-of-humanities-analytics

https://www.loom.com/share/a05f636661cb41628b9cb7061bd749ae

Synopsis: Maggie Delano looks at some of the affordances supplied by Tana (compared to Roam Research) in terms of providing better block-based user interface for note type creation, search, and filtering.

These sorts of tools and programmable note implementations remind me of Beatrice Webb's idea of scientific note taking or using her note cards like a database to sort and search for data to analyze it and create new results and insight.

It would seem that many of these note taking tools like Roam and Tana are using blocks and sub blocks as a means of defining atomic notes or database-like data in a way in which sub-blocks are linked to or "filed underneath" their parent blocks. In reality it would seem that they're still using a broadly defined index card type system as used in the late 1800s/early 1900s to implement a set up that otherwise would be a traditional database in the Microsoft Excel or MySQL sort of fashion, the major difference being that the user interface is cognitively easier to understand for most people.

These allow people to take a form of structured textual notes to which might be attached other smaller data or meta data chunks that can be easily searched, sorted, and filtered to allow for quicker or easier use.

Ostensibly from a mathematical (or set theoretic and even topological) point of view there should be a variety of one-to-one and onto relationships (some might even extend these to "links") between these sorts of notes and database representations such that one should be able to implement their note taking system in Excel or MySQL and do all of these sorts of things.

Cascading Idea Sheets or Cascading Idea Relationships

One might analogize these sorts of note taking interfaces to Cascading Style Sheets (CSS). While there is the perennial question about whether or not CSS is a programming language, if we presume that it is (and it is), then we can apply the same sorts of class, id, and inheritance structures to our notes and their meta data. Thus one could have an incredibly atomic word, phrase, or even number(s) which inherits a set of semantic relationships to those ideas which it sits below. These links and relationships then more clearly define and contextualize them with respect to other similar ideas that may be situated outside of or adjacent to them. Once one has done this then there is a variety of Boolean operations which might be applied to various similar sets and classes of ideas.

If one wanted to go an additional level of abstraction further, then one could apply the ideas of category theory to one's notes to generate new ideas and structures. This may allow using abstractions in one field of academic research to others much further afield.

The user interface then becomes the key differentiator when bringing these ideas to the masses. Developers and designers should be endeavoring to allow the power of complex searches, sorts, and filtering while minimizing the sorts of advanced search queries that an average person would be expected to execute for themselves while also allowing some reasonable flexibility in the sorts of ways that users might (most easily for them) add data and meta data to their ideas.

Jupyter programmable notebooks are of this sort, but do they have the same sort of hierarchical "card" type (or atomic note type) implementation?

https://quarto.org/

convert jupyter notebook to other format by command

example of a OER textbook with an embedded Jupyter Notebook. I've wanted to noodle around with this myself.

Because it teaches scientists bad programming habits:

• no modularity (but result depend on order of evaluation)
• no testabilty
• cannot view code without opening jupyter
• missing history (ok %history works)

We can replace VBA with Python

We can define functions in Python to later use in Excel

%xl_get lets us get the current Excel selection in Python

PyXLL lets us use Python/Jupyter Notebooks in Excel

Comparison of dashboard tech stack as of 10/2020:

Hot Reloading is what provides a great experience with updating your Dash code inside the Jupyter Notebooks

3 display modes of Dash using Jupyter Notebooks:

1. app.run_server(mode='external')
2. app.run_server(mode='inline')
3. app.run_server(mode='jupyterlab')

Moreover, you can display your Dash result inside a Jupyter Notebook using IPython.display.IFrame with this line:

app.run_server(mode='inline')

How Dash can run inside Jupyter Notebooks

Dash can be tried out inside a Jupyter Notebook right in your browser using binder.

To use Dash in Jupyter Notebooks, you have to import:

from jupyter_dash import JupyterDash

instead of:

import dash

Therefore, all the imports could look like that for a typical Dash app inside a Jupyter Notebook:

import plotly.express as px
from jupyter_dash import JupyterDash
import dash_core_components as dcc
import dash_html_components as html
from dash.dependencies import Input, Output

Usual final product in Data Science is the business analysis which is perfectly explained with notebooks

Table comparing pros and cons of:

• IDE/Editor
• REPL/shell
• Traditional notebooks (like Jupyter)

It's easier to explore the code:

• when you develop on the prompt (or REPL)
• in notebook-oriented system like Jupyter

but, it's not efficient to develop in them

Notebook makes it easier to handle dynamic Python features

Things missed in Jupyter Notebooks:

• good doc lookup
• good syntax highlighting
• integration with unit tests
• ability to produce final, distributable source code files

In exploratory programming, we:

• experiment with a new API to understand how it works
• explore the behavior of an algorithm that we're developing
• debug our code through combination of inputs

Version control in notebooks?

Problem of reproducibility in notebooks

Summary of the article:

Notebook = presentation + interactivity

YAML = simplicity + reproducibility

Git traces plaintext differences and with notebooks it's a problem

In comparison to notebooks, YAML is more compatible for Git and in the end might be a better solution for ML

unittest Python library doesn't work well in a notebook

To run cells inside a Python script in VSCode, all you need to is to define Jupyter-like code cells within Python code using a # %% comment:

# %%
msg = "Hello World"
print(msg)

# %%
msg = "Hello again"
print(msg)

How JupyterLab differs from a traditional notebook

git-friendly Jupytext options include

• Julia: .jl
• Python: .py
• R: .R
• Markdown: .md
• RMarkdown: .Rmd
• and more!

nbdev

First sighting of Jupyter Notebook (that I recall).

Cool name/logo story!

Such an interesting progression!

Nice to see that decision pay off!

I don't know why or when my annotations will be properly applied.

This is quite confusing. The interface remembers my tag, but not the content of my annotation.

It does not seem to allow the application of an annotation to text inside of an iframe. This prevents proper testing of hypothes.is as a jupyter notebook annotation tool.

In some ways it's great, but the interface and user model could use a lot of work. If it allowed annotations inside iframes I'd gladly navigate those rough edges. But without that feature it's hard to justify trying to use this for the purpose of annotating notebooks.

Hopefully, this can be fixed, in which case I'll edit this annotation to acknowledge that annotation inside iframes works. That would mean the annotation of Jupyter notebooks would be be a process capable of supporting code review on a notebook via GitHub.

Unfortunately this is probably the easiest place to apply a hypothes.is annotation. They don't look inside iframes. So the rendered version of the notebook will not work.

Seco, si bien es una implementación del 2004, tiene varias ideas que son similares a las de Grafoscopio de hoy, incluyendo la persistencia de una imagen (ellos usan HyperGraphDB, pero incluso mencionan Smalltalk), el hecho de ser una aplicación de escritorio y la idea de una computación p2p, o la opción de embeber el motor de rendering de un browser o el browser mismo en un ambiente más rico, incluso la inspiración de los notebooks de mathematica.

How to Annotate Jupyter notebook stored online