My first thought was also "why not SQLite?", but the author says he already has a MariaDB running. So, using the tools you know.

I guess it is the same for make vs airflow. I had no idea they could be used interchangeably for single machine workloads.

While I've seen datasette mentioned a lot of places, I still don't really know what it is, but if it makes exploring sqlite databases easy, I should give it a try!

The makefile data pipeline is definitely an underrated technique a couple great HN comments on this technique:

- https://news.ycombinator.com/item?id=22283368

- https://news.ycombinator.com/item?id=18896204

I personally learned it from bioinformaticians theres great coverage of this and other command line data skills in this book: https://www.oreilly.com/library/view/bioinformatics-data-ski...

The SQLite, pandas, bash, make stack for quick data science projects is a great and maintainable one that doesn’t require too much specialized knowledge.

Great read on Jupyter Notebooks. I've always had a strong dislike for them as well - just feel fuzzy, dirty, often in weird state - and the user put it into words nicely. I might just be bad with Jupyter, but I've been willing to mold these notebooks into saner forms (modularization, keeping state, deterministic cell order/content/execution) and came up empty.

At some point you got to ask if it's not the tool's fault. Modularization especially is infuriating -- it seems there is no reliable way to rerun `import myownmodule` when work is done on the latter. It won't detect changed code. A kernel restart is necessary (`reload` and friends didn't help), losing all state. It's punishment for saner software engineering practices.

You are absolutely right I have taken to referring to that as “notebook code.”

I love jupyter because its a great interactive programming environment that speeds up building scripts. But jupyter notebooks always end up being…notebooks. They are records of past work and thoughts that I had but I wouldn't present my paper notes to a coworker as finished documentation. I always end up extracting those jupyter snippets into runnable scripts and then I end up doing a lot of the work all over again as I parameterize things.

I have taken to using pycharm scientific mode and adding “cells” into my scripts: https://blog.jetbrains.com/pycharm/2018/04/pycharm-scientifi...

You get the interactivity of jupyter with the cells, the scientific view for plots and data, but you’re also writing a real script so you can still maintain some sanity in your code and good git history (and hopefully add some tests).

Then I combine these scripts together into a makefile and voila quick, easy and maintainable scripts. If you just stick to make, python, pandas and bash any programmer can modify your pipeline without needing specialist skills. I have written scrapers + ETL in <1.5 hour (journalist needed some data quick) with this method.

God I wish I still worked in data science I’m currently a front end dev and don’t get to do any of this at work. It’s such fun and offers so much room for creativity and problem solving.

I think notebooks are great for building a presentation / reports of a data exploration, but I agree that they shouldn't represent programs.

Rstudio won't export an R-markdown notebook to PDF without rerunning all cells sequentially. It's great for keeping the code "in check", but for things that takes hours to run, it can be quite annoying.

I do think most of the problems with notebooks go away if you somehow force sequential running before presenting it to other people.

Another really cool take on notebooks are Julia's Pluto Notebooks. Like a spreadsheet, there is no sequence that cells are run in. Everything is updated simultaneously. It's kinda hard to explain, but the JuliacCn presentation on these is absolutely wonderful: https://www.youtube.com/watch?v=IAF8DjrQSSk

makefiles in general are something that I quite frankly never figured people use with anything (forgive me for saying it) but "old-school C"... but I started using them earlier this year (the linked article is from Feb) after finding a makefile in a Python GitHub repo. I've since created one for most of my Python and go repositories and they've been a great tool. It has, however, not occurred to me to use them in place of actual pipelines (as the linked comments suggest), so I'll definitely try this soon, thanks!

That being said, a lot of what I do on my blog is stuff I don't get to do at work - Airflow being one of those things that has been "abstracted away from me" for too long...

I use SQLite quite a bit and I think it's fantastic, especially since Hipp seems to be a wonderful guy (judging by The Changelog podcast).

And you're right - use the tools you know and have running. I have all sorts of schemas and tables on that old instance, since I tend to use it if I need "anything SQL" - when I'm at home, is it as easy as using SQLite. My latest article used Trino and Hadoop-adjacent stuff... while fascinating it its own right, sometimes it's nice to just say "jdcb:// ..." :)