10 ms·

Atuin Desktop: Runbooks That Run

572 points by freetonik 1y ago

gyrovagueGeist 1y ago
All the problems of reproducibility in Python notebooks (https://arxiv.org/abs/2308.07333 https://arxiv.org/abs/2308.07333, https://leomurta.github.io/papers/pimentel2019a.pdf https://leomurta.github.io/papers/pimentel2019a.pdf) with the power of a terminal.
- milkshakes 1y ago
  what are the problems you're talking about? your references seem to refer to reproducing scientific publications, dependency issues, and cell execution ordering. this project appears to be intended for operational documentation / living runbooks. it doesn't really seem like the same use case.
  - shadowgovt 1y ago
    Agreed. The problem with reproducing Jupyter runbooks in academia is that someone thought a Jupyter runbook is a way to convey information from one person to another. Those are an awful model for that. As an on-the-fly debugging tool, they're great: you get a REPL that isn't actively painful to use, a history (roughly, since the state is live and every cell is not run every time) of commands run, and visualization at key points in the program to check as you go your assumptions are sound.
  - rtpg 1y ago
    I mean it feels pretty obvious to me that cell execution order is a pretty real issue for a runbook with a bunch of steps if you're not careful. I do think that given the fragile nature of shell scripts people tend to write their operation workflows in a pretty idempotent way, though...
    - ellieh 1y ago
      agreed - we actually have a dependency system in the works too! you can define + declare ordering with dependency specification on the edges of the graph (ie A must run before B, but B can run as often as you'd like within 10 mins of A)
      - nine_k 1y ago
        There of course should be a way to override the dependency, by explicitly pressing a big scary "[I know what I'm doing]" button. Another thing is that you'll need branches. As in: - Run `foo bar baz` - If it succeeds, run `foo quux`, Else run `rm -rf ./foo/bar` and rerun the previous command with `--force` option. - `ls ./foo/bar/buur` and make certain it exists. Different branches can be separated visually; one can be collapsed if another is taken. Writing robust runbooks is not that easy. But I love the idea of mixing the explanatory text and various types of commands together.
    - deleted 1y ago
      [deleted]
    - noodletheworld 1y ago
      I mean, is it worse than having it: - in excel - in a confluence document - in a text file on your desktop The use case this addresses is 'adhoc activites must be performed without being totally chaotic'. Obviously a nice one-click/trigger based CI/CD deployment pipeline is lovely, but uh, this is the real world. There are plenty of cases where that's simply either not possible, or not worth the effort to setup. I think this is great; if I have one suggestion it would just be integrated logging so there's an immutable shared record of what was actually done as well. I would love to be able to see that Bob started the 'recover user profile because db sync error' runbook but didn't finish running it, and exactly when that happened. If you think it's a terrible idea, then uh, what's your suggestion? I'm pretty tired of copy-pasting commands from confluence. I think that's, I dunno, unambiguously terrible, and depressingly common. One time scripts that are executed in a privileged remote container also works, but at the end of that day, those script tend to be specific and have to be invoked with custom arguments, which, guess what, usually turn up as a sequence of operations in a runbook; query db for user id (copy-paste SQL) -> run script with id (copy paste to terminal) -> query db to check it worked (copy paste SQL) -> trigger notification workflow with user id if it did (login to X and click on button Y), etc.
      - rtpg 1y ago
        I'm not against this notebook style, I have runbooks in Jupyter notebooks. I just think it's pretty easy to do things like start a flow back up halfway through the book and not fix some underlying ordering issues. With scripts that you tend to have to run top to bottom you end up having to be more diligent with making sure the initial steps are still OK because on every test you tend to run everything. Notebook style environments favor running things piecemeal. Also very helpful! It introduces a much smaller problem in the process of solving the larger issue of making it easier to do this kind of work in the first place.
- packetlost 1y ago
  This is more like literate programming (but for shells) than jupyter notebooks.
  - mananaysiempre 1y ago
    Literate programming really needs the ability to reorder, otherwise it’s just sparkling notebooks. (Except for Haskell, which is order-independent enough as it is that the distinction rarely matters.)
- theLiminator 1y ago
  Give marimo a try, it's much better for reproducibility.
  - mdaniel 1y ago
    linky https://github.com/marimo-team/marimo#:~:text=all%20in%20a%20modern%2C%20ai-native%20editor https://github.com/marimo-team/marimo#:~:text=all%20in%20a%2... (Apache 2)
    - ugiox 1y ago
      From their repo: “A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. *All in a modern, AI-native editor.* Why does it need to be in a “modern, AI-native editor”? (Closing tab, flashing marimo out of brain)
- dang 1y ago
  "Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something." https://news.ycombinator.com/newsguidelines.html https://news.ycombinator.com/newsguidelines.html
freedomben 1y ago
Will this be open source like Atuin CLI and the sync server are? Is this going to be productized?
- gniting 1y ago
  Most likely not free. Regardless, happy to see this be announced!
- iamwil 1y ago
  Are you worried about getting rug pulled by the platform?
  - deleted 1y ago
    [deleted]
  - freedomben 1y ago
    Yes, enshittification potential is top of mind for me now when considering adopting any product. If it's open source then I worry less.
- jamietanna 1y ago
  It'll be Open Source'd: https://news.ycombinator.com/item?id=43766200#43766584 https://news.ycombinator.com/item?id=43766200#43766584
  - brunoqc 1y ago
    Probably not the server though.
dheerkt 1y ago
How is this different from a local Jupyter notebook? Can we not do this with ! or % in a .ipynb? Genuine question. Not familiar with this company or the CLI product.
- RestartKernel 1y ago
  Jupyter Notebooks have always felt a bit hacky for terminal purposes to me, so I'm excited to give this a shot.
  - BOOSTERHIDROGEN 1y ago
    How about marimo?
- hashstring 1y ago
  100% same question. Usually, I feel like Jupyter gives both worlds—- flexible scripting and support for os commands (either through !/% or even os.system()
- berkes 1y ago
  The main thing that keeps me from using Jupyter notebooks for anything that's not entirely Python, is Python. For me, pipenv/pyenv/conda/poetry/uv/dependencies.txt and the invitable "I need to upgrade Python to run this notebook, ugh, well, ok -- two weeks later - g####m that upgrade broke that unrelated and old ansible and now I cannot fix these fifteen barely held up servers" is pure hell. I try to stay away from Python for foundational stuff, as any Python project that I work on¹ will break at least yearly on some dependency or other runtime woe. That goes for Ansible, Build Pipelines, deploy.py or any such thing. I would certainly not use Jupyter notebooks for such crucial and foundational automation, as the giant tree of dependencies and requirements it comes with, makes this far worse. ¹ Granted, my job makes me work on an excessive amount of codebases, At least six different Python projects last two months, some requiring python 2.7, some requiring deprecated versions of lib-something.h some cutting edge, some very strict in practice but not documented (It works on the machine of the one dev that works on it as long as he never updates anything?). And Puppet or Chef - being Ruby, are just as bad, suffering from the exact same issues, only that Ruby has had one (and only one!) package management system for decades now.
stevelacy 1y ago
Have been following along with the development, glad to see it announced!
nu11ptr 1y ago
Looks neat. What tech stack is used for this? Is it open source by chance?
- deleted 1y ago
  [deleted]
- iamwil 1y ago
  Do you want it to be open source because of the price or because you’re afraid of being rug pulled by the platform or you want to contribute?
  - nu11ptr 1y ago
    If I use something I like the idea that I can fix bugs should the need arise.
- ellieh 1y ago
  Thanks! We're using Tauri (https://v2.tauri.app/ https://v2.tauri.app/) on the client, and Elixir + Phoenix (with a little bit of Rust via Rustler) on the server Tauri means we can reuse a lot of the Rust we already have, easily do the systems stuff we need, and have something light + fast. Elixir has been awesome and makes a realtime sync backend easier Not currently open source while it's under heavy early development, we will be opening up the desktop app later on
  - tymscar 1y ago
    Amazing. Im very happy this is not yet another electron app
    - benatkin 1y ago
      This is one place where it would be more likely to make sense to have an electron app, because with user code, you'd already have a lot of variables out of your control, and having a standard browser engine would help. Also unlike other apps, you hopefully wouldn't have 5 code notebook apps running.
moonlion_eth 1y ago
the waitlist social media jump the list mechanic is kinda sus, regardless joined the waitlist
0xbadcafebee 1y ago
If it's local-first then it's already subject to rot. Unless they're running it all in containers? In which case local doesn't matter. If you want to record a runbook, then record a runbook. You can do that a million ways. Text file, confluence doc, screen recording, shell script, etc. People already don't do that; they're not gonna suddenly start doing it more because your UI is fancier. Personally, I don't want to sit around all day writing code (or docs) to try to get the system to be like X state. I want to manually make it have X state, and then run a tool to dump the state, and later re-run the tool to create (or enforce) that state again. I do not want to write code to try to tell the computer how to get to that state. Nor do I want to write "declarative configuration", which is just more code with a different name. I want to do the thing manually, then snapshot it, then replay it. And I want this to work on any system, anywhere, without dependence on monitoring a Bash shell for commands or something. Just dump state and later reapply state.
- milkshakes 1y ago
  what happens when you want to tweak something you did in the middle of this process? do you have to go through the whole flow again manually to make a single change?
  - 0xbadcafebee 1y ago
    I imagine you could either A) just modify the dumped state, B) paramaterize it, C) have the program split up the state into transactions and modify those. The program will probably have to take more than one step, in order, in order to accomplish everything. If it fails, you'd want it to try to undo it, ala transactions. And since it can do all that, it can stop, start, or resume at specific steps. Like, Terraform has always sucked because there was no way to dump existing resources as new code. So a team at Google made a tool to do it (Terraform-er). If Terraform had already had that feature, and if it didn't rely on having pre-existing state to manage resources, that would be like 90% of the way to what I'd want. Just dump resources as code, then let me re-run the code, and if I want I can modify the code to ask me for inputs or change things. (People think of Terraform as only working on Cloud resources, but you could (for example) make an Ubuntu Linux provider that just configures Ubuntu for you, if you wanted)
