kot-behemoth

I recently found llm-buddy (https://github.com/ahyatt/llm-buddy) which might be a good fit.

Llm-buddy is an “Emacs package that watches your recent buffer edits and asks an LLM to review them. When it finds something worth pointing out, it can add a short inline note in the relevant buffer or show a message in a popup buffer (it usually does the former).

The goal is lightweight feedback while you work: typos, logic mistakes, questionable edits, or prose issues that a normal compiler, linter, or spell checker may not catch.”

Daily Notes Editor plugin (https://github.com/Quorafind/Obsidian-Daily-Notes-Editor) does exactly that. Might do the trick for you.

A while ago I saw a promising Clojure project stepwise [0] which sounds pretty close to what you're describing. It not only allows you to define steps in code, but also implements cool stuff like ability to write conditions, error statuses and resources in a much-less verbose EDN instead of JSON. It also supports code reloading and offloading large payloads to S3.

Here's a nice article with code examples implementing a simple pipeline: https://www.quantisan.com/orchestrating-pizza-making-a-tutor....

[0] https://github.com/Motiva-AI/stepwise

macOS Mail app is still the best native e-mail client in my experience.

I have switched to Thunderbird full-time since I switched to Linux. Can confirm it supports unified inbox.

I’ve recently started an open-source self-hosted data platform (https://github.com/kot-behemoth/kitsunadata) with Dokku being a great initial deployment mode. It’s mature, simple to get started and has tons of docs / tutorials.

I collected a bunch of links while learning it, and launched https://github.com/kot-behemoth/awesome-dokku, as there wasn’t an “awesome” list.

Hope it helps someone!

Obsidian.nvim (https://github.com/epwalsh/obsidian.nvim) has been working really well for me. I use Obsidian mobile app (it’s not the best in this space, but still very good). And on my laptop, I’ve got neovim - getting to the daily note is one key combo. It’s also super fast and syncs using Obisidan Sync (or you can do your own).

Before I start working on a feature, I simulate how it's going to work in my head and try to identify all the hurdles and alternatives; sometimes several levels down in the hypothetical component/module hierarchy. I do brainstorms, draw diagrams and make lists of pros-and-cons. I use as many visual aids as I can get.

Remarkably, this is how 37Signal's Shape Up (https://basecamp.com/shapeup) encourages defining feature work prior to building.

In particular, the concepts of Rabbit Hole (as explored with senior developers prior to coding), Breadboarding and Fat Marker Sketches (having a high-level but end-to-end map of the feature) are almost identical to what you're describing.

I found this approach both intuitive in my personal development work, and as a tech lead for lean teams. Funnily, quite a few people really struggle with the concept of "thinking through the feature end-to-end", and not just "let's start with one piece and then figure it out". It's great to do development in small chunks with unknowns, but we still need to know what we are all trying to achieve!

(not affiliated with Shape Up / Basecamp, I just feel Jira leads to hugely suboptimal and waterfall-y processes).

Just a heads up that Prefect integration link on the landing page doesn't work - 404. This is the one I was interested in!

Core.async is listed as “built-in” in the Babashka Toolbox (https://babashka.org/toolbox). Might be worth checking if the compatibility has improved.

And bb supports Honey SQL and SQL pods (https://github.com/babashka/babashka-sql-pods) - so you might be already compatible!

The site itself just drops you straight into the tool, which can be quite confusing (beside being mobile-unfriendly).

Here's a short youtube showcase that gets straight to the point: https://www.youtube.com/watch?v=wE-vOSY-ULc&t=158s

It’s also worth noting that Clojure has libpython-clj (https://github.com/clj-python/libpython-clj) which offers an interface with Python from another lisp. Here are some advanced ML and dataviz examples using that lib: https://github.com/gigasquid/libpython-clj-examples.

I use direnv myself, and it's great. However, for anyone trying it out I'd caution that it doesn't play well with conda - the Python package management system (see this open issue https://github.com/direnv/direnv/issues/326). It can be a dealbreaker for some.

XTDB (https://xtdb.com) while is not directly for Postgres is at least not reliant on devs knowing Clojure. It's very close to Datomic in terms of approach. They expose SQL, Java, HTTP APIs.

Highly recommend LogSeq (https://logseq.com). It started out as very Roam-inspired, but with focus on actually supporting both Org and Md. It’s quite GUI-heavy with good shortcuts support.

Juxt were very vocal about making Crux available beyond Clojure (can't find the exact quote right now, unfortunately). Perhaps the last time you checked it, any non-Clojure support was still WIP. However, since then they definitely have Java API available (Javadoc here: https://crux-doc.s3.eu-west-2.amazonaws.com/crux-javadoc/20....), as well as REST API (see https://opencrux.com/docs#restapi).

Have you heard about Basecamp's solution to this, Hill Charts (https://basecamp.com/features/hill-charts)? It's definitely not an 'enterprise' solution, but I find its simplicity a really good map for the _true_ workflow of developers. That is to say, it's abstract and simple enough to use for devs, while meanigful enough for managers to gauge progress.

Plus, their writeup on imagined vs discovered tasks and how Jira et al give false sense of control when creating tickets upfront is also illuminating: https://basecamp.com/shapeup/3.4-chapter-12

Ah, sorry. I focused too much on the "seriously considering moving back to Markdown-folder backed by Dropbox". Joplin does support note linking (https://joplinapp.org/markdown/#links-to-other-notes), but it is quite clunky, to be honest. However, it does look like it's being addressed soon (https://discourse.joplinapp.org/t/syntax-to-link-notes/5264/...).

Have you had a look at Joplin (https://joplinapp.org)? It's mature, open-source, has e2e encryption, is markdown-backed, and supports syncing via Dropbox. Also supports attachments.

I actually switched to it from org-mode, but still edit the notes in emacs because of keymap (via "Edit in external editor" feature).

I actually am in the same position as you - my main text editor is Emacs (well, doom-emacs). After trying out Bear, Standard Notes etc, I couldn't give up editing plain md files that easily. Org-mode is amazing, but the attachments story is just not solved, especially once you throw mobile into the mix.

I've settled on Joplin, as it's the only serious note-taking app that allows for Emacs-friendly workflow by simply using external editor. I just set the external editor command to be 'emacsclient -c'. Now, when I'm editing a note, I just press Cmd-e, and get Emacs for editing - just for that note. Once I finished editing, it's "C-c k", and Emacs closes and I'm back in Joplin.

I actually set Joplin's layout to always show the rendered md, so that it's basically a pretty front-end for my Emacs-powered editing workflow. Beyond that, syncing and attachments are what makes it more or less perfect second brain system for me.

My current client is a sophisticated AI/ML startup/consultancy, Faculty (https://faculty.ai). They have extensive experience in a variety of areas, and do some cutting-edge stuff. If you're intested, either ping me (email in the profile) and I can connect, or use the website.

I should say that this is not my project. Nor am I a contributor — I only found it recently in my search for deploying TensorFlow models.

In terms of how this is different to other products that provides OCR as a service, object detection as a service: this is not an "as a service" product, but a framework that allows you to deploy ML models in a variety of configurations, such as Docker/K8s. I'd even say it's even further than a framework, as it's opinionated about what goes into the serving cluster: not just model workers, but query manager/load balancer, metrics aggregator and a config DB.

This looks like the perfect time for some of the EU-based influencers to raise a GDPR infringement request against Chtrbox. They collected the geo-location of the people, so the company should've known they would be liable.

"People will get exactly what they deserve". What have children born today done to "deserve" the devastating consequences that are going to unfold? Your view is fascinatingly self-centered and ruthless.

R's ggplot2 follows The Grammar of Graphics. The closest and best implementation of it in Python is Altair (https://altair-viz.github.io). It's a fairly young library, but is very simple to use, and can do really powerful things (see the last chart here https://altair-viz.github.io/case_studies/exploring-weather....)

I tend to agree with Bret Victor on this one (http://worrydream.com/LearnableProgramming): changing numbers randomly is a terrible way of learning programming. We can, and and should try and do better. The microwave analogy in the 'Read the Vocabulary' sections is very apt.

Kraken allows wash trading (proof: https://twitter.com/Bitfinexed/status/957757842852806657), so really untrustworthy.

Speaking of Three.js, have you heard of PlayCanvas (https://playcanvas.com)? It's pretty much a Unity-like IDE based on Three.js, and allows a whole bunch of cool features, like live collaboration.

Here's an example game made in it: Tanx, https://tanx.io. And here's a lightmap-heavy scene for eye candy: https://playcanv.as/p/txPePQvy/

Have you had a look at Lektor (https://www.getlektor.com). It's from the creator of Flask, and is a static CMS implemented in Python. It goes beyond just simple blogging, and allows you to define models for any entity you want to store. It's extremely flexible. It also has a pretty decent UI for writing things in, and is Dropbox-friendly for non-tech users, too.

The landing page explains the benefits quite well. Also, it has good examples of Lektor being used for a catalogue: https://www.getlektor.com/showcase/architekten-ronacher/ (direct link to the interactive version http://www.architekten-ronacher.at/projects/)

Lektor (https://www.getlektor.com) is a static site generator with a simple admin interface (with WYSIWYG editor for markdown) which can be run locally. Publishing can also be done via a button in the UI. For even more user-friendliness, the site can be stored in Dropbox, so the user doesn't even need to know git.

There is an app called Lisping which allows writing a variety of Lisps (Scheme and Clojure) on iPads. The great thing about it was that there was minimal typing - the interface made the AST very clickable, with minimal cursor movement. When I tried it, it was such a great way to edit code on an iPad. Demo video: https://www.youtube.com/watch?v=nHh00VPT7L4