Ask HN: What are some unpopular technologies you wish people knew more about?

I don't mean just vacuum tubes or even electronics at all. Mechanical analog computing is insane when you get down to it. You have special shapes that move against each other and do calculus.

We make these mechanical models as analogs of more complex physical systems. We can turn huge calculations into relatively simple machines. That we can roll two weirdly shaped gears together and get an integral out says to me something very profound about the universe. I find it to be one of the most beautiful concepts in all of the sciences.

What's even more wild is that we can take those mechanical analogs of physical systems and build an electronic analog out of vacuum tubes. That vacuum tubes work at all is just completely insane, but it's some absolutely beautiful physics.

And yes, there are equally beautiful problems that can only be solved in the digital domain, but it just doesn't speak to me in the same way. The closest thing is the bitwise black magic like fast inverse square root from a special constant and some arithmetic. Besides, that's more a property of number systems than it is of digital computation.

I understand how and why digital took over, but I can't help but feel like we lost something profound in abandoning analog.

Additionally, as machine-generated content proliferates, I think having services use something like the web of trust concept for membership would be super powerful. The problem is, of course, the terrible UX of cryptographic signatures. But I think there's a lot of opportunity for the group that makes it easy to use.

[0]: https://en.wikipedia.org/wiki/Web_of_trust

I call it a docs system rather than static site generator because the web is just one of many output targets it supports.

To tap into its full power you need to author in a markup that predates Markdown called reStructuredText (reST). It's very similar to Markdown (MD) so it's never bothered me, but I know some people get very annoyed at the "uncanny valley" between reST and MD. reST has some very powerful yet simple features; it perplexes me that these aren't adopted in other docs systems. For example, to cross-link you just do :ref:`target` where `target` is an ID for a section. At "compile-time" the ref is replaced with the section title text. If you remove that ID then the build fails. Always accurate internal links, in other words.

The extension system really works and there is quite a large ecosystem of extensions on PyPI for common tasks, such as generating a sitemap.

The documentation for Sphinx is ironically not great; not terrible but not great either. I eventually accomplish whatever I need to do but the sub-optimal docs make the research take a bit longer than it probably has to.

I have been a technical writer for 11 years and have used many SSGs over the years. There's no perfect SSG but Sphinx strikes the best balance between the common tradeoffs.

[1] https://www.sphinx-doc.org/en/master/index.html

You can create highly specialized templates in Lua, and there's a RDBMS extension called Cargo that gives you some limited SQL ability too. With these tools you can build basically an entirely custom CMS on top of the base MW software, while retaining everything that's great about MW (easy page history, anyone can start editing including with a WYSIWYG editor, really fine-grained permissions control across user groups, a fantastic API for automated edits).

It doesn't have the range of plugins to external services the way something like Confluence has, but you can host it yourself and have a great platform for documentation.

What I wish more people knew was that you don't need to do those things to get value from Nix. Create project specific dev shells that install the packages (at the correct versions) to work with that project can almost replace 90% of the docs for getting setup to work on a project.

This has accounted for about 90% of everything I've built since 1985.

Pick code generates my side project: https://eddiots.com/1

- Tarantool is some sort of in-memory DB with optional persistence

- Red is a programming language that has made the odd syntax decision to use {} for strings and [] to define scopes

- U++ is one of those all-encompasing C++ frameworks like QT

- Lazarus is a Pascal(?) IDE

- And FASM is a toolkit for building assemblers

I'm struggling to find the common thread across these links, apart from the OP probably being an enthusiast of obscure programming languages

Previous discussions on HN: https://hn.algolia.com/?q=postgrest

- costs next to nothing to charge

- fast and fun to get around

- never pay for parking

- cheap maintenance

- hauls groceries easily

- good exercise

I've always wanted to build a digital clock entirely running on fluids. It would use fluid gates, and present a digital display by pushing blobs of coloured immiscible liquids back and forth through glass tubes (perhaps arranged as a seven-segment display). The counter itself would be made using fluid gates (which I don't know how to make). It would be slow; but for a wallclock with minute precision, you hardly need nanosecond gates.