account-5 1y ago
I can't say I see the point in this. Can someone explain what I'm missing? Why would I use this over a simple shell script?
- rc00 1y ago
  Because it's written in Rust and this is Hacker News.
  - account-5 1y ago
    I was going to talk about using powershell but just for the rust I also really like Nushell. I personally would take either one over this...
- joh6nn 1y ago
  My experience with runbooks has been: - I am on a team that oversees a bunch of stuff, some of which I am very hands-on with and comfortable with, and some of which I am vaguely aware exists, but rarely touch - X, a member of the latter category, breaks - Everyone who actually knows about X is on vacation/dead/in a meeting - Fortunately, there is a document that explains what to do in this situation - It is somehow both obsolete and wrong, a true miracle of bad info So that is the problem this is trying to solve. Having discussed this with the creator some[1], the intent here (as I understand it) is to build something like a cross between Jupyter Notebooks and Ansible Tower: documentation, scripts, and metrics that all live next to each other in a way that makes it easier to know what's wrong, how to fix it, and if the fix worked [1]Disclosure: I help mod the atuin Discord
  - mmooss 1y ago
    > It is somehow both obsolete and wrong, a true miracle of bad info How does Atuin solve that problem? It seems to me that inaccurate and obsolete information can be in an Atuin document as easily as in a text document, wiki, etc., but possibly I'm not seeing something?
    - 1y ago
