The Fortnightly Tambourine

A new mode of explanation in fundamental physics, expressing laws in terms of what is possible or impossible rather than via initial conditions and motion.

Constructor theory represents a shift from the traditional “dynamical” conception of physics—where laws predict the future state of a system given its initial conditions—to a framework based on counterfactuals. Proposed by David Deutsch and Chiara Marletto, it formulates physical laws by defining which tasks are possible (can be performed by a “constructor” with arbitrary accuracy) and which are impossible. This approach aims to provide a unified foundation for phenomena that are difficult to accommodate in standard quantum or classical mechanics, such as information, thermodynamics, and the physics of life.

Google Research introduces a new architecture using deep neural networks for long-term memory, enabling models to handle 2M+ token contexts by updating memory on the fly.

Researchers at Google have introduced Titans and MIRAS, a new architecture and theoretical framework designed to give AI models effective long-term memory without the computational explosion of Transformers. While current alternatives like Mamba-2 trade expressiveness for speed by compressing context into fixed sizes, Titans employs a deep neural network as a dynamic memory module that updates in real-time based on a “surprise metric”—effectively learning context on the fly rather than compressing it into a static state. This approach, grounded in the MIRAS framework’s move beyond standard Mean Squared Error optimization, reportedly allows Titans to outperform GPT-4 on the BABILong benchmark with context windows exceeding 2 million tokens.

Version v0.0.15 of CodeWeaver, the open source tool that transforms your codebase into a single navigable Markdown document, was released, with a series of polish, quality-of-life improvements, and new capabilities.

Instruction flag: prepend custom text to the generated Markdown. Binary-content detection: automatically excludes binary files from the content section. Dynamic code fencing: code blocks now adapt to backticks inside files. Extension summaries: logs now show which file types were included or excluded. Cleaner tree view: prunes empty directories and removes folder coloring for clarity. Improved internal comments. Normalized log paths and standardized tree indentation for consistent output.

DSBG v0.1.6 brings 7 mobile friendly themes and the new template variables TAG, TAGS, TEXT and IMAGE.

Contribute with new themes, eventual bugfixes, requests, ideas or just spreading the word!

Clarivate expels 'Science of the Total Environment' from its index, exposing the perverse incentives of the 'pay-to-publish' model and the massive profit margins of publishers like Elsevier.

This El País article details the expulsion of Science of the Total Environment (STOTEN) from the Clarivate indexing system, a major blow to its reputation. The journal, under the editorship of Damià Barceló, had ballooned its output to nearly 10,000 articles annually, including scientifically dubious papers such as one claiming jade amulets could prevent COVID-19. The scandal highlights the deep structural rot in academic publishing. With the shift to “Open Access,” the business model moved from “pay-to-read” to “pay-to-publish.” This created a perverse incentive: the more papers a journal accepts, the more money it makes. Elsevier, the owner of STOTEN, reportedly operates with a 38% profit margin—accumulating $1.5 billion in 2024 alone. The article argues that this “factory farm” approach to science, driven by the “publish or perish” culture in academia, is funneling billions of public research dollars into the pockets of private publishing giants like Elsevier, Springer Nature, and Wiley, often at the expense of scientific rigor.

A pioneering Mexican science fiction and dystopian novel by Eduardo Urzaiz Rodríguez, originally published in 1919. It describes a future society organized around eugenics and collectivism.

Gareth Loy's comprehensive two-volume guide to the mathematical and physical foundations of music, covering everything from acoustics and scales to digital signal processing and composition.

http://www.musimathics.com/ https://mitpress.mit.edu/9780262516556/musimathics/

A cosmological treatise written by the child prodigy William James Sidis in 1920, in which he theorizes about the origin of life in the context of thermodynamics and the second law, proposing a "reverse" universe.

The book can be found freely in https://www.sidis.net/animate.pdf or at the https://archive.org/details/TheAnimateAndTheInanimate.W.J.Sidis/page/n3/mode/2up, with and audiobook version in https://librivox.org/the-animate-and-the-inanimate-by-william-james-sidis/ and https://www.youtube.com/watch?v=6453yOu_00Q.

How I vibe-coded a markdown preprocessor over a weekend with only free tools