So I wish "fluidonics" were popular.

Linux namespaces/cgroups but lighter than Docker.

I use it when I want to limit the memory of a Python script:

``` maxmem="56" #GB

firejail --noprofile --rlimit-as=${maxmem}000000000 python myscript.py ```

ESPHome. It's a framework for declaratively building firmware for microcontrollers, based on rules like "This pin is an input with debouncing, when it changes, toggle this".

Contributing to them has probably been the most fun I've had programming in years.

We just need power management, and a C++ implementation of the Native API client. It's so close to being able to replace most of what I'd normally code by hand in Arduino.

https://esphome.io/

RealThunder's fork of FreeCAD: https://github.com/realthunder/FreeCAD

They fix so many issues. Linear patterns can duplicate other linear patterns!

Vorta: It's the best backup technology I've seen. Just an easy guided GUI for Borg, which gives you deduplication. I just wish they let you deduplicate across multiple repositories somehow.

Given that webassembly is a stack language with no GC, i do expect a comeback of concatenative programming some time in the future.

https://www.youtube.com/@siliconvalleyforthinterest1736

* SSH ForcedCommand. Lots of usecases here, for backups, file storage, git, etc.

* Verilog as a tool for software developers to learn digital electronics. VCS/code/simulation/unit tests are all a lot more familiar and expected for developers.

* Writing tools yourself. There's often decent stable libraries that do 90% of what you want, and the remaining 10% is less effort than dealing with awkward integration with off-the-shelf tools. This relies on having low overhead packaging/deployment, e.g. Nix/Guix/Bazel.

Fossil: distributed version control and much more in a single executable, from the creators of SQLite: https://fossil-scm.org/

* Graph-relational database

* Queries return objects linked to other objects through properties, not rows

* ... But it's still Postgres under the hood

* Open source

- Matrix. It's pretty popular but I see way too many open source projects still saying "join our Discord!" instead of "join us on Matrix!"

- DNSSEC+DANE - It's half-assed deployed but there's a lack of end-user UX

- wais - search before gopher

- afs - distributed fs

- discard protocol - basically, a network-based /dev/null

- humans.txt - Not around as much as it was

- makeheaders - Auto-generated C/C++ headers

- man page generators - ronn and help2man

- checkinstall - The automatic software package creator

- bashdb and zshdb

- crystal - Compiled Ruby-ish

- forth - Powered the FreeBSD bootloader menu for many years and word processors (typewriter-like almost computers)

- ocaml - The best ML, used by Jane Street and Xen

- pony - A language built around an arguably better GC than Azul's C4 with arguably stronger sharing semantics than Rust

- prolog - Erlang's grandpa

- rpython - PyPy's recompiler-compiler

- pax - POSIX archives

- shar - shell archives - Self-extracting archives that look like scripts at the beginning

- surfraw - Shell Users' Revolutionary Front Rage Against the Web - founded by Julian Assange

- step-ca - A Go-based PKI server

- dmraid - Because it works

- X10 - Before WiFi and IoT, there was the Firecracker: a parasitic power serial port RF outlet controller

- FreeBSD - It's not unknown or obscure per se, but it powers many important things in the civilized world without getting much credit

- :CueCat - A dotcom era barcode reader that was given away

- Xen - If you need to run a VPS but can't ju$tify u$ing VMware

- KataContainers - k8s but with VM isolation

- stow - software management by symlinks

- habitat - similar philosophy as nix but not as clean and functional and almost like Arch PKGBUILD but with more infrastructure around it

- JTAG - debug all the things

- in-circuit emulators (ICEs) - hardware-based debuggers

- polarized light sources - easier to see things under the bi/trinocular microscope

"Haxe can build cross-platform applications targeting JavaScript, C++, C#, Java, JVM, Python, Lua, PHP, Flash, and allows access to each platform's native capabilities. Haxe has its own VMs (HashLink and NekoVM) but can also run in interpreted mode."

It's mostly popular in game dev circles, and is used by: Nortgard, Dead Cells, Papers Please, ... .