elAhmo 1y ago
Looks interesting! We recently started using https://marimo.io/ https://marimo.io/ as a replacement for Jupyter notebooks, as it has a number of great improvements, and this seems like a movement in a similar direction.
floathub 1y ago
For anyone emacs-curious, you can do a similar thing with org-babel You can have a plaintext file which is also the program which is also the documentation/notebook/website/etc. It's extremely powerful, and is a compelling example of literate programming. A good take on it here: https://osem.seagl.org/conferences/seagl2019/program/proposals/664 https://osem.seagl.org/conferences/seagl2019/program/proposa...
- kstrauser 1y ago
  Similar with BBEdit's Shell Worksheets, which mingle prose with commands you can run with a keypress.
  - ymarketing 1y ago
    [dead]
- spudlyo 1y ago
  Thanks for the shout-out! I think org-babel is really well suited for this task, and can make some really great documentation. You can check out the video[0] from the talk and a git repo[1] with a more advanced demonstration. [0]: https://www.youtube.com/watch?v=0g9BcZvQbXU https://www.youtube.com/watch?v=0g9BcZvQbXU [1]: https://gitlab.com/spudlyo/orgdemo2 https://gitlab.com/spudlyo/orgdemo2
  - floathub 1y ago
    Thanks for making the presentation. I found it very useful when I first started messing around with babel, and I still come back to it from time to time.
- zelphirkalt 1y ago
  Actually, in terms of capabilities, org-babel is among the most capable, if it is not the most capable, systems for literate programming. I have used it to great effect when learning from computer programming books. I can now go back to those literate programs, and understand again much faster, than originally when reading the books. The literate part of it answers my "silly" questions, that come from not remembering 100% of the reasoning or my own thoughts. That said, there is of course a learning curve, and people unwilling to learn something like that are better off not going that route.
InvisGhost 1y ago
This sort of slogan says nothing about what actually makes it worth looking into.
- rc00 1y ago
  What more do you need than "written in Rust"?
pm90 1y ago
My dream tooling is for every tool to have an terminal interface so that I can create comprehensive megabooks to get all the context that lives in my head. i.e. jira, datadog, github etc, all in one pane.
- buremba 1y ago
  You might like MCP then.
  - x-complexity 1y ago
    > You might like MCP then. That's entirely different to what's being desired by GP. > > My dream tooling is for every tool to have an terminal interface so that I can create comprehensive megabooks to get all the context that lives in my head. i.e. jira, datadog, github etc, all in one pane. My perspective on this is essentially having jira/datadog/github/etc be pluggable into the CLI, and where standard bash commands & pipes can be used without major restrictions. (Something akin to Yahoo Pipes) MCP is highly centered around LLMs analyzing user requests & creating queries to be run on MCP servers. What's being desired here doesn't centralize around LLMs in any sense at all.
    - janwandersun 1y ago
      [dead]
    - omneity 1y ago
      It’s actually not too far off. Yes MCP is designed for LLM interactions, but we observed that it’s an invocation API that’s pretty generic. So we built a package format that encapsulates computations and makes them accessible from any of MCP, REST, JSON-RPC over WS (the generic cousin of MCP).. We build logic once and make it automatically accessible from any of these consumption methods, in a standardized way to our clients, and I am indeed piping some of these directly in the CLI to jq and others for analysis.
- turtlebits 1y ago
  Not sure what you mean- github and datadog already have official CLI tools.
huntaub 1y ago
This is exactly what I wanted for our team when I was at AWS. There are so many versions of operations which are just slightly too dangerous to automate, and this provides a path to iteratively building that up. Congratulations!
- simsla 1y ago
  When I was at Amazon (pre covid), Eider could've been used for that. (Hosted notebooks with IAM integration.)
- rochak 1y ago
  Preface: My opinions are my own and not my employer’s. Curious how long ago were you at AWS? For context, I spent the last few years in AWS working on an internal platform service whose entire purpose was to reduce operational toil by helping you codify your operational runbooks and execute them safely and automatically. Atuin Desktop is similar to that service in some sense but that service just offered much more features.
  - perpil 1y ago
    Not OP but was there 15 years (left Dec 2021) and surprised I wasn't aware of this. I was only aware of a few tools that acted like chatbots to automatically gather context or take action from chime/tt/alarms.
- perpil 1y ago
  When I was at AWS, I built something so I could run things straight from the wiki. Think cloudwatch queries, aws cli commands etc with user inputs but without all the setup of securely getting the right credentials and formatting inputs. I've rebuilt to run stuff straight from GitHub. Here's it invoking a lambda function straight from a github wiki with user input in 4 lines of code: https://speedrun.nobackspacecrew.com/index.html#invoking-an-aws-lambda-function https://speedrun.nobackspacecrew.com/index.html#invoking-an-...