While I am no stranger to coding, I decided to try to “vibe code” a markdown preprocessor from the ground up. The idea was to replace some mathematical manipulations I’ve been doing using Python notebooks with something cleaner. The basic idea was to have something that runs selected code fences in markdown files and replaces them with the actual result. The full history, including the reasoning from the models that feature this capability, is available at the app’s https://github.com/tesserato/Inscribe (make sure to give it a star!). From the initial concept to the choice of programming language, and even the name (twice!), everything was vibe coded. The Claude history was downloaded with the Claude Exporter https://www.claudexporter.com/en. To feed the codebase to the models when necessary, I used https://github.com/tesserato/CodeWeaver, a CLI I made a while back. Without further ado: I started using Gemini 2.5 Pro via https://aistudio.google.com/ User I would like to make a markdown preprocessor CLI that runs code fences and replaces them with their result. Which language would be better? Rust, Haskell, or another one? Model The model provided a comprehensive breakdown of the options. It highlighted Rust for its best-in-class performance and safety, though it warned of a steep learning curve. It suggested Haskell for parsing elegance and Go or Python for rapid development. Crucially, it flagged the massive security vulnerability of running arbitrary code from a document, suggesting I implement sandboxing or whitelisting. Despite the warnings about the learning curve, I decided to go with Rust for its robustness and the ability to ship a single binary. If you intend to make an app public, it is important to think of a unique name for it from the beginning and check if the relevant repositories are available (which I only did later…), so I asked: User What could be nice names for this app? Model The AI suggested several categories of names: descriptive ones like “MarkRun,” metaphorical ones like “Forge” or “Catalyst,” and punchy CLI names like “Etch” or “Ink.” One stood out for its evocation of ancient magic and reading, so I chose Scroll. With the language and name settled, I needed a blueprint. User develop some specifications for this app i have chosen Rust as the programming language and Scroll as the name of the app. The idea is to have the following code run for example (both inline and the block code fences: import pandas as pd import plotly.graph_objects as go from plotly.subplots import make_subplots # CSV data as a string (replace with file reading if data is in a separate file) # Save the data to a file (for this script's execution) # In a real scenario, you'd just provide the filename file_path = "health.csv" for file_path in ["health.csv", "health Samara.csv"]: # 1. Read the data from disk try: df = pd.read_csv(file_path) except FileNotFoundError: print(f"Error: The file '{file_path}' was not found.") exit() except Exception as e: print(f"Error reading the CSV file: {e}") exit() in place text >pythoncode to be run rest of the stuff Model The model drafted a detailed specification. It proposed using clap for CLI arguments and pulldown-cmark for parsing. It suggested a syntax similar to R Markdown (using curly braces {} inside the code fence info string) and a TOML configuration file to manage runners. While solid, it felt a bit too heavy for the lightweight tool I envisioned. I wanted something cleaner that wouldn’t break syntax highlighting in editors. User the syntax should be based on a comment before each block, so the syntax highlight is not broken. Also, a list of commands and languages could be passed as argument to the execution. […] Model The model pivoted to a “magic comment” syntax (e.g., <!-- scroll: execute -->) placed before code blocks. However, it started adding complex state management for arguments and configurations. I realized I was letting the scope creep, so I told it to strip it back: no arguments, no config files, and—perhaps controversially—drop the security guardrails. If you run scroll on a file, you trust that file. User it is getting over complicated. The is no need to pass arguments to the scripts. Inline code should also be activated by comments. There is no need for a config file either. The comment will specify a language and optionally a command to run the following code. Once specified, this command is the default for that language until changed. Also, drop the security measures. If scroll is explicitly run to preprocess a file, the risks are known. Model We were getting closer, but the architecture still felt heavy. The model was designing a system to manage long-running processes and inter-process communication. I realized we could simplify everything by treating the whole operation as a batch job. User how about not keeping track of running processes? Just read the md, assemble one script for each language, insert the necessary print statements, run the scripts get the results and replace them? Model This was the breakthrough moment. The model validated this “Batch Execution” approach. Instead of keeping a complex REPL open, Scroll would simply read the whole file, glue all Python blocks into one big script, run it once, and splice the output back in. I refined the spec one last time to ensure ease of use: User 1 if no directive to define the runner is given, use sensible defaults 2 no need to handle artifacts. Just make sure the script has the same working directory as the file, and the user can simply generate the artifact and create the markdown piece that user it Model The model generated a final, clean specification: a two-pass batch system where the user is fully responsible for the code they write. A quick syntax tweak to make it even cleaner: User great! Just drop the lang and : from the syntax ( command="" -- should be command="" -- and we are good to go! Before writing code, I checked for any blind spots. Model The model suggested adding Watch Mode (re-running on file save) and Caching. These were excellent ideas, so I asked to incorporate them into the plan immediately, along with better error handling. User Change the following: 1 for the error, when some error ocurr, generate another file ie: <output_name>.err.md, and not the original one 2 Watch Mode and Caching. Env vars should be setted normally and read from the generated scripts, 3 make sure the implementation is cross platform. Then, generate an implementation plan for the app Model With the plan solid, it was time to generate the code. User great! Generate the complete files and step by step instructions to implement scroll Model The model generated the initial Rust code, split into parser.rs, executor.rs, and main.rs. I then started a new session with Gemini to iterate on this base code and handle specific implementation details, feeding it the code generated in the previous step. User Change the codebase as little as possible so that the example # My Report This report demonstrates `scroll`. First, let's define a variable in Python. <!-- scroll --> ```python message = "Hello from a persistent Python script!" ``` Now, let's print that variable in a separate code block. <!-- scroll --> ```python print(message + "\n") ``` And here is a calculation: <!-- scroll --> ```python x = 100 y = 50 print(f"The result is: {x + y}") ``` And here is a calculation `x + y` = <!-- scroll -->`x + y`: ``` is correctly transformed into: # My Report This report demonstrates `scroll`. First, let's define a variable in Python. Now, let's print that variable in a separate code block. Hello from a persistent Python script! And here is a calculation: The result is: 150 And here is a calculation `x + y` = 150: ``` Model The model understood that to achieve this, we needed a more robust parsing strategy. User Formulate a plan for a more elegant solution for engine.rs. Output only the plan. Model The model proposed a complete architectural overhaul. Instead of messy regex replacements on the raw string, it suggested a Single-Pass Parser creating an intermediate representation (Vec<Segment>), followed by a Batch Execution phase, and finally a Sequential Assembly phase. User Does this handles blocks that doesn’t generate outputs, and blocks that generate multiple outputs? Model The model confirmed that by using a delimiter strategy (printing a unique string between blocks), it could correctly map empty outputs (side-effect only code) and multi-line outputs back to their respective blocks. User great. but how we inject that in arbitrary languages, without knowing its print keyword? Model This was a tricky one. The model originally wanted to hardcode print statements inside the engine. When challenged, it pivoted to a configuration-driven approach where the Runner struct defines how to print a delimiter for that specific language. User there is no need for inline_template. The user should implement the print, if he wants to, himself (sorry for the malformed example) Model I realized I was over-engineering the “magic.” I wanted the user to have full control. If they want output, they print it. The model simplified the Runner struct to remove implicit formatting templates. User great. One last think: During the md, the user can redefine the runner. How we deal with that? Model This added a layer of complexity: state changes mid-document. The model correctly identified that we needed to track the “Active Runner” state linearly as we parsed the document, grouping code blocks into batches based on the runner configuration active at that moment. User Great! Generate the complete changed files to implement this, for easy copy and paste! Model The model generated the code. I pasted it in. It compiled, but runtime errors appeared immediately. User Compiling scroll v0.1.0 (C:\Users\carlos.t.santos\Desktop\Files\Reps\Scroll) Finished dev profile [unoptimized + debuginfo] target(s) in 2.11s Running target\debug\scroll.exe -help A markdown preprocessor that executes embedded code blocks … Finished dev profile [unoptimized + debuginfo] target(s) in 0.05s Running target\debug\scroll.exe example.md -o example.out.md --watch ❌ Error: Runner for ‘–>’ is missing a ‘command’ 👀 Watching for changes in ’example.md’. Press Ctrl+C to exit. Model The regex was too greedy. It was trying to parse the closing comment arrow --> as a language name. User the error persists. Let me make a test: how should be the output of the example, and why? Model I forced the model to verbally walk through the logic to prove it understood the task before generating more code. It correctly identified that the regex was ambiguous and fixed it. User Compiling scroll v0.1.0 (C:\Users\carlos.t.santos\Desktop\Files\Reps\Scroll) Finished dev profile [unoptimized + debuginfo] target(s) in 4.40s Running target\debug\scroll.exe -help … Finished dev profile [unoptimized + debuginfo] target(s) in 0.14s Running target\debug\scroll.exe example.md -o example.out.md --watch ❌ Error: Execution failed for command ‘python’. Stderr: Traceback (most recent call last): File “”, line 1, in NameError: name ‘message’ is not defined 👀 Watching for changes in ’example.md’. Press Ctrl+C to exit. Model This error revealed a critical flaw in the batching logic. It was grouping adjacent blocks, but if there was text between them, it started a new batch (and a new process), causing variables defined in the first block to be lost. The model had to rewrite the engine to collect all blocks for a specific runner configuration across the entire file into a single batch. User It works. Just a little problem with newlines: My Report This report demonstrates scroll. First, let’s define a variable in Python. message = "Hello from a persistent Python script!" Now, let’s print that variable in a separate code block. print(message + "\n") This problem actually persisted for about 10 more exchanges, at which point I decided to try Claude’s Sonnet 4.5. I try to use it sparingly because of the inferior requests limit. I do not find it particularly better or worse than other models, but sometimes it offers new insights. User Can you simplify and fix this code? https://github.com/tesserato/Inscribe/blob/main/example.md should be transformed exactly into https://github.com/tesserato/Inscribe/blob/main/example.out.md, respecting the newlines Model Claude analyzed the code and pointed out that the replacement logic was complex and error-prone. User File: example.out.md that was the generated output… Model Claude realized that the double newlines were coming from Python’s implicit newline and the tool adding another one. User File: example.out.md Model We went back and forth on the exact expected output structure. User File: example.out.md Try to simplify the regexes and the implementation in general Model Claude proposed a simplified regex strategy. User runners must be able to be overwritten during the script Model Claude fixed a regression: runners must be parsed linearly, not upfront. I decide to start a new prompt with Claude, and ask why the error: User File: File: example.md File: example.out.md why python x = 100 y = 50 print(f"The result is: {x + y}") is getting a newline before it? Model The model found the regex wasn’t consuming the newline before the block. User the output is like this: My Report This report demonstrates scroll. First, let’s define a variable in Python. … And here is a calculation x + y = 150: Model Claude confirmed the blank lines were correct: they reflected the original file’s structure. Branding and Documentation With the code finally working perfectly, I returned to Gemini to prepare for release. It was time to make it professional. User create some nice examples to showcase the functionality of this codebase Model Gemini generated examples: System reports Custom runners Data visualization with matplotlib Reading JSON files User Can you improve the readme? Be sure to add a mention to Watch mode Model It generated a polished, badge-rich README including Watch Mode. User in key feature, generate a line about how the session is preserved for each language. Output only the new line Model Stateful Execution: Code blocks of the same language share a single runtime session, allowing variables and state to persist. User the name scroll is taken. Can you think of other nice names? Model It tried: MarkRun, Quill, Fuse… User nope. all taken Model It tried harder: Sigil, Weft, Inscribe, Markout. User Inscribe it is! Generate a professional readme for the app Model It generated a new README for Inscribe. User change the codebase to reflect the renaming Model It updated all references from scroll to inscribe: Cargo.toml, regexes, README, config, engine, docs. User professionally comment this codebase so I can upload it to crates.io Model The model added crate-level, module-level, and API-level documentation. User generate a show hn text Model It drafted three Show HN variants. User just clear the list below for the body text Execute Code Fences: Run code from various languages directly within your markdown. Multi-Language Support: Built-in runners for Python, JavaScript/Node, Ruby, Shell (bash, sh), and more. Customizable Runners: Easily define custom commands for any language (e.g. use python3.11 instead of python). Inline Code Execution: Run and replace short, inline code snippets for dynamic text. File Watching: Automatically reprocess your document whenever the source file changes for a seamless workflow. Post-Processing Hooks: Run any command (like a static site generator or pandoc) after a file is successfully processed. Standard I/O: Works seamlessly with stdin and stdout for easy integration into Unix pipelines. Stateful Execution: Code blocks of the same language share a single runtime session, allowing variables and state to persist from one block to the next. Model A plain-text body list was produced for showHN/posting reuse. User just clear the formatting, since there is plain text Execute Code Fences: Run code from various languages directly within your markdown. … Model All markdown bolding and icons removed; plain text version output. User change the code below to also output current date and time in human readable format: println!( "\n🔄 Detected change, reprocessing '{}'...", input_path.display() ); Model chrono added to Cargo.toml; src/main.rs now logs Local::now().format("%Y-%m-%d %H:%M:%S"). User the output (WRONG AGAIN…) Model The model acknowledged the mismatch and dug back into the regex and replacement logic. It traced the remaining issues to newline handling and to how empty-output blocks were being handled in the assembly pass. User the block message = "Hello from a persistent Python script!" Should vanish, as it does not generate output. Its four fucking lines gone! The block below x = 100 y = 50 print(f"The result is: {x + y}") shouldn’t have a newline BEFORE it. Yet, your dumbass result is like below: My Report This report demonstrates scroll. First, let’s define a variable in Python. Now, let’s print that variable in a separate code block. Hello from a persistent Python script! And here is a calculation: The result is: 150 And here is a calculation x + y = 150: Model At that point I lost my cool. The model finally realized the issue wasn’t the runtime output but the regex: it didn’t consume the trailing newline after fenced blocks. The fix: ensure the fenced-block regex consumes the optional trailing \r?\n?, and simplify replacement to “replace exactly what the block matched with the block’s stdout (trimmed appropriately for inline blocks).” User Is this right, dumbfuck? Model The model apologized, fixed the regex to include the trailing newline when matching a fenced block, and simplified the replacement strategy to “trust the user”: fenced blocks are replaced with raw block output (including newlines inside printed output), inline blocks are trimmed to a single inline output token, and runner-definition directives produce no output (they are consumed). User does this implementation support overwriting the runner in the middle of the script? Model Yes. Because we parse the document linearly into segments, and we track the active runner configuration at each point, a runner-definition directive that appears mid-file becomes the active runner for following blocks — and the batching/assembly phases honor that. User it works. Generate a plan to implement watch mode. Also, add an optional argument to let the user specify a command to call after the file is generate, both in watch and normal modes Model Plan (summary): Add notify as a dependency; spawn a RecommendedWatcher. Debounce events to avoid multiple triggers from editors that save in multiple steps. When a save event triggers, re-run the processing pass for the file, write to <output>, and then (if specified) run --on-finish command, substituting {{input}} and {{output}}. Add CLI --on-finish <cmd> and --watch flags; ensure cross-platform quoting and command splitting. If execution fails, write <output>.err.md with a helpful error message and the raw stderr. Use environment variables for configuration available to generated scripts; ensure scripts run in the same working directory as the input file. User great! generate the complete modifiles, for easy copy and paste Model The model produced the required code modifications and split the logic into config.rs, engine.rs, and main.rs with watch-mode glue. The files compiled. User Change the codebase to use pomsky instead of regex Model I attempted an experiment replacing regex usage with pomsky-macro to make the regexes more readable at compile-time. User there is no pomsky_lib Model The model hallucinated pomsky_lib. The correct dependency is pomsky-macro which expands to regex types; the code was corrected to use pomsky-macro macros over regex::Regex, or reverted to regex when that proved fragile. Ultimately I reverted to regex with clearer, separate regexes per block type. User riiiight. So revert to regex, but keep the improved and tested UNIFIED_RE and BLOCK_RE patterns that correctly include the trailing newline. Also ensure the parser produces Vec<Segment> intermediate representation. Model Done. The updated UNIFIED_RE and BLOCK_RE patterns now treat fenced blocks as including their trailing newline, which solved the newline war. The parser produces a Vec<Segment> where each Segment is one of: Text(String) — raw text RunnerDef { lang: String, cmd: Option<String> } — directives FencedBlock { lang: String, code: String } — fenced blocks InlineExpr { lang: String, code: String } — inline code snippets The executor collects blocks by runner state into batched scripts, inserts delimiters only when configured (the Runner struct no longer injects print templates by default), runs each batch, splits on the delimiter token, and maps outputs back to segments. User The name scroll is taken. Can you think of other nice names? Model We re-ran the naming exercise. The chosen name was Inscribe (available), which better matches the project’s mechanics and branding. User Inscribe it is! Generate a professional readme for the app Model A polished README.md was generated. It included badges, installation via cargo install inscribe, usage examples, and a highlighted section: Live Reloading with Watch Mode plus --on-finish use cases. User change the codebase to reflect the renaming Model All references were updated: Cargo.toml package name and description, README titles and examples, regex patterns from scroll to inscribe, and internal delimiter constant renamed to INSCRIBE_DELIMITER (and exported via config.rs). User professionally comment this codebase so I can upload it to crates.io Model Doc comments were added (//!, ///) and public API documentation expanded for Runner, process_markdown, and CLI flags. Cargo.toml gained metadata fields and keywords. User create some nice examples to showcase the functionality of this codebase Model I generated an examples/ folder suggestion with: basic-report.md (system commands + python) viz-demo.md (python creates SVG and writes path) custom-runner.md (defining <!-- inscribe node command="node" -->) inline-expressions.md (inline <!-- inscribe --> expressions embedded in sentence) User Can you improve the readme? Be sure to add a mention to Watch mode Model README updated with a dedicated Live Reloading (Watch Mode) section showing inscribe --watch example.md -o example.out.md --on-finish "pandoc {{output}} -o final.pdf". User in key feature, generate a line about how the session is preserved for each language. Output only the new line Model Stateful Execution: Code blocks of the same language share a single runtime session, allowing variables and state to persist from one block to the next. fileciteturn2file17 User generate a show hn text Model Three Show HN drafts were produced; the chosen one was friendly, succinct, and highlighted the Rust pedigree and the watch mode. User just clear the list below for the body text Execute Code Fences: Run code from various languages directly within your markdown. Multi-Language Support: Built-in runners for Python, JavaScript/Node, Ruby, Shell (bash, sh), and more. Customizable Runners: Easily define custom commands for any language (e.g. use python3.11 instead of python). Inline Code Execution: Run and replace short, inline code snippets for dynamic text. File Watching: Automatically reprocess your document whenever the source file changes for a seamless workflow. Post-Processing Hooks: Run any command (like a static site generator or pandoc) after a file is successfully processed. Standard I/O: Works seamlessly with stdin and stdout for easy integration into Unix pipelines. Stateful Execution: Code blocks of the same language share a single runtime session, allowing variables and state to persist from one block to the next. Model A plain-text body list was produced for showHN/posting reuse. User just clear the formatting, since there is plain text Execute Code Fences: Run code from various languages directly within your markdown. … Model All markdown bolding and icons removed; plain text version output. User change the code below to also output current date and time in human readable format: println!( "\n🔄 Detected change, reprocessing '{}'...", input_path.display() ); Model chrono added to Cargo.toml; src/main.rs now logs Local::now().format("%Y-%m-%d %H:%M:%S"). User Everything compiles. Anything else left? Model Final checklist: README ✅ Crate metadata ✅ Watch mode ✅ Debounce for watcher ✅ --on-finish hook ✅ Error file writing <output>.err.md ✅ Tests and CI — suggested but left to author ✅ User Ready to publish? Model Yes. I produced a publish-checklist.md with steps: run cargo test, ensure license file, bump version, run cargo publish --dry-run, then cargo publish. Also recommended adding GitHub Actions CI. There you have it.