I’ve been using it for over 5 years now [1], and it’s as good as ever. It’s way faster than any other chat app I’ve used. It has a good UI and conversation model. It has a simple and functional API that lets me curl threads and write blog posts based on them.

(only problem is that I Ctrl-+ in my browser to make the font bigger – I think it’s too dense for most people)

(2) re2c regex to state machine compiler - https://re2c.org

A gem from the 90’s, which people have done a great job maintaining and improving (getting Go and Rust target support in the last few years).

I started using it in 2016, and used it for a new program a few months ago. I came to the conclusion that it should have been built into C, because C has shitty string processing – and Ken Thompson both invented C AND brought regular languages to computing !!

In comparison, treesitter lexers are very low level, fiddly, and error prone. I recently saw dozens of ad hoc fixes to the tree-sitter-bash lexer, which is unsurprising if you look at the structure of the code (manually crawling through backslashes and braces in C).

https://github.com/tree-sitter/tree-sitter-bash/blob/master/...

These fixes are definitely appreciated, but I think it indicates a problem with the model itself.

(based on https://lobste.rs/s/endspx/software_you_are_thankful_for#c_y...)

[1] https://www.oilshell.org/blog/2018/04/26.html

- VSCode devcontainers: https://code.visualstudio.com/docs/devcontainers/containers

(I only wish I was being sarcastic.)

It's a protocol/tool for async file transfer, built for disconnected/intermittent connectivity amongst known parties (trusted friends as p2p), allowing even for sneakernet-based file transfer.

It's started as a modern take on usenet, but it boggles my mind how cool it is:

Want to send a TV Series to your friend? send it via nncp, and it will make it through either via line-based file transfer (when connection allows, pull or push, cronjob, etc), or even via sneakernet if there is "someone going that way".

Comms priority system lets you hi-prio message-checking via expensive network link vs bulk file transfer using trunk lines later.

It even can be configured to run arbitrary commands on message receive, to allow indexing/processing of files (like a ZFS-receive hook, mail/matrix ingestion...)

See all the usecases: http://www.nncpgo.org/Use-cases.html

As with many of these cool techs, I just wish I had a good reason to use it =D

- https://arcan-fe.com/2022/10/15/whipping-up-a-new-shell-lash...

- https://arcan-fe.com/2021/04/12/introducing-pipeworld/

- https://arcan-fe.com/2020/12/03/arcan-versus-xorg-feature-pa...

- https://arcan-fe.com/2021/09/20/arcan-as-operating-system-de...

- gron (Greppable JSON): https://github.com/tomnomnom/gron

- MarkDownload (Markdown Web Clipper): https://github.com/deathau/markdownload

- Lean4 links:

-- Theorem proving: https://lean-lang.org/theorem_proving_in_lean4/introduction....

-- Natural Number Game: https://adam.math.hhu.de/#/g/leanprover-community/NNG4

However, lately I've come to like llama.cpp and friends, yes it's not ChatGTP miracle whatever but how often do you /actually/ need that? Despite its tremendous popularity, it still seems like something more people should know about. For me, I've had great fun with running LLMs locally and experiencing their different "flavors" from a more "phenomenological" (what is it like to use them) perspective rather than a technological one.

¹) http://wincompose.info/

²) https://en.wikipedia.org/wiki/Compose_key

Couple of things I like

- tarantool https://www.tarantool.io/en/

- rebol/red-lang https://www.red-lang.org/

- U++ : https://www.ultimatepp.org/

- lazarus: https://www.lazarus-ide.org/

- fasm: https://flatassembler.net/

For publishing documentation / to build the web site: Antora [2].

AsciiDoc has a bit more features compared to Markdown which allows for a richer and more pleasant presentation of the docs.

Antora allows you to have the project documentation in the actual project repositories. It then pulls the docs from all the different repos together to build the site. This also allows you to have the released product versions go in-synch with the docs versions. Antora builds each version of the product as part of one site. The reader can explore different product versions or navigate between pages across versions.

===

[1] https://asciidoc.org/

[2] https://antora.org/

and here for a book to learn it from: https://book.simply-logical.space/src/simply-logical.html