scubbo 1y ago
I'm really confused by products like this and Warp Drive[0]. What does this add over a shell script? There is a response elsewhere in comments[1] which claims that this is trying to fix the problem of bad documentation, but this has the same fundamental problem. If you a) are responsible for fixing something, b) are unfamiliar with it, and c) the "fixing resources" - whether those are scripts, documentation, or a Runbook/Workflow - you were provided with by the experts are out-of-date; you're SOL and are going to have to get to investigating _anyway_. A runbook and a script are just different points along the spectrum of "how much of this is automated and how much do I have to copy-paste myself?"[2] - both are vulnerable to accuracy-rot. [0]: https://www.warp.dev/warp-drive https://www.warp.dev/warp-drive [1]: https://news.ycombinator.com/item?id=43766842 https://news.ycombinator.com/item?id=43766842 [2]: https://blog.danslimmon.com/2019/07/15/do-nothing-scripting-the-key-to-gradual-automation/ https://blog.danslimmon.com/2019/07/15/do-nothing-scripting-...
- brunoqc 1y ago
  > I'm really confused by products like this and Warp Drive[0]. What does this add over a shell script? Because everything is a start-up now.
axegon_ 1y ago
Oh, that's really neat! Thanks for sharing!
OhSoHumble 1y ago
This makes me think of using org mode to build runbooks.
celera 1y ago
This looks super similar to https://runme.dev https://runme.dev
- nathabonfim59 1y ago
  This is amazing! Exactly what I was looking for, thanks!
- sourishkrout 1y ago
  Thanks for the shout-out. Co-creator of Runme here . Love runnable documentation. We don't have enough of it.
  - mkl 1y ago
    I didn't find the hero video on https://runme.dev/ https://runme.dev/ very helpful. I think it would be much easier to understand what Runme is for if you replaced the video with the "Make Markdowns Interactive" demos.
    - sourishkrout 1y ago
      Will look into it. The feedback is much appreciated. Thank you!
  - binaryblitz 1y ago
    Your playground says the login is "Only used for verification against abuse." Immediately after signing in, I get an email from you. Serious uncool and an instant "nope" from me after that.
baggiponte 1y ago
This looks so dope!
nsonha 1y ago
Kinda related but just the other day I was thinking of the notebook/runbook workflow and wonder if there is a tool like this that also incorporates git checkpoints (either commit or stash) into it. Like top to bottom, associate all the blocks and resulting artifacts with a commit hash. Might be something to vibe code over the weekend.
kamatour 1y ago
[dead]
amirathi 1y ago
I took a stab at this ~7 years ago - https://nurtch.com/ https://nurtch.com/ The idea has a lot of merit. We even gave a talk about it in JupyterCon Paris 2023 - https://www.youtube.com/watch?v=TUYY2kHrTzs https://www.youtube.com/watch?v=TUYY2kHrTzs When you have executable code in the documentation, folks want to follow PR-review workflow with the docs as well - which is a bit more team investment than editing a wiki. Good luck!
- wodenokoto 1y ago
  My first thought was also "why not jupyter"? Nice to see someone else had the same thought!
davidelettieri 1y ago
Our team used polyglot notebooks https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.dotnet-interactive-vscode https://marketplace.visualstudio.com/items?itemName=ms-dotne... Using C# as main language this allowed us to have runbooks using code shared as nuget package and so being able to interact with our own APIs and applications as any other code that runs in production. Not the best experience to review but it worked for us.
sudomateo 1y ago
Congratulations on the launch! I've been following Atuin for a bit and, while I'm not necessarily the intended audience for this runbook feature, love seeing people build fun new things.
nikolay 1y ago
It's kind of sad the direction they took. The last thing I want is my runbooks being held hostage by my desktop with proprietary and possibly paid software.
- SomaticPirate 1y ago
  What do you mean? This looks like open-source
  - nikolay 1y ago
    Only the app, not the server and by all indications it won't be free.
kunley 1y ago
Cool name, a reference to well known books
ChrisMarshallNY 1y ago
+1 for the Sir Terry reference!
gitroom 1y ago
i think lots of tools try to solve the same mess and i always end up just wanting my stuff all in one place with less hassle, so seeing more takes on this is cool
exiguus 1y ago
Is it opensource?
oscribinn 1y ago
pretty sure obsidian already has an extension for this
sleepybrett 1y ago
This reminds me of xiki which seems to have kind of died on the vine.
fitsumbelay 1y ago
This post reminded me how much I enjoy doodling with notebooks and UIs like observable and hacks like this -- https://gist.github.com/kahole/651990b888c19b84d5700422daa961de https://gist.github.com/kahole/651990b888c19b84d5700422daa96.... In a really roundabout way, notebooks take me back to using crouton on my Chromebook and opening a terminal in a browser tab. Also just discovered Deno's Jupyter kernel and feel rather set for good times ...
nopelynopington 1y ago
I presume the name Atuin comes from the great world turtle in Terry Pratchett's Discworld books?
perrygeo 1y ago
The poor man's version of this - write your runbooks as text files in your source code. And set your editor to "Send to Terminal". I use vim-slime in nvim, vscode has similar functionality. Document it, version control it, share it, and (semi)automate it. There's no reason to type or copy-paste important commands directly into the terminal.

