dhamidi

There's vuego: https://github.com/titpetric/vuego

And my own version (I learned of vuego only after): https://htmlc.sh

Not a fan of html/template and tmpl myself, because HTML should be treated as tree and not as strings, but everybody has different preferences.

For routing I now use my own library in all projects: https://github.com/dhamidi/dispatch

It's relatively easy to generate your own nowadays, I mostly go through the Ruby on Rails guides and mix and match the pieces I want for go and turn them into libraries :)

I understand the sentiment. Rails was my introduction to hypermedia and it was convenient and easy, so experiencing friction when building with Go/HTMX came as a surprise.

After a few attempts I learned that abstractions are important :D

Without a component builder and reversible router is indeed pretty painful (and Rails just ships with these things so you didn't have to worry about it).

The biggest benefit for me personally is that computation and data live in one place, which carries you very far. Also, machines like hypermedia: LLMs are great at using and testing hypermedia apps because they are self-contained and the cycle time is lower because you don't need to wait for JS.

And yes, no easy off the shelf component library makes starting harder.

Disclaimer: I'm part of the team building it

That's what Amp is built around!

By default conversations are shares in your team (you can also make them private), and the agent has access to them.

So you can do things like "how would $teammate think about this" and the agent will read your colleague's conversations with Amp to get a feel for that and evaluate your work based on that.

Or just figuring out what everyone is doing at the moment is much easier that way

I know it's in vogue to bash Bash but I feel that criticism is unfair.

Shell scripting is a victim of its own success: it is _so easy_ to get started that most users get value out of knowing the first one percent and never bother to actually learn the rest.

There aren't many who have read the Bash manual, or know what zsh can do that Bash cannot, etc.

"Shell scripting is a hot, slow mess" is the same hot slow mess that you get wherever the barrier to entry is extremely low (e.g. early PHP, early JavaScript/frontend development, game development with a game engine where you can just click around in the editor, etc).

Maybe useful inspiration from TCL: there are many commands that define new variables, which makes modeling the stack unnecessary.

For example:

  lappend responses [dict status 200 body ...]

I can see that being an attribute:

  <request-send url="..." as="greeting" />
  <response-text response="greeting" as="text" />
  <selection-set-text text="text" />

Feather, a fresh implementation of TCL: https://www.feather-lang.dev

Command languages are underrated, and being able to add a Bash-like REPL for agents and users alike is something I want to see more of.

Feather solves the "rest of the Owl" problem: agents/users get loops, conditionals, online help for free from Feather, as the embedder you only need to add application-specific commands.

Feather itself has no GC (uses the host's), no own data structures (uses the host's, e.g. JavaScript arrays for lists in the js version), and no I/O.

The core is implemented in stdlib-less C

Thank you!

Are you doing a mostly one-to-one port, or something more novel?

Step 1 is a one-to-one port of all the non-I/O, non-OO stuff. I've got it down to a single skill for Opus 4.5 and now it's just a matter of turning the crank and keeping an eye on it.

Step 2: add more functionality for interactive use for humans/agents. Things like defining the syntax of commands, a completion engine, a help system. Essentially all the things you'd expect from a modern shell experience, but with a bring-your-own-UI approach.

but man is reference counting a pain in the neck or what.

Maybe this is a bit more novel: since the only use case is embedding, and the host language already has dicts, lists, and other data structures, I'm just leveraging those. In the Go version of Feather, dicts are Go maps; in the JavaScript version they are backed by lists of pairs (to preserve insertion order)

Not affiliated, just have been following development closely: Phrasing leverages existing content, e.g. subtitles from your favorite shows.

The quality depends on the source material you choose to give it.

This is great, I was literally looking for something like this yesterday to embed TCL into a Go application without needing CGo

That's already the case with https://docs.claude.com/en/docs/claude-code/plugins

The `source` builtin searches through all directories on PATH, not quite a library system, but useable with a bit of discipline in the to-be-sourced shellscripts.

More tools / toys / sandboxes to play with.

Growing a coding agent as a "game": https://github.com/dhamidi/smolcode. Started with https://ampcode.com/how-to-build-an-agent and then asked the agent to modify itself. It's so much fun and hard to stop!

Since coding is cheap now, I'm building a web framework for myself, using reasonable defaults: built around the transaction log, single binary deploys, sqlite3 for everything, runtime introspection tools to make ops easier.

I want the framework to "compile itself out of the project", so that projects don't have devtime dependencies and can be easily edited by Cursor et al. It should still stick around in the form of a high-level CLI that an AI agent can leverage to fulfill common tasks (e.g. add a new UI component, query, command, etc).

Modash.io | Senior Product Engineer | Remote (EU) | Full-time

Modash is an end-to-end influencer marketing platform for Shopify stores.

We help every creator earn a living.

Headquartered in Tallinn, Estonia, with engineering distributed across Europe.

60 person team, raised $12M in Series A funding, ARR growing 2x YoY.

We're on the hunt for Senior Product Engineers who love working with AWS, Vue, NodeJS, Typescript and a passion for product: you are eager to talk to customers and anticipate their needs.

If you're all about remote work, and can't wait to make a real impact, we'd love to chat!

Interview Process

Option A: https://www.modash.io/blog/engineering-interviews-at-modash

Use https://apply.workable.com/modash/j/C1507B65C3/ to apply

Option B: showcase your project!

  - It's live somewhere,
  - It has users
  - You built it yourself/you are the main contributor

Use this link https://forms.gle/K4GcyxT1zbmHGdsRA to apply.

So cool to see this here!

I bought a house in Nyland [1] a few years ago and now I'm turning it into a place to retreat to for focus time / being close to nature.

If someone is interested in sharing the space over a longer period of time (as I'm not living in Sweden), hit me up (email on my profile)

[1] https://maps.app.goo.gl/Ww1GHL5rFXdkcdHfA

It's not much different than with Postgres:

    ssh your-server sqlite3 /tmp/path/to/your/db.sqlite3

    kamal app exec -i --reuse bin/rails console

I had the pleasure of meeting Ben in real life and watch him work — he's just really good at what he does, and his experience with ClojureScript is deep and wide.

One thing that sets him apart from myself and other engineers I've seen is *speed*: while I'm still thinking about a problem, Ben has implemented multiple prototypes, learned more about the problem and picked the best solution.

Actually plain less works quite well when using filters:

  #!/bin/bash
  # ~/.lessfilter
  case $1 in
    *.md) view-md $1;;
    *.json) jq -C . $1;;
    *) pygmentize $1;;
  esac

  #!/usr/bin/env ruby
  
  require 'tty-markdown'
  
  puts TTY::Markdown.parse(ARGF.read, colors: 256)