A theoretical demonstration of on-chip programmable diffractive deep neural networks using rewritable Sb₂Se₃ phase-change metasurfaces, offering a compact, non-volatile solution for optical computing.

Published in Scientific Reports, this study by Sanaz Zarei introduces a programmable on-chip diffractive deep neural network built from cascaded phase-change metasurfaces. By utilizing Antimony Triselenide (Sb₂Se₃) and direct laser writing, the architecture overcomes the static nature of traditional optical networks, allowing for non-volatile reprogramming and error correction. The design is theoretically benchmarked on MNIST digit classification and pattern recognition, achieving accuracies comparable to state-of-the-art electronic systems while maintaining an ultra-compact footprint and low power consumption. Similar efforts can be seen in https://www.nature.com/articles/s41928-022-00719-9.

CLI to generate interactive scatter plots from massive data or audio files

Create interactive, single-file HTML scatter plots from data (CSV, Parquet, JSON, Excel) or audio formats (WAV, MP3, FLAC, OGG, M4A, AAC). Built for speed and massive datasets with optional intelligent downsampling. https://github.com/tesserato/Scatters

Silvanus P. Thompson's classic 1910 textbook that teaches the fundamentals of calculus in a simple, non-technical manner. Freely available in multiple places (Public Domain).

https://calculusmadeeasy.org/?fbclid=IwZXh0bgNhZW0CMTAAYnJpZBExNDdGdldENXM1WjFoZjROVwEeYPrk5PoYAecpAdFsDkoq98N3I8Y7Buw8ACM0wJhhIMwoIUArRKXzF23nFlg_aem_izy4U9ler2pwdq8nH1b6FA https://www.gutenberg.org/files/33283/33283-pdf.pdf https://archive.org/details/calculus_made_easy_1608_librivox

Bell Labs was a powerhouse of innovation—its unique culture and structure made it legendary. What can we learn from it today?

As a researcher, and a digital music enthusiast on top of that, it is hard to be oblivious to the name Bell Labs. One encounters the name so frequently in the annals of 20th-century technology that it sometimes feels as though all significant innovation between the 1940s and 1970s originated from this singular institution. Bell Labs is widely recognized as a powerhouse of U.S. innovation and one of the most productive industrial laboratories of all time, fundamentally shaping the modern world with its research.#fn:1 Its success in fostering groundbreaking innovation in the 20th century is attributed to a unique confluence of resources, concentrated talent, and a powerful workplace culture.#fn:1#fn:2 Jon Gertner, in his New York Times essay “True innovation” and his book The Idea Factory: Bell Labs and the Great Age of American Innovation, suggests Bell Labs not only offers lessons on how U.S. technology innovation came about but also presented a “more encompassing and ambitious approach to innovation than what prevails today.”#fn:3 He observed that its “staff worked on the incremental improvements necessary for a complex national communications network while simultaneously thinking far ahead, toward the most revolutionary inventions imaginable.”#fn:3 Further emphasizing this unique atmosphere, Michael Noll, an engineer during its heyday, has noted that the innovative environment often associated with modern Silicon Valley had antecedents at Bell Labs, stressing that understanding the people and their motivations is key to grasping why so many were drawn to contribute there.#fn:4 The core of Bell Labs’ success, as Gertner argues, can be traced to figures like Mervin Kelly, who was “most responsible for this culture of creativity.”#fn:3 Kelly’s fundamental belief was that an “institute of creative technology” required a “critical mass” of talented individuals to foster a dynamic exchange of ideas.#fn:3#fn:2 Crucially, he was convinced that “physical proximity was everything,” leading to the intentional co-location of “thinkers and doers.”#fn:3 This meant physicists, metallurgists, and electrical engineers involved in projects like the transistor worked side-by-side, blending theory, experimentation, and manufacturing expertise.#fn:3#fn:5 Kelly, like an “able concert hall conductor,” aimed to create harmony, and at times productive tension, between disciplines, between researchers and developers, and between individual contributors and collaborative groups.#fn:3 This environment stands in stark contrast to what Gertner perceived as the contemporary “belief that small groups of profit-seeking entrepreneurs turning out innovative consumer products are as effective as our innovative forebears.”#fn:3 He contended that history does not support this, noting, “The teams at Bell Labs that invented the laser, transistor and solar cell were not seeking profits. They were seeking understanding. Yet in the process they created not only new products but entirely new—and lucrative—industries.”#fn:3#fn:1 Gertner’s analysis stimulated notable responses. One letter to the editor, from a digital signal processing engineer, concurred that modern tech giants often engage in “juggling, renaming and rebranding existing technologies in a way that maximizes profit,” rather than pursuing the kind of foundational innovation characteristic of Bell Labs.#fn:3 Another correspondent highlighted that Bell Labs’ existence was “predicated on an implicit tax foisted on the nation’s phone bills by its monopoly,” raising questions about whether such a business model is uniquely conducive to innovation.#fn:3#fn:6 This point underscores the financial stability that allowed Bell Labs to pursue long-term, ambitious research. A further response emphasized the ongoing need for national investment in basic research, a principle that Bell Labs epitomized.#fn:3 Even as times changed, the spirit of Bell Labs persisted; despite sometimes being referred to in the past tense, Jeong Kim, then president of Bell Labs, asserted the institution’s continued vitality and focus on “promising new technologies for the future,” citing “remarkable progress on a potentially revolutionary technology to move us beyond the approaching limits of the optical transport systems that make up the foundation of the Internet.”#fn:3 Central to this enduring legacy was a profound respect for individual autonomy. A core tenet was the freedom and dignity of the individual scientist.#fn:4#fn:7 Leaders like Kelly acted more as patrons than micromanagers, believing that genius required autonomy.#fn:7 Researchers, such as Claude Shannon, were often free to pursue their intellectual curiosities, sometimes for years, without immediate pressure for direct financial return.#fn:4#fn:1 Discoveries, therefore, often percolated through the organization organically. This philosophy of empowerment was further articulated by Ralph Bown, a Bell Labs VP of Research, who identified two crucial freedoms for accomplishing work effectively: the freedom for research groups to say no to external problems, allowing them to focus their energies on the most fruitful avenues, and the right for researchers to carry their ideas experimentally into the application stage, demonstrating their merit and fostering a connection between basic research and practical application.#fn:7#fn:2 Beyond internal freedoms, Bell Labs also encouraged its staff, many of whom were respected figures in academia, to engage with the wider scientific world.#fn:4#fn:2 This outward-looking approach was exemplified by the paramount importance of freedom of publication; the interchange of knowledge was seen as the “life blood of scientific advance.”#fn:2 Internally, the leadership structure reinforced this ethos. Supervisors aimed to bring out the best in others, ensuring that credit for inventions went to the individuals responsible.#fn:4#fn:7 While resources were ample, the unique atmosphere of intellectual freedom and peer recognition was considered a more significant motivator than salary alone.#fn:4 This distinctive environment, fueled by the resources of AT&T’s monopoly#fn:6 and a culture that championed talent, collaboration, long-term vision, and scientific freedom,#fn:4#fn:1#fn:7#fn:2 allowed Bell Labs to generate transformative innovations like the transistor,#fn:5 the laser, and the foundations of Unix and C.#fn:3 It serves as a historical benchmark, reminding us that true breakthroughs often emerge from environments that prioritize deep understanding, patience, and a willingness to invest in people over immediate product cycles.#fn:8 While the specific economic conditions that supported Bell Labs may be hard to replicate,#fn:6#fn:8 its cultural lessons on fostering creativity and long-range research remain profoundly relevant. References https://www.flickr.com/photos/airport/30502237513/in/photostream/ used under the https://creativecommons.org/licenses/by-sa/2.0/. https://www.forbes.com/sites/quora/2017/07/19/why-bell-labs-was-so-important-to-innovation-in-the-20th-century/. #fnref:1↩︎ #fnref1:1↩︎ #fnref2:1↩︎ #fnref3:1↩︎ #fnref4:1↩︎ https://maceip.github.io/bell-labs-innovation/ #fnref:2↩︎ #fnref1:2↩︎ #fnref2:2↩︎ #fnref3:2↩︎ #fnref4:2↩︎ #fnref5:2↩︎ https://doi.org/10.1063/PT.4.0193‘’. #fnref:3↩︎ #fnref1:3↩︎ #fnref2:3↩︎ #fnref3:3↩︎ #fnref4:3↩︎ #fnref5:3↩︎ #fnref6:3↩︎ #fnref7:3↩︎ #fnref8:3↩︎ #fnref9:3↩︎ #fnref10:3↩︎ #fnref11:3↩︎ #fnref12:3↩︎ #fnref13:3↩︎ https://quello.msu.edu/being-there-a-personal-perspective-on-the-culture-of-innovation-at-bell-labs/. #fnref:4↩︎ #fnref1:4↩︎ #fnref2:4↩︎ #fnref3:4↩︎ #fnref4:4↩︎ #fnref5:4↩︎ #fnref6:4↩︎ https://en.wikipedia.org/wiki/History_of_the_transistor. #fnref:5↩︎ #fnref1:5↩︎ https://trmcdonald.substack.com/p/the-rise-and-fall-of-bell-labs-how&. #fnref:6↩︎ #fnref1:6↩︎ #fnref2:6↩︎ https://1517.substack.com/p/why-bell-labs-worked. #fnref:7↩︎ #fnref1:7↩︎ #fnref2:7↩︎ #fnref3:7↩︎ #fnref4:7↩︎ https://www.noahpinion.blog/p/the-dream-of-bringing-back-bell-labs #fnref:8↩︎ #fnref1:8↩︎