572 points by freetonik 1y ago

All the problems of reproducibility in Python notebooks (https://arxiv.org/abs/2308.07333 https://arxiv.org/abs/2308.07333, https://leomurta.github.io/papers/pimentel2019a.pdf https://leomurta.github.io/papers/pimentel2019a.pdf) with the power of a terminal.

milkshakes 1y ago
what are the problems you're talking about? your references seem to refer to reproducing scientific publications, dependency issues, and cell execution ordering. this project appears to be intended for operational documentation / living runbooks. it doesn't really seem like the same use case.
- shadowgovt 1y ago
  Agreed. The problem with reproducing Jupyter runbooks in academia is that someone thought a Jupyter runbook is a way to convey information from one person to another. Those are an awful model for that. As an on-the-fly debugging tool, they're great: you get a REPL that isn't actively painful to use, a history (roughly, since the state is live and every cell is not run every time) of commands run, and visualization at key points in the program to check as you go your assumptions are sound.
- rtpg 1y ago
  I mean it feels pretty obvious to me that cell execution order is a pretty real issue for a runbook with a bunch of steps if you're not careful. I do think that given the fragile nature of shell scripts people tend to write their operation workflows in a pretty idempotent way, though...
  - ellieh 1y ago
    agreed - we actually have a dependency system in the works too! you can define + declare ordering with dependency specification on the edges of the graph (ie A must run before B, but B can run as often as you'd like within 10 mins of A)
    - nine_k 1y ago
      There of course should be a way to override the dependency, by explicitly pressing a big scary "[I know what I'm doing]" button. Another thing is that you'll need branches. As in: - Run `foo bar baz` - If it succeeds, run `foo quux`, Else run `rm -rf ./foo/bar` and rerun the previous command with `--force` option. - `ls ./foo/bar/buur` and make certain it exists. Different branches can be separated visually; one can be collapsed if another is taken. Writing robust runbooks is not that easy. But I love the idea of mixing the explanatory text and various types of commands together.
  - deleted 1y ago
    [deleted]
  - noodletheworld 1y ago
    I mean, is it worse than having it: - in excel - in a confluence document - in a text file on your desktop The use case this addresses is 'adhoc activites must be performed without being totally chaotic'. Obviously a nice one-click/trigger based CI/CD deployment pipeline is lovely, but uh, this is the real world. There are plenty of cases where that's simply either not possible, or not worth the effort to setup. I think this is great; if I have one suggestion it would just be integrated logging so there's an immutable shared record of what was actually done as well. I would love to be able to see that Bob started the 'recover user profile because db sync error' runbook but didn't finish running it, and exactly when that happened. If you think it's a terrible idea, then uh, what's your suggestion? I'm pretty tired of copy-pasting commands from confluence. I think that's, I dunno, unambiguously terrible, and depressingly common. One time scripts that are executed in a privileged remote container also works, but at the end of that day, those script tend to be specific and have to be invoked with custom arguments, which, guess what, usually turn up as a sequence of operations in a runbook; query db for user id (copy-paste SQL) -> run script with id (copy paste to terminal) -> query db to check it worked (copy paste SQL) -> trigger notification workflow with user id if it did (login to X and click on button Y), etc.
    - rtpg 1y ago
      I'm not against this notebook style, I have runbooks in Jupyter notebooks. I just think it's pretty easy to do things like start a flow back up halfway through the book and not fix some underlying ordering issues. With scripts that you tend to have to run top to bottom you end up having to be more diligent with making sure the initial steps are still OK because on every test you tend to run everything. Notebook style environments favor running things piecemeal. Also very helpful! It introduces a much smaller problem in the process of solving the larger issue of making it easier to do this kind of work in the first place.
packetlost 1y ago
This is more like literate programming (but for shells) than jupyter notebooks.
- mananaysiempre 1y ago
  Literate programming really needs the ability to reorder, otherwise it’s just sparkling notebooks. (Except for Haskell, which is order-independent enough as it is that the distinction rarely matters.)
theLiminator 1y ago
Give marimo a try, it's much better for reproducibility.
- mdaniel 1y ago
  linky https://github.com/marimo-team/marimo#:~:text=all%20in%20a%20modern%2C%20ai-native%20editor https://github.com/marimo-team/marimo#:~:text=all%20in%20a%2... (Apache 2)
  - ugiox 1y ago
    From their repo: “A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. *All in a modern, AI-native editor.* Why does it need to be in a “modern, AI-native editor”? (Closing tab, flashing marimo out of brain)
dang 1y ago
"Please don't post shallow dismissals, especially of other people's work. A good critical comment teaches us something." https://news.ycombinator.com/newsguidelines.html https://news.ycombinator.com/newsguidelines.html

freedomben 1y ago

Will this be open source like Atuin CLI and the sync server are? Is this going to be productized?

gniting 1y ago
Most likely not free. Regardless, happy to see this be announced!
iamwil 1y ago
Are you worried about getting rug pulled by the platform?
- deleted 1y ago
  [deleted]
- freedomben 1y ago
  Yes, enshittification potential is top of mind for me now when considering adopting any product. If it's open source then I worry less.
jamietanna 1y ago
It'll be Open Source'd: https://news.ycombinator.com/item?id=43766200#43766584 https://news.ycombinator.com/item?id=43766200#43766584
- brunoqc 1y ago
  Probably not the server though.

dheerkt 1y ago

How is this different from a local Jupyter notebook? Can we not do this with ! or % in a .ipynb? Genuine question. Not familiar with this company or the CLI product.

RestartKernel 1y ago
Jupyter Notebooks have always felt a bit hacky for terminal purposes to me, so I'm excited to give this a shot.
- BOOSTERHIDROGEN 1y ago
  How about marimo?
hashstring 1y ago
100% same question. Usually, I feel like Jupyter gives both worlds—- flexible scripting and support for os commands (either through !/% or even os.system()
berkes 1y ago
The main thing that keeps me from using Jupyter notebooks for anything that's not entirely Python, is Python. For me, pipenv/pyenv/conda/poetry/uv/dependencies.txt and the invitable "I need to upgrade Python to run this notebook, ugh, well, ok -- two weeks later - g####m that upgrade broke that unrelated and old ansible and now I cannot fix these fifteen barely held up servers" is pure hell. I try to stay away from Python for foundational stuff, as any Python project that I work on¹ will break at least yearly on some dependency or other runtime woe. That goes for Ansible, Build Pipelines, deploy.py or any such thing. I would certainly not use Jupyter notebooks for such crucial and foundational automation, as the giant tree of dependencies and requirements it comes with, makes this far worse. ¹ Granted, my job makes me work on an excessive amount of codebases, At least six different Python projects last two months, some requiring python 2.7, some requiring deprecated versions of lib-something.h some cutting edge, some very strict in practice but not documented (It works on the machine of the one dev that works on it as long as he never updates anything?). And Puppet or Chef - being Ruby, are just as bad, suffering from the exact same issues, only that Ruby has had one (and only one!) package management system for decades now.

stevelacy 1y ago

Have been following along with the development, glad to see it announced!

nu11ptr 1y ago

Looks neat. What tech stack is used for this? Is it open source by chance?

deleted 1y ago
[deleted]
iamwil 1y ago
Do you want it to be open source because of the price or because you’re afraid of being rug pulled by the platform or you want to contribute?
- nu11ptr 1y ago
  If I use something I like the idea that I can fix bugs should the need arise.
ellieh 1y ago
Thanks! We're using Tauri (https://v2.tauri.app/ https://v2.tauri.app/) on the client, and Elixir + Phoenix (with a little bit of Rust via Rustler) on the server Tauri means we can reuse a lot of the Rust we already have, easily do the systems stuff we need, and have something light + fast. Elixir has been awesome and makes a realtime sync backend easier Not currently open source while it's under heavy early development, we will be opening up the desktop app later on
- tymscar 1y ago
  Amazing. Im very happy this is not yet another electron app
  - benatkin 1y ago
    This is one place where it would be more likely to make sense to have an electron app, because with user code, you'd already have a lot of variables out of your control, and having a standard browser engine would help. Also unlike other apps, you hopefully wouldn't have 5 code notebook apps running.

moonlion_eth 1y ago

the waitlist social media jump the list mechanic is kinda sus, regardless joined the waitlist

0xbadcafebee 1y ago

If it's local-first then it's already subject to rot. Unless they're running it all in containers? In which case local doesn't matter. If you want to record a runbook, then record a runbook. You can do that a million ways. Text file, confluence doc, screen recording, shell script, etc. People already don't do that; they're not gonna suddenly start doing it more because your UI is fancier. Personally, I don't want to sit around all day writing code (or docs) to try to get the system to be like X state. I want to manually make it have X state, and then run a tool to dump the state, and later re-run the tool to create (or enforce) that state again. I do not want to write code to try to tell the computer how to get to that state. Nor do I want to write "declarative configuration", which is just more code with a different name. I want to do the thing manually, then snapshot it, then replay it. And I want this to work on any system, anywhere, without dependence on monitoring a Bash shell for commands or something. Just dump state and later reapply state.

milkshakes 1y ago
what happens when you want to tweak something you did in the middle of this process? do you have to go through the whole flow again manually to make a single change?
- 0xbadcafebee 1y ago
  I imagine you could either A) just modify the dumped state, B) paramaterize it, C) have the program split up the state into transactions and modify those. The program will probably have to take more than one step, in order, in order to accomplish everything. If it fails, you'd want it to try to undo it, ala transactions. And since it can do all that, it can stop, start, or resume at specific steps. Like, Terraform has always sucked because there was no way to dump existing resources as new code. So a team at Google made a tool to do it (Terraform-er). If Terraform had already had that feature, and if it didn't rely on having pre-existing state to manage resources, that would be like 90% of the way to what I'd want. Just dump resources as code, then let me re-run the code, and if I want I can modify the code to ask me for inputs or change things. (People think of Terraform as only working on Cloud resources, but you could (for example) make an Ubuntu Linux provider that just configures Ubuntu for you, if you wanted)