Is anybody here aware of any TUI/CLI tools that bring UX patterns/ideas from other programs to the terminal?

Examples:

- bash/zsh/fish bring suggestions/autocompletion

- fzf brings fuzzily-matching selections to the terminal,

- https://github.com/ericfreese/rat brings the idea of "widgets" or "layouts",

- https://github.com/mrnugget/fzz brings "preview as you type"

I'm looking for more patterns like that, mainly to explore how to make them work in the terminal and see whether that actually has an impact on everyday actions people perform in the terminal many times per day.

The goal is not to save time, but to reduce mental friction.

It is not a good idea to use the backslash as the trigger key since it is the traditional line continuation and escape character on UNIX.

Well it is also the default key binding for VIM's leader key and placed on the home row on US keyboards which makes it really accessible.

What is not shown in the demo screencast is that leader detects whether the cursor is inside a quoted string and in that case doesn't present a menu but tells the shell to insert a literal backspace at the current cursor position.

For continuing lines on an interactive shell the user would have to press Ctrl+V followed by a backslash to insert a literal backslash. In my experience this is rarely necessary in an interactive terminal so the extra utility gained by having leader on the home row outweighs the extra key press necessary for continuing a line.

Furthermore it is not a good idea to replace the command line with a menu since that limits what is possible in UNIX.

That is true. Leader is not _replacing_ the command line, the command line still works as usual, the only difference is that you can launch a menu by typing backslash to quickly run a command.

Why should basename accepts its argument on stdin? It doesn't act as a filter, processing a stream of data, but rather as a plain function.

Thanks, somehow I missed that.

The question of water is not so much how do we protect the building from water but rather how do we harvest the resource of water from the building!

"Harvesting" water from the building is certainly an interesting idea!

as condensation from warm interiors onto cold surfaces will likely be an issue

That's a good point.

What's your opinion on the feasibility of this building technique for urban areas (in say, Western Europe)? I can imagine it to be hard to get a permit for building such a dome, as it doesn't blend in with the surrounding structures. Other than that, the low cost make it very attractive.

All the pictures on the website seem to be taken in arid climates. Does anyone know how well Superadobe is suited to more humid/cold climates (e.g. Scandinavia)?

Adding layers of insulation on the inside seems non-trivial, given the dome shape and the already thick walls.

The plastic bags are only intended to be exposed temporarily. If the structure is intended to be permanent, the plastic bags are plastered over (from the article):

For permanent structures, the synthetic bags are plastered over to provide an erosion resisting layer, or they can be removed when the stabilized earthen filler is cured.

How are app stores (something which users are used to already) different from package managers with a user-friendly GUI?

See also Setun <http://en.wikipedia.org/wiki/Setun>, a computer from 1958 using the balanced ternary system.

Update: the README now describes the available key bindings and gives more usage examples.

Regarding Emacs: git ships with Emacs integration <https://github.com/git/git/tree/master/contrib/emacs>.

Note that most likely git.el is not on your load-path. After it is loaded, you can use M-x git-status to interactively stage, diff and commit files. In the git-status buffer you can checkout a branch with C-c C-o. If helm is installed, you'll get something similar to percol right in Emacs.

Would you mind sharing what that alias would look like and do? I can only imagine it appending the string "| tmenu" to the current line, eventually pressing Return for the user as well.

Funnily enough, I recently implemented something akin to percol:

https://github.com/dhamidi/tmenu

It actually tries to be dmenu for the terminal.

+1 for Estonia

"Jobless programmer" is kind of a joke there.