Odin is one of the most interesting new languages out there: a modern, clean, data-oriented alternative to C.

As a programming freak always on the lookout for new tools and paradigms, the emergence of languages like Odin is exciting. It promises a fresh take on systems programming, a domain long-dominated by C and C++. The goal of bringing back the “Joy of Programming” was what caught my eye, though. It is being used in productions in https://jangafx.com/software/embergen and https://jangafx.com/software/geogen.

My journey exploring Zig for (scientific) programming, its current strengths, limitations, and why Rust ultimately won out for a specific project.

After more than a year working day in and day out on a large Python codebase, I started looking for a statically-typed language where I could be as productive as I am in Python. While Python’s type hinting helps, I’ve found that features not directly enforced by the language can become problematic in real-world, large-scale projects. For bigger endeavors, I’ve generally settled on Go (https://github.com/tesserato/dsbg, https://github.com/tesserato/CodeWeaver) or Rust (https://github.com/tesserato/cloudmapper, https://github.com/tesserato/BibRust), depending on the specific requirements. Although I appreciate C++, its tooling felt too different from my daily workflow, so it was off the table from the start. For traditional scientific programming, however, both Go and Rust can feel a bit heavyweight. This led me to explore “modern C” alternatives, and Zig, a language I kept reading about, particularly caught my attention. My initial foray into Zig involved implementing a series of finite difference schemas I was deriving. On the bright side, once I got the hang of it, the language largely got out of my way. It felt modern, close to the metal, and remarkably fast. As the work progressed, however, I began to miss more mature tooling and a richer ecosystem. At one point, I needed to generate videos based on these schemas; for that, I had to resort to saving large CSV files and then using Python for the video generation, which was a bit clunky and awfully slow. The error messages also left something to be desired. The last straw was the lack of built-in parallelism. I discovered that, as of version 0.14.0 (see discussions like https://www.reddit.com/r/Zig/comments/1dned9t/im_confused_by_the_state_of_concurrency_right_now/), concurrency features had been removed from the language, with plans to reintroduce them later. The language is clearly still in flux, with a development philosophy that seems to prioritize breaking changes now to achieve long-term correctness. While this approach is laudable, I found Zig too immature for my current needs. I ended up porting the entire project to Rust, where I could directly generate videos, leverage parallel processing, and benefit from more mature tooling. This isn’t to say Zig can’t be used in production—projects like https://bun.sh/ demonstrate its capabilities—but for my specific project, Rust was a better fit at this time. All in all, I’ll keep an eye on its development and will likely try Zig again in the future.

CloudMapper is a tool to visualize and analyze your cloud storage usage across multiple providers. Open-sourced to help you gain insights and control over your distributed files.

Over the years, I found myself juggling data between Google Drive, Dropbox, OneDrive, Box, and others, with no easy way to get a unified view of what was stored where, how much space was used, or where duplicates were hiding. To solve this, I built CloudMapper—a tool that scans your cloud storage accounts, aggregates metadata, and generates visualizations and reports to help you understand your storage usage. With CloudMapper, you can: Visualize storage usage: Generate treemaps and summaries to see which folders and files are taking up the most space. Find duplicates: Identify duplicate files across providers to reclaim wasted space. Analyze file types: Get breakdowns by file extension, size, and more. Export reports: Output results as HTML, Markdown, or plain text for further analysis. CloudMapper is open-source and available at https://github.com/tesserato/cloudmapper. Key Features Unified view of multiple cloud storage providers Treemap visualizations for quick insights Duplicate file detection File type and size analysis Exportable reports Installation CloudMapper is written in Rust and can be easily installed using Cargo. See the https://github.com/tesserato/cloudmapper?tab=readme-ov-file#installation for detailed instructions.

Barrie's beloved 1911 novel (originally titled Peter and Wendy) about the boy who refuses to grow up. The story follows the Darling children's flight to Neverland, where they encounter the Lost Boys, Tinker Bell, and the villainous Captain Hook.

At about the end of the first quarter of the book as of 2025 12 02 on Google Play Books. ( “Nana wagged her tail, ran to the medicine, and began lapping it.”) https://www.gutenberg.org/ebooks/16 https://librivox.org/peter-pan-version-4-by-j-m-barrie/

During my PhD, I went a bit out of my way to comment on the history of digital musical instruments. I felt that it could aid in motivating the reader for the myriad of more complex topics to come. The original section, with minor corrections, follows here.

The theory was applied to the development of the open-source https://github.com/tesserato/PianoForte digital instrument. More info about the project can be found at https://omnessonos.web.app/. The full thesis is available at https://app.uff.br/riuff/handle/1/29781. Music is a staple of humanity’s creativity. Montagu defines music as sounds generated deliberately with the aim of provoking emotion.#fn:1 Musical instruments, consequently, can broadly be defined as any tool used for that purpose. In this context, music can be traced back to time immemorial, with its origins probably motivated by ritual practices performed by early humans. Whereas the very first musical instrument was most probably the voice, it might have been shortly followed by other rudimentary musical instruments, likely of a percussive nature#fn:2: Evidence of the use of simple instruments, such as drums and bone flutes, can be traced back to the Paleolithic era, more than 30,000 years ago#fn:3. During the course of human history, musical instruments became more elaborate, incorporating technological advancements, responding to and also helping to evolve the predominant aesthetic of music in each society. Despite reaching, along this long period of evolution, a high degree of sophistication in their design, before the 20th century, musical instruments necessarily relied on mechanical vibrations to generate their sounds. In a comprehensive timeline of the technology associated with electronic music, Stubbs marks the year 1876, with the invention of the Musical Telegraph by Elisha Gray — a device that broadcast single notes along telegraph lines — as the beginning of the electronic instruments’ era.#fn:4 Regarding stringed instruments, in 1890, George Breed, a United States Naval Officer, filed a patent for an electrified guitar. Electricity, however, was not used for amplification purposes, serving instead to continually vibrate the guitar strings, leaving the instrument’s sound acoustic in nature. The patent also suggests the use of this method for an electric piano, albeit in a less detailed way. The guitar’s design, in addition to differing considerably from what we now consider an electric guitar, presented some idiosyncrasies that probably prevented its commercial success#fn:5. Other authors place the origin of this new electronic era for musical instruments at the invention of the Telharmonium, patented in 1897 by Thaddeus Cahill, due to the influence the instrument eventually exerted. The Telharmonium, also known as Dynamophone, was a machine weighing around two hundred tons, intended to synthesize music with the use of sinusoidal tones of different frequencies generated with modified dynamos, to be broadcast in real-time over telephone lines#fn:6. Still others, such as Montagu, attribute the beginning of electronic instruments to the invention of the Theremin by Lev Termen, around 1920, on the grounds of the popularity the instrument accrued at the time, both in its original USSR and in the USA.#fn:7 About a decade later, the first commercially successful guitars started to emerge. Notorious among them was the Gibson ES-150 in 1936, with a single pickup responsible for capturing the vibration of the metallic strings#fn:8. Electric guitars, due to the mechanical origins of the sound generated, are not regarded as purely electronic instruments. Be that as it may, the Moog synthesizer was the instrument responsible for popularizing electronic instruments. Implementing the ideas published by Robert Moog#fn:9, it is largely considered the first analog synthesizer, and the first commercial synthesizer. Wendy Carlos’s 1968 album Switched-On Bach, featuring Bach compositions arranged for the Moog synthesizer, achieved critical and popular acclaim#fn:10, helping to popularize the instrument, which would also be used by bands such as The Beatles, Rolling Stones, and Yes. The theoretical foundation underlying the developments introduced by the process of electrification, especially concerning the area that came to be known as digital signal processing, can be traced back to a few centuries before those events, however. The work of d’Alembert and the introduction of differential equations#fn:11, Euler, with the invention of integral transforms#fn:12, Bernoulli, and most notably Fourier, formed the theoretical basis for the birth of DSP#fn:13: how this process happened is described in more detail in Chapter Theory. For the theory to be applied in the form it is known nowadays, however, computers were needed, and it was only after the Second World War that such machines would first emerge, with examples such as the ENIAC and the IAS, dating from the mid to late 1940s. With growing access to computers, the area of DSP started to consolidate itself in subsequent decades. Fortunately, parallel to that revolution, another was taking place, one that would eventually lead to the development of modern digital computers. The need to process large amounts of data, both in Europe and the US, led to an increasing interest in calculating machines. A punched card tabulating system was developed for the US government to be used in the 1890 census and became so popular in the first half of the twentieth century that it originated IBM. A few decades later, the company consolidated itself as a business machine manufacturer, with an income of 20 million dollars by 1928. This quest for computing machines, and the rudiments of modern computer science, can be traced back at least a century earlier, however, as described in Kelly#fn:14, to the efforts of Charles Babbage. Motivated by the desire to improve the process of manufacturing navigational tables for the English government, Babbage designed his first famous computation machine, the Difference Engine, in the early 1820s. Despite securing funding and completing a working prototype, Babbage never completed a full-scale Difference Engine. Technical problems encountered along the way led him to investigate the state of the art of English mechanical systems and eventually conceptualize, about a decade later, the Analytical Engine, first mentioned in a statement for the English government in 1834. By suggesting that funding should be shifted to this new machine without having completed the former and the tables it was supposed to produce, Babbage undermined the government’s confidence in him. Despite this, Babbage continued to work on the Analytical Engine for the rest of his life and secured the interest of people such as Ada Lovelace, responsible for the most extensive account of the machine at the time. Ultimately, however, his efforts were insufficient to ensure the construction of the machine, with Babbage’s failure motivating scientists to momentarily pursue another path to computing machines: analog computing. This was unfortunate, since Babbage’s design for the Analytical Engine exhibited all the characteristics encountered in a modern digital computer, such as separation of arithmetic and storage, and would likely be Turing-complete#fn:15. Nevertheless, the beginning of the 20th century saw the ascension of analog computing, with the term analog coming from the word analogy. Analog computers were single-purpose machines built as scale models of the problems they were intended to solve, such as dam building and electrical grid design. In 1937, inspired in part by Babbage’s concepts, Aiken proposed to IBM the first designs of the Mark I, which was finalized, after a series of delays, in January 1943, becoming the first fully automatic computation machine. It was electromechanical in principle, with an abundance of moving parts, and was eventually superseded by strictly electronic designs. Parallel to those developments, in the field of mathematics, Turing and Church were making advancements in the theory of logic, independently arriving at similar results in the mid-1930s. Turing’s approach, however, involved a conceptual computer, later known as the Turing Machine, and a proof, described in his article ‘‘On Computable Numbers with an Application to the Entscheidungsproblem’’#fn:16, that this idealized machine could compute any function. While staying at Princeton University, Turing met John von Neumann, who would go on to play a prominent role in the invention of the modern electronic computer, inspired in part by Turing’s work. John von Neumann became involved in the computer development scene when he became aware of the ongoing efforts for the construction of the ENIAC, around 1944, a computer that used thousands of valves and was built to use the decimal system. Neumann started to work as a consultant for the team and soon identified many potential problems with the machine, leading him to start designing a successor capable of addressing those problems. His report ‘‘A First Draft of a Report on the EDVAC’’#fn:17, originally from June 30, 1945, laid the basis for modern digital computers. When finally operational, at the beginning of 1950, the EDVAC ushered in the new era of digital computers. From this point on, the process of popularization of the computer, from a mathematical machine to a general-purpose appliance, would continue, eventually culminating in the creation and widespread adoption of personal computers. Since the early days of digital computers, even when mainframes were the only available machines, restricted to organizations with considerable resources, people found ways and motivation to overcome technical limitations and develop artistic applications, like video games, in their — and the machines’ — spare time. At the 1940 New York World’s Fair, for example, the Nimatron was first exhibited#fn:18. It was a single-purpose, electromechanical machine designed to play the game of Nim, described in Redheffer#fn:19. Another example is a computer chess game for programmable machines, written by Turing in 1947, that could not be implemented due to the limitations of available computers at the time#fn:20. In the following year, the patent for the cathode-ray tube amusement device, considered the first known example of an interactive electronic game, was granted#fn:21. Regarding musical applications, in 1957, while working at the Bell Telephone Laboratories, Max Mathews created MUSIC I, a programming environment intended to simulate the circuitry for analog musical synthesizers in digital computers#fn:22. His efforts are described in Mathews#fn:23, and inaugurated the quest for digital sound synthesis. In the seminal paper ‘‘The Digital Computer as a Musical Instrument’’#fn:24, Max Vernon Mathews, after years of using computers to analyze sounds at Bell Labs, argued that digital computers could be used not only to aid in composition and other high-level music-related tasks, but also to generate sounds that could be reproduced by loudspeakers. The paper highlights that computers are theoretically capable of synthesizing any sound, proceeding to describe the process in which discrete numbers can be transformed into sounds and, in so doing, introducing the concept of discrete numbers as samples from the instantaneous pressure of a sound wave. To convert those numbers to sound, a digital-to-analog device, capable of generating pulses proportional to the magnitude of each number, is to be used, and those pulses smoothed a posteriori. The paper also highlights the practical necessity of compact sound representations. Mathews went on to implement, in 1968, the successor to the MUSIC I-IV family, Music V, in Fortran, the first music programming language to be implemented in a portable programming language#fn:25. Around that time, in 1965, Cooley and Tukey introduced what is now known as the FFT algorithm, in the paper ‘‘An algorithm for the machine calculation of complex Fourier series’’#fn:26, one of the 10 most influential algorithms of the 20th century#fn:27. The FFT algorithm, by exploiting symmetries, reduced the complexity of the calculation of the DFT from \(O(N^2)\) to \(O(N \log_2(N))\), where \(N\) is the length of the original discrete signal, for cases when \(N\) is a power of \(2\). Although this algorithm was originally discovered by Gauss#fn:28, and rediscovered at least a handful of times in the approximately 100 years between Gauss and Cooley#fn:29 #fn:30, it became famous in the form proposed by the latter. Montagu, Jeremy (2007). Origins and Development of Musical Instruments. Scarecrow Press. #fnref:1↩︎ Montagu, Jeremy (2007). Origins and Development of Musical Instruments. Scarecrow Press. #fnref:2↩︎ Bovermann, Till, Alberto de Campo, Hauke Egermann, Sarah-Indriyati Hardjowirogo, and Stefan Weinzierl (2017). Musical Instruments in the 21st Century. Springer Singapore. https://doi.org/10.1007/978-981-10-2951-6 #fnref:3↩︎ Stubbs, David (2018). Mars by 1980 : the story of electronic music. Faber and Faber Limited. #fnref:4↩︎ Hill, Matthew (2008). “George Breed and His Electrified Guitar of 1890”. The Galpin Society Journal 61, 193–203. [Link not available] #fnref:5↩︎ Collins, Nick and Julio d’Escrivan, eds. (2007). The Cambridge Companion to Electronic Music. Cambridge University Press. https://doi.org/10.1017/ccol9780521868617 #fnref:6↩︎ Montagu, Jeremy (2007). Origins and Development of Musical Instruments. Scarecrow Press. #fnref:7↩︎ French, Richard Mark (2012). Technology of the Guitar. Springer US. https://doi.org/10.1007/978-1-4614-1920-4 #fnref:8↩︎ Moog, Robert A. (July, 1965). “Voltage controlled electronic music modules”. journal of the audio engineering society 13 (3), 200-206. [Link not available] #fnref:9↩︎ Collins, Nick and Julio d’Escrivan, eds. (2007). The Cambridge Companion to Electronic Music. Cambridge University Press. https://doi.org/10.1017/ccol9780521868617 #fnref:10↩︎ Oliveira, Agamenon R. E. (2020). “D’Alembert and the Wave Equation: Its Disputes and Controversies”. Advances in Historical Studies 09 (04), 229–239. https://doi.org/10.4236/ahs.2020.94019 #fnref:11↩︎ Dominguez, Alejandro (January, 2016). “Highlights in the History of the Fourier Transform”. IEEE Pulse 7 (1), 53–61. https://doi.org/10.1109/mpul.2015.2498500 #fnref:12↩︎ Alessio, Silvia Maria (2016). Digital Signal Processing and Spectral Analysis for Scientists. Springer International Publishing. https://doi.org/10.1007/978-3-319-25468-5 #fnref:13↩︎ Kelly, Martin (2014). Computer : a history of the information machine. Westview Press, a member of the Perseus Books Group. #fnref:14↩︎ Graham-Cumming, John (December, 2010). “Let’s build Babbage’s Analytical Engine”. New Scientist 208 (2791), 26–27. https://doi.org/10.1016/s0262-4079(10)63100-4 #fnref:15↩︎ Turing, A. M. (1937). “On Computable Numbers, with an Application to the Entscheidungsproblem”. Proceedings of the London Mathematical Society s2-42 (1), 230–265. https://doi.org/10.1112/plms/s2-42.1.230 #fnref:16↩︎ Neumann, J. von (1993). “First draft of a report on the EDVAC”. IEEE Annals of the History of Computing 15 (4), 27–75. https://doi.org/10.1109/85.238389 #fnref:17↩︎ Condon, E. U. (May, 1942). “Clubs and Allied Activities”. The American Mathematical Monthly 49 (5), 330–335. https://doi.org/10.1080/00029890.1942.11991234 #fnref:18↩︎ Redheffer, Raymond (June, 1948). “A Machine for Playing the Game Nim”. The American Mathematical Monthly 55 (6), 343–349. https://doi.org/10.1080/00029890.1948.11999249 #fnref:19↩︎ Donovan, Tristan (2010). Replay: the history of video games. Yellow Ant. #fnref:20↩︎ Wolf, Mark (2021). Encyclopedia of video games : the culture, technology, and art of gaming. Greenwood, an imprint of ABC-CLIO, LLC. #fnref:21↩︎ Collins, Nick and Julio d’Escrivan, eds. (2007). The Cambridge Companion to Electronic Music. Cambridge University Press. https://doi.org/10.1017/ccol9780521868617 #fnref:22↩︎ Mathews, Max V. (May, 1961). “An Acoustic Compiler for Music and Psychological Stimuli”. Bell System Technical Journal 40 (3), 677–694. https://doi.org/10.1002/j.1538-7305.1961.tb03237.x #fnref:23↩︎ Mathews, M. V. (November, 1963). “The Digital Computer as a Musical Instrument”. Science 142 (3592), 553–557. https://doi.org/10.1126/science.142.3592.553 #fnref:24↩︎ Collins, Nick and Julio d’Escrivan, eds. (2007). The Cambridge Companion to Electronic Music. Cambridge University Press. https://doi.org/10.1017/ccol9780521868617 #fnref:25↩︎ Cooley, James W. and John W. Tukey (1965). “An algorithm for the machine calculation of complex Fourier series”. Mathematics of Computation 19 (90), 297–301. https://doi.org/10.1090/s0025-5718-1965-0178586-1 #fnref:26↩︎ Dongarra, J. and F. Sullivan (January, 2000). “Guest Editors Introduction to the top 10 algorithms”. Computing in Science & Engineering 2 (1), 22–23. https://doi.org/10.1109/mcise.2000.814652 #fnref:27↩︎ Cooley, James W. (January, 1987). “The re-discovery of the fast Fourier transform algorithm”. Mikrochimica Acta 93 (1-6), 33–45. https://doi.org/10.1007/bf01201681 #fnref:28↩︎ Heideman, Michael T., Don H. Johnson, and C. Sidney Burrus (1985). “Gauss and the history of the fast Fourier transform”. Archive for History of Exact Sciences 34 (3), 265–277. https://doi.org/10.1007/bf00348431 #fnref:29↩︎ Ceccherini-Silberstein, Tullio, Fabio Scarabotti, and Filippo Tolli (2018). Discrete Harmonic Analysis. Cambridge University Press. https://doi.org/10.1017/9781316856383 #fnref:30↩︎

Automate your digital presence with DSBG, a free and open-source static site generator built with Go that's truly simple to use and focused on helping broadcast your content.

A couple of years ago, I decided it was time to return to the internet and establish a virtual presence. Having been removed from social networks for over a decade at that point, I found the current state of affairs somewhat daunting. I felt overwhelmed by the complexity and, frankly, much of the content I encountered wasn’t to my taste. This was in stark contrast to my personal feed, meticulously curated over the years from a multitude of blogs. Simultaneously, I was trying to organize and give meaning to a vast collection of links, notes, and general content, often in Markdown format, that served me as a kind of external brain. It then dawned on me that I could hack my way back online by establishing a blog as a central hub for my content and sharing to social media from there; the content would come from this second brain and, as a bonus, this approach would compel me to organize this notes dump, potentially making this mass of notes useful to both myself and others. With this goal in mind, I set out to investigate the best and most painless way to set up such a blog. After exploring existing solutions, I decided to build my own, first writing tentative scripts in Python, which quickly became unmaintainable. This situation called for a more robust solution, and I initially spent some time developing one in Rust. However, switching to Go significantly sped up the process, and here it is: the first, more or less stable, version of DSBG. I believe it boasts a good initial feature set, including RSS feed generation, automatic share buttons, themes, and more, making it completely usable (at least for my own use case). Because I believe DSBG could be useful to others in similar situations, I’m releasing it under an MIT license, primarily to gather feedback and solicit help from the community for its further development. This very blog was generated using DSBG. DSBG is available at https://github.com/tesserato/dsbg. Show HN: DSBG - A Static Site Generator that Fast-tracks Your Digital Presence The ethos behind it is to automate your virtual presence as much as possible, while retaining control over the created content. To that end, the following features are available: Easy installation; Support for Markdown & HTML source files; Automatic tag generation from paths ; built-in tag filtering; Client-side fuzzy search over all content; Automatic RSS feed generation; Watch mode with automatic rebuild for continuous feedback; 3 different themes, with the ability to add your own via custom CSS; Automatic share buttons for major social networks; Easy to extend with analytics, comments, and more. A couple of years ago, when I decided to re-engage with social networks, I felt completely lost in the modern internet landscape. Social media felt overwhelming, and I missed the curated, thoughtful spaces of the “old internet.” I also had a massive collection of notes and links (my “second brain”) that was becoming unmanageable. So, I decided to build my way back online with a tool to transform those files as easily as possible into something meaningful and visually appealing. The result is DSBG (Dead Simple Blog Generator). It started as Python scripts, evolved to Rust, and finally landed in Go for speed and simplicity. DSBG is designed to be your central online hub. It lets you: Effortlessly create a blog: Download a binary or go install - setup is incredibly easy. Use your existing content: Supports Markdown and HTML files directly. Organize automatically: Tags are generated from your folder structure, with built-in filtering. Offer instant search: Built in Client-side fuzzy search. Syndicate with RSS: Automatic feed generation. Customize the look: Includes themes and custom CSS support for full control. Share easily: Automatic, custom-made, non-tracking social share buttons. Extend as needed: Simple to add analytics, comments, and more. I believe DSBG can help others who feel overwhelmed and want to build a meaningful online presence painlessly. It’s MIT-licensed, and I’m actively seeking feedback, feature requests, and contributors to make it even better.

Continuing to open-source internal tools, I'm releasing CodeWeaver, a CLI to generate a single markdown file from a directory of source files. The idea is to facilitate sharing and feeding the codebase information to AI tools. Check out https://github.com/tesserato/CodeWeaver for more.

from https://github.com/tesserato/CodeWeaver: CodeWeaver: Generate a Markdown Document of Your Codebase Structure and Content CodeWeaver is a command-line tool designed to weave your codebase into a single, easy-to-navigate Markdown document. It recursively scans a directory, generating a structured representation of your project’s file hierarchy and embedding the content of each file within code blocks. This tool simplifies codebase sharing, documentation, and integration with AI/ML code analysis tools by providing a consolidated and readable Markdown output. The output for the current repository can be found https://github.com/tesserato/CodeWeaver/blob/main/codebase.md. Key Features Comprehensive Codebase Documentation: Generates a Markdown file that meticulously outlines your project’s directory and file structure in a clear, tree-like format. Code Content Inclusion: Embeds the complete content of each file directly within the Markdown document, enclosed in syntax-highlighted code blocks based on file extensions. Flexible Path Filtering: Utilize regular expressions to define ignore patterns, allowing you to exclude specific files and directories from the generated documentation (e.g., .git, build artifacts, specific file types). Optional Path Logging: Choose to save lists of included and excluded file paths to separate files for detailed tracking and debugging of your ignore rules. Simple Command-Line Interface: Offers an intuitive command-line interface with straightforward options for customization. Installation If you have Go installed, run go install github.com/tesserato/CodeWeaver@latestto install the latest version of CodeWeaver or go install github.com/tesserato/CodeWeaver@vX.Y.Z to install a specific version. Alternatively, download the appropriate pre built executable from the https://github.com/tesserato/CodeWeaver/releases. If necessary, make the codeweaver executable by using the chmod command: chmod +x codeweaver Usage For help, run codeweaver -h For actual usage, run codeweaver [options] Options: Option Description Default Value -dir <directory> The root directory to scan and document. Current directory (.) -output <filename> The name of the output Markdown file. codebase.md -ignore "<regex patterns>" Comma-separated list of regular expression patterns for paths to exclude. \.git.* -included-paths-file <filename> File to save the list of paths that were included in the documentation. None -excluded-paths-file <filename> File to save the list of paths that were excluded from the documentation. None -help Display this help message and exit. Examples Generate documentation for the current directory: ./codeweaver This will create a file named codebase.md in the current directory, documenting the structure and content of the current directory and its subdirectories (excluding paths matching the default ignore pattern \.git.*). Specify a different input directory and output file: ./codeweaver -dir=my_project -output=project_docs.md This command will process the my_project directory and save the documentation to project_docs.md. Ignore specific file types and directories: ./codeweaver -ignore="\.log,temp,build" -output=detailed_docs.md This example will generate detailed_docs.md, excluding any files or directories with names containing .log, temp, or build. Regular expression patterns are comma-separated. Save lists of included and excluded paths: ./codeweaver -ignore="node_modules" -included-paths-file=included.txt -excluded-paths-file=excluded.txt -output=code_overview.md This command will create code_overview.md while also saving the list of included paths to included.txt and the list of excluded paths (due to the node_modules ignore pattern) to excluded.txt. Contributing Contributions are welcome! If you encounter any issues, have suggestions for new features, or want to improve CodeWeaver, please feel free to open an issue or submit a pull request on the project’s GitHub repository. License CodeWeaver is released under the LICENSE. See the LICENSE file for complete license details.

Juan Rulfo's seminal 1955 novel telling the story of Juan Preciado's journey to Comala to find his father. A foundational text of the Latin American Boom and a masterpiece of magical realism.

https://archive.org/details/pedroparamo0000juan Started right after watching the Netflix series. About halfway through on Google Play Books as of 2015 12 02. (“Suspiró y trató de imaginar en qué lugar irían ya los vaqueros. Pero lo distrajo el potrillo alazán de Miguel del Páramo, que se rascaba los morros contra la barda.”).

A series of personal writings by Marcus Aurelius, Roman Emperor from 161 to 180 AD, recording his private notes to himself and ideas on Stoic philosophy. Written in Koine Greek as a source for his own guidance and self-improvement, it remains one of the greatest works of spiritual and ethical reflection.

Around the end of the first quarter (“What is divine is full of Providence. Even chance is not divorced from nature, from the inweaving and enfolding of things governed by Providence.”) in Google Play Books as of 2025 12 02. The version I am reading has a nice introduction describing the philosophies he might have had contact at the time. http://classics.mit.edu/Antoninus/meditations.html https://librivox.org/the-meditations-of-marcus-aurelius/

An ancient Greek epic poem attributed to Homer that follows the Greek hero Odysseus, king of Ithaca, and his ten-year journey home after the fall of Troy, as he faces mythical creatures and vengeful gods.

I am at about 11% on this one (“In its attention to Eumaeus and other humble characters”, Stanley Lombardo’s translation) as of 2025 12 02, reading a PDF in the Kindle cloud service.

Transformers can be conceptualized as infinite-state RNNs and efficiently compressed using TOVA, a policy that retains tokens based on attention scores.

This paper conceptually bridges the gap between Transformers and Recurrent Neural Networks (RNNs), demonstrating that decoder-only Transformers function as “unbounded multi-state RNNs.” By limiting the size of the hidden state (the Key-Value cache), the authors introduce a training-free compression policy called TOVA (Token Omission Via Attention). Instead of relying on fixed context windows, TOVA dynamically retains only the tokens with the highest attention scores. The results show that this method can reduce cache size to 1/8th of the original and increase throughput by 4.8x without significant performance loss, proving that massive context windows can be managed efficiently by discarding tokens that the model itself deems unimportant.

NVIDIA launches a family of open models designed to generate and filter synthetic data for training LLMs, addressing data scarcity issues.

To address the scarcity and cost of high-quality training data, NVIDIA has released Nemotron-4 340B, a family of open models optimized for generating synthetic data pipelines. The suite includes Base, Instruct, and Reward models designed to work in tandem: the Instruct model generates diverse outputs, while the Reward model—which topped the Hugging Face RewardBench upon release—filters and grades them for quality. Released under a permissive license, the 340B-parameter models are optimized for NVIDIA’s NeMo and TensorRT-LLM frameworks, providing a scalable solution for developers to train and refine their own commercial LLMs without relying solely on organic datasets.

Physical AI hardware: how to train artificial spin glasses (Ising machines) using Equilibrium Propagation.

As detailed in a 2022 https://spectrum.ieee.org/spin-glass-nanomagnet-ai, “spin glass” nanomagnet arrays have long promised a low-power, self-learning alternative to digital AI, though training them has remained a major physical hurdle. A new study in Nature Communications by Jérémie Laydevant, Danijela Marković, and Julie Grollier finally breaks this barrier by successfully training an Ising machine (a hardware spin glass) using Equilibrium Propagation. This physics-aware algorithm allows the system to learn by relaxing into energy minima—effectively treating the hardware’s intrinsic physics as the computational engine—rather than forcing it to run digital backpropagation. Validated on a D-Wave system, the approach achieved supervised learning results comparable to digital networks, bringing the vision of fully autonomous, physics-based neuromorphic chips closer to reality.

A groundbreaking study using Lidar reveals a vast, 2,500-year-old network of cities in the Ecuadorian Amazon, challenging the view of the rainforest as a historically pristine wilderness.

Published in Science, this study led by Stéphen Rostain (CNRS) unveils the earliest and largest urban network ever documented in the Amazon. Using Lidar technology in Ecuador’s Upano Valley, researchers discovered a dense agrarian civilization lasting over 1,000 years, featuring more than 6,000 earthen platforms, plazas, and an intricate system of straight roads connecting 15 distinct settlements. Described as “garden urbanism,” this complex infrastructure rivals Mayan systems and definitively disproves the notion that the pre-Columbian Amazon was sparsely populated by small nomadic tribes. https://www.bbc.com/news/science-environment-67940671 https://www.smithsonianmag.com/smart-news/archaeologists-discover-ancient-cities-hidden-in-the-ecuadorean-amazon-180983588/

Research from Bar-Ilan University suggests that the brain's wide, shallow architecture can match the classification accuracy of deep learning models, highlighting a divergence between biological efficiency and current GPU optimization.

Researchers from Bar-Ilan University challenge the prevailing “deeper is better” paradigm in AI by demonstrating that the brain’s learning mechanism—which relies on a wide, shallow architecture with very few layers—can compete with deep learning in complex classification tasks. Published in Physica A, the study contrasts the “skyscraper” structure of artificial neural networks with the “wide building” structure of the brain, arguing that network width can effectively substitute for depth. The authors note, however, that adopting this biological approach faces a significant hurdle: modern GPU technology is specifically engineered to accelerate deep architectures and currently fails to efficiently implement the wide, shallow dynamics found in nature.

A study applying quantum mechanics to financial markets, revealing that investor herding is driven by economic uncertainty and is significantly stronger during recessions.

This study proposes a theoretical model based on quantum mechanics—specifically deriving a Schrödinger equation to model stock return dynamics—to explain investor behavior. By analyzing S&P 500 data from 1992 to 2021, the authors demonstrate that “herding” (investors mimicking each other) is counter-cyclical: it is significantly stronger during recessions than during economic booms. The research identifies economic uncertainty as the critical mechanism; as uncertainty rises during downturns, information asymmetry forces investors to abandon independent valuation in favor of following the crowd, a behavioral shift that the quantum model successfully predicts via power law exponents in return distributions.

Why I made yet another blog generator?

In today’s world, it’s safe to say that most of us have a wealth of bookmarked content, as well as a considerable amount of internal notes, documents, and other material that we keep in services like Google Keep and Obsidian. I use Obsidian to store thoughts, incomplete ideas, and pieces of information that might be useful in the future. The problem is that, since it is meant to be consumed by myself only, it’s hard to find the motivation to really polish those notes. I see no point in dating them, either, so you eventually find yourself in a situation where you don’t know if that preliminary research on how to embed 3D animations in HTML is reasonably up to date, or if it is worth redoing in light of new technology that might have emerged. For a couple of years, I’ve been searching for a frictionless way to publish this kind of content. Social networks tend to come and go, so the most future-proof medium has always seemed to me to be the good old blog. On a personal note, since the days of Orkut, I haven’t truly engaged with social networks. The combination of a lack of time and a format that isn’t particularly interesting to me has pushed me away. I’ve always preferred the more passive approach of blogs, with longer and generally more consistent content. So much so, that even today, I still maintain my feeds. Some interesting platforms have emerged, of course, in the meantime, such as Medium, which has some very interesting articles. However, in recent years, I started to notice that there were interesting things I was developing, both in the workplace and in terms of personal projects, and I began to plan my return. In the interim, I’ve made a few scattered websites to organize some information that was interesting to me. If you notice, at the top, the link “research paper structure” leads to a page with instructions for writing an academic paper, and another with a collection of videos and animations compiling calisthenics exercises. In the context of this endeavor, I’d like a solution that could easily encompass these sites. I also tried to hack together something, most notably the Pandoc + Python’s Beautiful Soup implementation below, but it got too messy too quickly. My ideal workflow would be to write or edit content as I already do for my personal wiki, which currently consists of Markdown files in an Obsidian vault. Then, with a simple command, I’d have everything transformed into a static website, with an RSS feed updated accordingly, ready to host on services like GitHub Pages, Netlify, or Firebase. It’s imperative, therefore, that my blogging experience consists of having a structure of organized text files with up-to-date backups that can somehow be transformed into a blog. Being a programmer, I only feel comfortable working within a version control system like Git, for example. This is another reason for having as much as possible in a textual format. With that in mind, I set out to investigate what was available. Behemoths like WordPress and self-hosted Ghost were immediately ruled out, as I wanted something lightweight and simple. To sum up the requirements: Git! Markdown I remember when I started to dabble with HTML, back in the day, and my first thought was, “Who the hell came up with this bloated syntax?” Free, and preferably open-source Closest to a static website as possible A comment system, to get some insight and feedback Integrations with LinkedIn, Twitter, Facebook, Instagram, and possibly others like Medium Set and forget - given my tendency for tinkering, the more separation of concerns, the better Mailing list RSS I almost forgot about this one https://gohugo.io/’s claims of speed were alluring, but I found it too complex. In https://jekyllrb.com/’s case, the problem, I believe, was with Liquid, their templating engine, and the Ruby dependencies. I also explored https://getgrav.org/, https://www.11ty.dev/, https://docs.getpelican.com/en/latest/index.html#, and https://getnikola.com/, but was ultimately unsatisfied for one reason or another. So, I decided to build my own static site generator. My first attempt, ContentManager, was in Rust, and I was actually making slow but steady progress with it in my free time. Fast forward to around September 2024, when I grew tired of how much Python struggles with large codebases. I began to look for a statically typed and, ideally, compiled language in which I could be as productive as I am in Python. I decided to try Go and, after reading a few books and experimenting with a small project, I decided to port what I already had in Rust to Go. Within a couple of days, the Go version had already achieved feature parity with the barebones Rust implementation. A short three months later, I am proud to present the Dead Simple Blog Generator (DSBG), a static site generator written in Go. Dead Simple Blog Generator is here! A new static site generator that’s truly simple. Built with Go for speed & efficiency. Easy installation: Download a https://github.com/tesserato/dsbg/releases or use go install github.com/tesserato/dsbg@latest, Support for Markdown & HTML source files, Tag generation and filtering, Client-side fuzzy search, RSS feed generation, Watch mode with automatic re-rendering, 3 different themes, with the ability to add your own via custom CSS. Easy analytics, comments, and more. https://tesserato.github.io/dsbg/

An accessible explanation of Classifier-Free Guidance (CFG), the mechanism behind the "Guidance Scale" parameter found in almost all modern image generation models.

This post by Sander Dieleman (Google DeepMind) is the definitive explanation for one of the most persistent parameters in generative AI: the Guidance Scale. Dieleman explains the trade-off between sample diversity and fidelity, detailing how “Classifier-Free Guidance” (CFG) works by amplifying the difference between a conditional model (one with a text prompt) and an unconditional one. While newer techniques like “guidance distillation” are emerging in 2025, CFG remains the standard method used to force diffusion models to adhere to user prompts, making this post essential reading for understanding why your “CFG Scale” slider actually works.

How a Māori community in New Zealand is challenging "AI colonialism" by building their own language models and establishing strict data sovereignty to revitalize Te Reo.

Karen Hao reports on a groundbreaking initiative by Te Hiku Media in New Zealand, led by Peter-Lucas Jones and Keoni Mahelona. Fighting against the decline of the Māori language (te reo) and the extractive nature of Big Tech, the pair purchased their own hardware to train natural language processing models. The article frames this struggle as a defense against “data colonialism.” Mahelona notes that “Data is the last frontier of colonization.” Rather than allowing large corporations to harvest their language data and sell it back to them, Te Hiku established strict data sovereignty protocols based on kaitiakitanga (guardianship). They successfully crowdsourced thousands of hours of speech from the community to build accurate recognition tools, proving that advanced AI development isn’t the exclusive domain of Silicon Valley and can be an act of cultural preservation.

Research suggests fundamental theoretical limits to deep learning, drawing parallels to Gödel and Turing: just because a stable neural network exists mathematically, doesn't mean an algorithm can compute it.

This IEEE Spectrum article discusses a study published in https://www.pnas.org/doi/10.1073/pnas.2107151119 by researchers from the University of Cambridge and the University of Oslo. The authors identify a paradox at the heart of deep learning: while a stable and accurate neural network might mathematically exist for a given problem, there may be no algorithm capable of actually computing it with current digital tools. The researchers draw parallels to the work of Kurt Gödel and Alan Turing regarding the fundamental limits of mathematics and computation. They illustrate the problem with a “cake analogy”: a recipe for the perfect cake may exist, but if the physical tools (the mixer) are insufficient, the cake cannot be made—or worse, you might bake a completely different cake and not realize it until you taste it. Practically, this manifests as a trade-off between accuracy and stability. In safety-critical fields like medical imaging or autonomous driving, high accuracy is often achieved at the cost of stability, making systems vulnerable to adversarial attacks (where a single pixel change causes a misdiagnosis). The study suggests that rather than blind faith in deep learning, we need a classification theory to understand which neural networks are actually computable.

An analysis of why AGI might be harder to achieve than the hype suggests, focusing on the distinction between narrow AI and the human-like attributes required for General Intelligence.

Joshi argues that while we have mastered narrow AI—machines that outperform humans in specific tasks—the leap to General Intelligence involves replicating consciousness, empathy, and civilized thinking. These are barriers we are nowhere near crossing, suggesting that AGI might remain a “pipe dream” or at least a very distant reality, despite the current enthusiasm in the field.

Researchers at TU Berlin propose a "Folded-in-time" Deep Neural Network that simulates a complex multi-layer network using a single neuron and time-delayed feedback loops to tackle the energy inefficiency of modern AI.

This article details a fascinating approach by researchers at Technische Universität Berlin to address the skyrocketing energy costs of training massive neural networks like GPT-3. Instead of the traditional method of adding more neurons to a network (scaling in space), the team designed a “Folded-in-time Deep Neural Network” (Fit-DNN) that uses a single neuron. The concept relies on feedback-modulated delay loops. Rather than passing data through layers of physical nodes, the single neuron processes information sequentially, “weighting the same neuron differently over time.” The researchers compare it to “a single guest simulating the conversation at a large dinner table by switching seats rapidly and speaking each part.” By utilizing lasers to create these time-based loops, the system operates near the speed of light, theoretically allowing for a “limitless number” of neuronal connections without the massive hardware footprint.

A project utilizing generative AI models, Ithaca and Aeneas, to collaborate with historians in restoring, dating, and attributing ancient Greek and Latin inscriptions.

This site presents Ithaca and Aeneas, two generative AI models developed (often in collaboration with Google DeepMind) to assist historians. Unlike typical predictive text models that forecast the future of a sentence, these models “predict the past” by analyzing damaged ancient inscriptions. They help fill in missing characters (restoration), estimate the geographic origin (attribution), and determine the timeframe (dating) of texts that have been eroded by time. An https://www.nature.com/articles/s41586-022-04448-z, an https://github.com/google-deepmind/predictingthepast and a https://colab.research.google.com/github/google-deepmind/predictingthepast/blob/master/colabs/inference.ipynb are available.

An open, project-oriented book by Gil Mizrahi that teaches functional programming concepts by guiding the reader through the construction of a static blog generator in Haskell.

https://github.com/soupi/learn-haskell-blog-generator

A look at the "King" Cello, crafted by Andrea Amati around 1560 for King Charles IX of France, which remains playable today at the National Music Museum.

This Open Culture feature spotlights the “King” Cello, crafted by Andrea Amati in Cremona around 1560, which is widely recognized as the oldest cello in existence. Originally part of a set of 38 instruments commissioned for the court of King Charles IX of France—and still bearing the painted royal armorials in gold leaf—the instrument has survived wars and revolutions to reside at the National Music Museum in South Dakota. Despite being cut down in size during the early 19th century to modernize its playability, the “King” retains a rich, resonant tone, demonstrated in the article through a performance of Bach’s Cello Suite No. 1. https://www.youtube.com/watch?v=X8f367GIA0E

A guide to the digitized collections of Leonardo da Vinci's surviving notebooks, featuring links to the Codex Arundel at the British Library, the Codex Forster at the V&A, and the massive Codex Atlanticus.

This Open Culture guide aggregates the major digital repositories of Leonardo da Vinci’s notebooks, offering a rare glimpse into the mind of the Renaissance polymath. Widely dispersed after his death, these manuscripts—written in his famous “mirror script”—cover topics ranging from anatomy and botany to hydraulics and flight. The article provides direct access to high-resolution scans from institutions like the British Library (Codex Arundel), the Victoria and Albert Museum (Codex Forster), and the Biblioteca Ambrosiana (Codex Atlanticus), allowing users to explore his intricate sketches and ideas from the comfort of their screens. http://www.bl.uk/manuscripts/Viewer.aspx?ref=arundel_ms_263_f001r https://www.vam.ac.uk/articles/leonardo-da-vincis-notebooks& http://www.codex-atlanticus.it/

A profile of the 10th-century Persian polymath Ibn Sina, whose "Canon of Medicine" defined medical practice for centuries and whose philosophy bridged Aristotelian logic and Islamic theology.

This Open Culture feature explores the life and legacy of Ibn Sina (known in the West as Avicenna), the preeminent philosopher and physician of the Islamic Golden Age. It highlights his two most influential works: The Canon of Medicine, which served as the standard medical textbook in European universities until the mid-17th century, and The Book of Healing, a monumental scientific and philosophical encyclopedia. The article also details his famous “Floating Man” thought experiment—arguably a precursor to Descartes’ Cogito, ergo sum—which attempted to demonstrate the existence of the soul and self-awareness independent of sensory input.

A reflection on the trajectory of AI, drawing parallels to the invention of the combustion engine and the standardization of time, arguing for a century-long view on ethical development.

Written during the height of the COVID-19 pandemic, this piece by Angela Harvey (SAP) highlights how AI compressed vaccine development timelines from years to months. However, the core of the essay is a historical analogy provided by Genevieve Bell (Intel) regarding the combustion engine. The article notes that the engine didn’t just speed up travel; it eventually forced the standardization of time (GMT) to prevent trains from colliding. It suggests AI will similarly alter our fundamental understanding of reality. The critical warning, however, is that the engine also brought global warming—a consequence of short-term design. The piece argues for the necessity of “innovating 100 years into the future” and integrating “poets” with engineers to ensure AI addresses the right problems without creating existential debt.

An introduction to one of the few surviving pre-Columbian manuscripts, a deer-skin pictographic record of Mixtec history and the life of ruler Eight Deer Jaguar-Claw.

This Open Culture article highlights the Codex Zouche-Nuttall, a rare accordion-folded manuscript made of deer skin that serves as a vital record of Mixtec history. Although completed around 1556, scholars consider it to be of pre-Hispanic origin due to the total absence of European stylistic influence. The codex contains two narratives: the history of important Mixtec centers and the genealogy and military feats of the ruler Eight Deer Jaguar-Claw. Discovered in a Florentine monastery in 1854, this pictographic “storyboard”—which would have guided complex oral recitations—is now available digitally, offering a glimpse into the sophisticated literary traditions that persist alongside the resurgence of indigenous languages in modern Mexico. https://archive.org/details/gri_33125011146541/page/n71/mode/2up

A curated, ranked directory of the best free educational resources on the internet, created by the non-profit The School of Thought.

Created by The School of Thought—the non-profit behind https://yourfallacy.is—this project organizes and ranks the “best free edu-things on the internet.” Moving beyond simple aggregation, the list curates high-quality resources across categories like programming, languages, and critical thinking, featuring heavy hitters like Khan Academy, Crash Course, and Dan Carlin’s Hardcore History. The initiative aims to democratize access to world-class education by connecting learners directly with the most engaging free content available, bypassing traditional institutional barriers.

A spotlight on the San Francisco-based ensemble Voices of Music, featuring a playlist of Bach's works performed on period-accurate instruments to recreate the 18th-century soundscape.

This Open Culture feature highlights a curated playlist by Voices of Music, a San Francisco-based early music ensemble dedicated to performing on original period instruments. By utilizing baroque violins with gut strings, theorbos, and harpsichords, the ensemble aims to recreate the authentic soundscape of the 18th century. The collection of ten pieces—including the Brandenburg Concerto No. 2 and the Cello Suite No. 2—offers listeners a “musical time travel” experience, revealing the warmer, grittier, and more resonant textures that characterized Bach’s era, in contrast to the polished sound of modern orchestral instruments. https://www.youtube.com/channel/UC9qItJ2Gs8Xfu6y_ERKNsxw

An exploration of Richard Feynman's teaching legacy, focusing on his "notebook" learning technique and Bill Gates' admiration for his ability to make science accessible and fun.

This Open Culture article reflects on why Richard Feynman remains a beloved educator decades after his death, a sentiment echoed by Bill Gates who calls him “the best teacher I never had.” It highlights Feynman’s rigorous intellectual honesty—specifically his “notebook” technique of explaining concepts in simple terms to identify gaps in understanding—and his ability to convey the “pleasure of finding things out.” The piece suggests that his enduring fame stems not just from his theoretical work, but from his lifelong, engaging conversation with the public about the beauty of physical laws. https://www.feynmanlectures.caltech.edu/

An introduction to "The Sifter," a massive open-access database created by culinary historian Barbara Ketcham Wheaton that catalogs over 5,000 historical cookbooks to aid in the study of food history.

Reina Gattuso reports on the launch of The Sifter, a Wikipedia-style database compiling over 5,000 historical cookbooks from Europe and the U.S. spanning more than a thousand years. The project, the culmination of 50 years of work by culinary historian Barbara Ketcham Wheaton, allows users to search not just for titles but for specific ingredients, techniques, and authors, providing a powerful tool for analyzing long-term trends in dining habits, trade routes, and culinary culture. It represents a shift from viewing cookbooks merely as recipe collections to treating them as serious historical documents that reveal the “gendered economic and cultural capital” of their times. https://thesifter.org/

A comprehensive guide to the history, hardware, and protocol of MIDI, explaining why the 1982 standard remains essential for modern makers and microcontroller projects.

Tim Deagan’s guide introduces makers to the enduring utility of the Musical Instrument Digital Interface (MIDI). Originally released in 1982, MIDI remains a standard for digital music due to its simplicity and robustness, utilizing a unidirectional current loop and a specific 31,250 baud rate to transmit messages like NoteOn and ControlChange without complex handshakes. While the classic standard persists, the landscape is evolving: MIDI 2.0 (2020) introduces bidirectional communication and 32-bit resolution while maintaining backward compatibility, and https://ccrma.stanford.edu/groups/osc/index.html offers a high-resolution, network-based alternative using URI-style addressing and modern protocols (UDP/TCP) for complex multimedia applications.

Physicist Nicolas Gisin proposes that the "block universe" concept is based on the physical impossibility of infinite precision, suggesting "intuitionist mathematics" as a way to restore the reality of time's passage.

Natalie Wolchover profiles the work of Swiss physicist Nicolas Gisin, who challenges the Einsteinian “block universe” model where time is a stubborn illusion. Gisin argues that the deterministic view of physics relies on a mathematical fiction: “real numbers” with infinite strings of pre-existing digits, which implies infinite information in a finite volume. By applying “intuitionist mathematics”—a century-old framework where digits are constructed sequentially rather than existing simultaneously—Gisin suggests that the future is mathematically open. This approach treats time not as a dimension already laid out, but as a process where new information is genuinely created, offering a potential bridge between the determinism of General Relativity and the randomness of Quantum Mechanics.

A comprehensive digital anthology edited by David Widger, aggregating hundreds of Anton Chekhov's short stories from various Project Gutenberg volumes. This massive compilation features classic translations (primarily by Constance Garnett) and organizes the Russian master's works alphabetically, spanning his career from early humorous sketches to his profound later tales like "The Lady with the Dog" and "Ward No. 6".

I am at 189 / 2947 in Google Play books as of 2025 12 02. Decided to read Chekhov after praise from Ariano Suassuna. https://www.gutenberg.org/ebooks/57333 This https://standardebooks.org/ebooks/anton-chekhov/short-fiction/constance-garnett seems to be related…

A 2013 anthology edited by George R.R. Martin and Gardner Dozois featuring fifteen original stories set on a retro-futuristic Mars. The collection pays homage to the "Golden Age" planetary romances of Edgar Rice Burroughs and Leigh Brackett, featuring authors like Peter F. Hamilton, Michael Moorcock, and Joe R. Lansdale.

Started reading expecting something in the line of Ray Bradbury’s https://www.goodreads.com/book/show/76778.The_Martian_Chronicles. I remember being mildly disappointed at the time. Have it on Google Play Books, but apparently I read almost nothing of it as of 2025 12 02. https://georgerrmartin.com/grrm_book/old-mars/ https://www.penguinrandomhouse.com/books/220649/old-mars-by-edited-by-george-rr-martin-and-gardner-dozois/ https://www.audible.com/pd/Old-Mars-Audiobook/B00F3HGV0E