account-5 1y ago

I can't say I see the point in this. Can someone explain what I'm missing? Why would I use this over a simple shell script?

rc00 1y ago
Because it's written in Rust and this is Hacker News.
- account-5 1y ago
  I was going to talk about using powershell but just for the rust I also really like Nushell. I personally would take either one over this...
joh6nn 1y ago
My experience with runbooks has been: - I am on a team that oversees a bunch of stuff, some of which I am very hands-on with and comfortable with, and some of which I am vaguely aware exists, but rarely touch - X, a member of the latter category, breaks - Everyone who actually knows about X is on vacation/dead/in a meeting - Fortunately, there is a document that explains what to do in this situation - It is somehow both obsolete and wrong, a true miracle of bad info So that is the problem this is trying to solve. Having discussed this with the creator some[1], the intent here (as I understand it) is to build something like a cross between Jupyter Notebooks and Ansible Tower: documentation, scripts, and metrics that all live next to each other in a way that makes it easier to know what's wrong, how to fix it, and if the fix worked [1]Disclosure: I help mod the atuin Discord
- mmooss 1y ago
  > It is somehow both obsolete and wrong, a true miracle of bad info How does Atuin solve that problem? It seems to me that inaccurate and obsolete information can be in an Atuin document as easily as in a text document, wiki, etc., but possibly I'm not seeing something?
  - 1y ago