I think it is the closest thing to a "tool for expressing thought" with a proof procedure, which presently exists.

The openSUSE build system is also great for building packages for a lot distros. It's not just for openSUSE.

I dream of a CMS akin to WordPress, but developed in LSP.

Lua is lean, with minimal syntactic sugar, and it feels like a 'complete' language. Therefore, we don't anticipate any additional bloat in the future.

Tokenizes chinese text into "words" for learning purposes and then renders the text in a GUI where you can click on a word to get the definition. It's not perfect, but a LLM fine tuned for it will eventually result in much better "tokenization".

I'm not sure I can type out, with trembling fingers, how many dollars have been flushed down the toilet of CCSs by businesses that either had no business experimenting with componentized content, or businesses that didn't have resources for training up staff, or vendors who literally evaporated like morning dew after they'd gotten their initialization fees. So just one single story: one prime aerospace vendor I worked with had started their road to S1000D publishing in 2009. Today - at the end of 2023, and more than twenty million dollars later, with a garbage truck full of sweat and blood - that system has not released a single publication to the end user. Not one.

https://github.com/automatic-ripping-machine/automatic-rippi...

Put a DVD/blu ray in a drive and it automatically determines the title, starts ripping, then pops the disc out when it's done.

There's options for post-ripping transcoding also.

- Data diodes (unidirectional networks) - allow you to monitor a network without allowing external control (or only submit info, never ever exfiltrate it)

- GNU Radio - you can play with your audio ports, and learn instinctively how do deal with all the stuff that used to require DSP chips... then apply that knowledge with a $30 RTL-SDR dongle.

- Lazarus - seconding the above... a really good Pascal GUI IDE. The documentation needs work, but it's pretty good otherwise.

"vopono is a tool to run applications through VPN tunnels via temporary network namespaces. This allows you to run only a handful of applications through different VPNs simultaneously, whilst keeping your main connection as normal.

vopono includes built-in killswitches for both Wireguard and OpenVPN."

the cyber swiss army knife

- in-process databases (rocksdb, sqlite)

- FoundationDB

- C/C++ and low level programming in general (I wished I learned those instead of js when I was younger)

- State Machines, Actor Model (Orleans Net), Event Sourcing