elAhmo 1y ago

Looks interesting! We recently started using https://marimo.io/ https://marimo.io/ as a replacement for Jupyter notebooks, as it has a number of great improvements, and this seems like a movement in a similar direction.

floathub 1y ago

For anyone emacs-curious, you can do a similar thing with org-babel You can have a plaintext file which is also the program which is also the documentation/notebook/website/etc. It's extremely powerful, and is a compelling example of literate programming. A good take on it here: https://osem.seagl.org/conferences/seagl2019/program/proposals/664 https://osem.seagl.org/conferences/seagl2019/program/proposa...

kstrauser 1y ago
Similar with BBEdit's Shell Worksheets, which mingle prose with commands you can run with a keypress.
- ymarketing 1y ago
  [dead]
spudlyo 1y ago
Thanks for the shout-out! I think org-babel is really well suited for this task, and can make some really great documentation. You can check out the video[0] from the talk and a git repo[1] with a more advanced demonstration. [0]: https://www.youtube.com/watch?v=0g9BcZvQbXU https://www.youtube.com/watch?v=0g9BcZvQbXU [1]: https://gitlab.com/spudlyo/orgdemo2 https://gitlab.com/spudlyo/orgdemo2
- floathub 1y ago
  Thanks for making the presentation. I found it very useful when I first started messing around with babel, and I still come back to it from time to time.
zelphirkalt 1y ago
Actually, in terms of capabilities, org-babel is among the most capable, if it is not the most capable, systems for literate programming. I have used it to great effect when learning from computer programming books. I can now go back to those literate programs, and understand again much faster, than originally when reading the books. The literate part of it answers my "silly" questions, that come from not remembering 100% of the reasoning or my own thoughts. That said, there is of course a learning curve, and people unwilling to learn something like that are better off not going that route.

InvisGhost 1y ago

This sort of slogan says nothing about what actually makes it worth looking into.

rc00 1y ago
What more do you need than "written in Rust"?

pm90 1y ago

My dream tooling is for every tool to have an terminal interface so that I can create comprehensive megabooks to get all the context that lives in my head. i.e. jira, datadog, github etc, all in one pane.

buremba 1y ago
You might like MCP then.
- x-complexity 1y ago
  > You might like MCP then. That's entirely different to what's being desired by GP. > > My dream tooling is for every tool to have an terminal interface so that I can create comprehensive megabooks to get all the context that lives in my head. i.e. jira, datadog, github etc, all in one pane. My perspective on this is essentially having jira/datadog/github/etc be pluggable into the CLI, and where standard bash commands & pipes can be used without major restrictions. (Something akin to Yahoo Pipes) MCP is highly centered around LLMs analyzing user requests & creating queries to be run on MCP servers. What's being desired here doesn't centralize around LLMs in any sense at all.
  - janwandersun 1y ago
    [dead]
  - omneity 1y ago
    It’s actually not too far off. Yes MCP is designed for LLM interactions, but we observed that it’s an invocation API that’s pretty generic. So we built a package format that encapsulates computations and makes them accessible from any of MCP, REST, JSON-RPC over WS (the generic cousin of MCP).. We build logic once and make it automatically accessible from any of these consumption methods, in a standardized way to our clients, and I am indeed piping some of these directly in the CLI to jq and others for analysis.
turtlebits 1y ago
Not sure what you mean- github and datadog already have official CLI tools.

huntaub 1y ago

This is exactly what I wanted for our team when I was at AWS. There are so many versions of operations which are just slightly too dangerous to automate, and this provides a path to iteratively building that up. Congratulations!

simsla 1y ago
When I was at Amazon (pre covid), Eider could've been used for that. (Hosted notebooks with IAM integration.)
rochak 1y ago
Preface: My opinions are my own and not my employer’s. Curious how long ago were you at AWS? For context, I spent the last few years in AWS working on an internal platform service whose entire purpose was to reduce operational toil by helping you codify your operational runbooks and execute them safely and automatically. Atuin Desktop is similar to that service in some sense but that service just offered much more features.
- perpil 1y ago
  Not OP but was there 15 years (left Dec 2021) and surprised I wasn't aware of this. I was only aware of a few tools that acted like chatbots to automatically gather context or take action from chime/tt/alarms.
perpil 1y ago
When I was at AWS, I built something so I could run things straight from the wiki. Think cloudwatch queries, aws cli commands etc with user inputs but without all the setup of securely getting the right credentials and formatting inputs. I've rebuilt to run stuff straight from GitHub. Here's it invoking a lambda function straight from a github wiki with user input in 4 lines of code: https://speedrun.nobackspacecrew.com/index.html#invoking-an-aws-lambda-function https://speedrun.nobackspacecrew.com/index.html#invoking-an-...

scubbo 1y ago

I'm really confused by products like this and Warp Drive[0]. What does this add over a shell script? There is a response elsewhere in comments[1] which claims that this is trying to fix the problem of bad documentation, but this has the same fundamental problem. If you a) are responsible for fixing something, b) are unfamiliar with it, and c) the "fixing resources" - whether those are scripts, documentation, or a Runbook/Workflow - you were provided with by the experts are out-of-date; you're SOL and are going to have to get to investigating _anyway_. A runbook and a script are just different points along the spectrum of "how much of this is automated and how much do I have to copy-paste myself?"[2] - both are vulnerable to accuracy-rot. [0]: https://www.warp.dev/warp-drive https://www.warp.dev/warp-drive [1]: https://news.ycombinator.com/item?id=43766842 https://news.ycombinator.com/item?id=43766842 [2]: https://blog.danslimmon.com/2019/07/15/do-nothing-scripting-the-key-to-gradual-automation/ https://blog.danslimmon.com/2019/07/15/do-nothing-scripting-...

brunoqc 1y ago
> I'm really confused by products like this and Warp Drive[0]. What does this add over a shell script? Because everything is a start-up now.

axegon_ 1y ago

Oh, that's really neat! Thanks for sharing!

OhSoHumble 1y ago

This makes me think of using org mode to build runbooks.

celera 1y ago

This looks super similar to https://runme.dev https://runme.dev

nathabonfim59 1y ago
This is amazing! Exactly what I was looking for, thanks!
sourishkrout 1y ago
Thanks for the shout-out. Co-creator of Runme here . Love runnable documentation. We don't have enough of it.
- mkl 1y ago
  I didn't find the hero video on https://runme.dev/ https://runme.dev/ very helpful. I think it would be much easier to understand what Runme is for if you replaced the video with the "Make Markdowns Interactive" demos.
  - sourishkrout 1y ago
    Will look into it. The feedback is much appreciated. Thank you!
- binaryblitz 1y ago
  Your playground says the login is "Only used for verification against abuse." Immediately after signing in, I get an email from you. Serious uncool and an instant "nope" from me after that.

baggiponte 1y ago

This looks so dope!

nsonha 1y ago

Kinda related but just the other day I was thinking of the notebook/runbook workflow and wonder if there is a tool like this that also incorporates git checkpoints (either commit or stash) into it. Like top to bottom, associate all the blocks and resulting artifacts with a commit hash. Might be something to vibe code over the weekend.

kamatour 1y ago

[dead]

amirathi 1y ago

I took a stab at this ~7 years ago - https://nurtch.com/ https://nurtch.com/ The idea has a lot of merit. We even gave a talk about it in JupyterCon Paris 2023 - https://www.youtube.com/watch?v=TUYY2kHrTzs https://www.youtube.com/watch?v=TUYY2kHrTzs When you have executable code in the documentation, folks want to follow PR-review workflow with the docs as well - which is a bit more team investment than editing a wiki. Good luck!

wodenokoto 1y ago
My first thought was also "why not jupyter"? Nice to see someone else had the same thought!

davidelettieri 1y ago

Our team used polyglot notebooks https://marketplace.visualstudio.com/items?itemName=ms-dotnettools.dotnet-interactive-vscode https://marketplace.visualstudio.com/items?itemName=ms-dotne... Using C# as main language this allowed us to have runbooks using code shared as nuget package and so being able to interact with our own APIs and applications as any other code that runs in production. Not the best experience to review but it worked for us.

sudomateo 1y ago

Congratulations on the launch! I've been following Atuin for a bit and, while I'm not necessarily the intended audience for this runbook feature, love seeing people build fun new things.

nikolay 1y ago

It's kind of sad the direction they took. The last thing I want is my runbooks being held hostage by my desktop with proprietary and possibly paid software.

SomaticPirate 1y ago
What do you mean? This looks like open-source
- nikolay 1y ago
  Only the app, not the server and by all indications it won't be free.

kunley 1y ago

Cool name, a reference to well known books

ChrisMarshallNY 1y ago

+1 for the Sir Terry reference!

gitroom 1y ago

i think lots of tools try to solve the same mess and i always end up just wanting my stuff all in one place with less hassle, so seeing more takes on this is cool

exiguus 1y ago

Is it opensource?

oscribinn 1y ago

pretty sure obsidian already has an extension for this

sleepybrett 1y ago

This reminds me of xiki which seems to have kind of died on the vine.

fitsumbelay 1y ago

This post reminded me how much I enjoy doodling with notebooks and UIs like observable and hacks like this -- https://gist.github.com/kahole/651990b888c19b84d5700422daa961de https://gist.github.com/kahole/651990b888c19b84d5700422daa96.... In a really roundabout way, notebooks take me back to using crouton on my Chromebook and opening a terminal in a browser tab. Also just discovered Deno's Jupyter kernel and feel rather set for good times ...

nopelynopington 1y ago

I presume the name Atuin comes from the great world turtle in Terry Pratchett's Discworld books?

perrygeo 1y ago

The poor man's version of this - write your runbooks as text files in your source code. And set your editor to "Send to Terminal". I use vim-slime in nvim, vscode has similar functionality. Document it, version control it, share it, and (semi)automate it. There's no reason to type or copy-paste important commands directly into the terminal.