- Bittorrent for other things than pirating (it looks like it's dying)

- Arduino and similar

- Seastar

- Arrow (ecosystem)

A whole lot of innovation from the competitive debate community has quietly existed for decades now. Hopefully one day SV discovers all the cool shit debaters have been building for themselves.

[0] https://lv2plug.in/ [1] https://lv2plug.in/ns/ext/atom

Edit: Hydrocolloid blister plasters

- I'd like Emacs/org-mode knowledge common at least starting from universities because we need the classic desktop model and Emacs is the still developed piece of software implementing it alongside with Pharo, but Pharo is usable only to play and develop while Emacs is ready to end-users usage with a gazillion of ready-made packages;

- feeds, in the broad sense, meaning XML automation on the net/web so I can get my bills just from a feedreader, all transactions digitally signed, so both party have a proof (ah, of course a national PKI is mandatory), news, anything in the same way making my information mine in my hands instead of wasting time in gazillion of crappy services;

- IPv6 with a global per host, so we can finally profit of our modern fiber-optics connections instead of being tied to someone else computer, i.e. "the cloud";

- last but just aside: R instead of spreadsheets for the business guys, so they do not produce and share anymore crappy stuff, LaTeX for similar reasons to produce nice looking pdfs...

https://imba.io/

It's a really simple alternative to something like wireguard.

https://kozubik.com/items/2famule/

Of course someone will reply with a more complete language, but I'll start by throwing out array-based languages, in the form of J: https://www.jsoftware.com/#/

Once you really get your head around composing verbs, really working with arrays, and using exponents on functions, it's mind-expanding.

Also, my company (VMware) has a really powerful YAML templating engine called ytt. I originally hated it and dunked on it constantly but have grown to love it. It makes creating composable and modular YAML really easy, which is extremely unfortunate that this is a real thing, but when you need it, you need it.

Lastly, Cucumber isn't _unknown_ unknown, but I wish it was more widely used. Behavior testing is really useful even if the program has great test coverage underneath. Being able to express tests in pure English that do stuff is powerful and can be a bargaining chip for crucial conversations with product sometimes if done correctly. I mean, yes, we have GPTs that can write tests from prompts written in your language of choice and GPT Vision can manipulate a browser, but Cucumber is an easy stand-in IMO that is cheap and free!

If you have a distributed system, dont want to spend a lot of time on wrestling with ELK or fell out of your chair when opening the Splunk bill. Loki offers 90% of the features with OSS model and very simple deployment.

Complete game changer. Very simple to understand data model, alerts on logs, extract and group data from structured or unstructured logs, combine logs across sources, scales to both small and big system.

It’s surprising other tools in the same space have such a hard time hitting the right balance between capability and cost+complexity. Logs are so essential you would think the tooling space around it was better.

It was truly interesting. Long story short, you stored your objects in the database, along with other objects. No object-relational mismatch.

Queries meant taking a subset of a graph (of objects). It was fast and performant, and fairly solid.

It's essentially the result of asking "what if database development had taken a different turn at some point?".

Of the owning company would release it under some kind of open source license (maybe open core, BSL or one of those new revenue-friendly licenses) it could probably get very very popular.

https://docs.saltproject.io/en/getstarted/

https://stackstorm.com

https://sshuttle.readthedocs.io/en/stable/

A few people on HN are into Buddhist meditation - I read mentions of Culadasa's The Mind Illuminated or Ingram's book. Indeed I've done several Vipassana and Zen retreats, but they just aren't as integrated as yogas 8 limbs. They may lead to the same place eventually, but I think they take much longer.

If there was a device that made people feel as good as the awakening nervous system, the inventor would be a multi-millionaire, no question (in fact I think I heard a Western monk is involved in a startup to try to create one). It is truly unparalleled and something actually worth experiencing (from what I've seen so far).

For those interested in resources I've found helpful to experience these changes for myself here are 2 I recommend:

* https://www.aypsite.com/10.html

* https://morrismethodsandmore.com/schedules/

https://github.com/codecando-x/peregrine

It should be used more for building Data Pipelines specifically.

  * APL -- I haven't dedicated the time to learning in part because there's little support where I normally work. I'd love for APL to have be adapted like a domain specific language a la perl compatible regular expressions for various languages (april in common lisp, APL.jl in julia).
  * regular expressions. https://xkcd.com/1171/
  * bugs/issue tracking embedded in git https://github.com/MichaelMure/git-bug/

  * "type efficiently by saying syllables and literal words" https://sr.ht/~geb/numen/
  * I use fasd[0] 'z' alias for jumping to previous directories in shell every day.
  * Alt+. in shell (readline, bash) to get the previous commands last argument is another ergonomic time saver that I think is relatively obscure. I have a bash wrapper to combine that with fzf for quick any-previous-command-argument  fuzzy search and insert [1]
  * zimwiki [2] (and/or a less capable emacs mode[3]) for note taking has served me well for a decade+
  * DokuWiki's XML RPC [4] enables local editor edits to a web wiki. I wish it was picked up by more editor plugin developers. (cf. emacs-dokiwki [5]) 
 * xterm isn't unpopular per say, but I don't see sixel support and title setting escape codes talked about often. I depend on a bash debug trap to update the prompt with escape codes that set the terminal title [6]

[0] https://github.com/clvv/fasd [1] https://github.com/WillForan/fuzzy_arg [2] https://zim-wiki.org/ [3] https://github.com/WillForan/zim-wiki-mode [4] https://www.dokuwiki.org/xmlrpc [5] https://github.com/flexibeast/emacs-dokuwiki [6] https://github.com/WillForan/dotconf/blob/master/bash/PS1.ba... -- bash debug trap to update prompt with escape codes that set the title to previous run command -- to eg. search windows for the terminal playing music from 'mpv'

E-ink diplays...

Flexion pens

XMPP

Gemini Protocol

Urbit