dimkr1

Most people wouldn't enjoy something like https://github.com/dimkr/tootik

https://github.com/dimkr/tootik is another Gemini social network that does federate over ActivityPub, and I've been thinking about developing a minimalist ActivityPub alternative (maybe using Gemini and Titan to replace HTTP GET and POST, respectively) that can coexist with ActivityPub support

This is my attempt to tick all boxes. Small codebase, two languages (Go and SQL), easy deployment and no frameworks/ORMs, ActivityPub support and a lightweight text-based interface.

https://github.com/dimkr/tootik

For me, the best small side projects involve some kind of porting (between protocols, OSs or CPUs), contribution of a fix for a visible but mysterious bug, or revival of codebases in bad shape, especially when they're unfamiliar and written by others. You can learn a lot from a software engineering culture that's different from yours or small, feasible projects that allow you to understand the bits and bytes of something unfamiliar in a fun and useful way. These projects are great to develop flexibility and general problem solving intuition. And getting familiar with the 20% of an idea, a protocol, a programming language, etc' that's used 80% of the time in real-world use cases, is often enough.

https://github.com/dimkr/gplaces (Gopher -> Gemini port)

https://github.com/dimkr/paho.mqtt.embedded-c (revival of an abandoned library, WebSocket+TLS+Windows+Meson porting sub-projects)

https://github.com/dimkr/loksh (OpenBSD -> Linux)

https://github.com/dimkr/locwm (OpenBSD -> Linux)

https://github.com/puppylinux-woof-CE/woof-CE/projects/1 (a bunch of GTK+ 2/X11/X.Org -> GTK+ 3/Wayland/wlroots porting sub-projects)

https://github.com/dimkr/gtk (x86_64/ARM64 port of a 90's library)

> You can do DNS over HTTPS through Firefox (sadly not on an OS level in Windows for example, but that's fine -- I'm sure OS level support works better on Linux

I'm using https://github.com/dimkr/nss-tls with https://github.com/dimkr/dohli on Linux and it works well. Everything, not just the browser, uses DoH and with endless customization, since I own the server.

When not running as root, it doesn't use a tmpfs. Also, papaw replaces /proc/self/exe with an empty file. And it has some basic anti-debugging, like locking of the payload to RAM so it cannot be recovered by reading it from a swap partition.

There are other ways to do this that don't involve tmpfs or write() - see https://github.com/dimkr/papaw and https://github.com/dimkr/Mirai-Source-Code

nss-tls is "at the OS level". It makes getaddrinfo(), etc', use DoH behind the scenes, so applications are transparently migrated to DoH.

I think you missed the nss-tls README and think nss-tls is not at the "OS level".

Because the OS (getaddrinfo(), gethostbyname(), etc') doesn't implement DoH; it implements a /etc/hosts parser and a DNS (over UDP) client.

I wrote a glibc plugin that implements a caching DoH client for glibc, which can replace the DNS client or fall back to it - https://github.com/dimkr/nss-tls.

Or, you can use https://github.com/dimkr/nss-tls - everything that uses gethostbyname(), addrinfo(), etc', including Firefox with network.trr.mode set to DNS, will use DoH

Raising the security bar of routers is indeed a priority of many ISPs, organizations and consumers. But IMHO, securing the router isn't enough, because once you close the huge security and privacy hole created by vulnerable and outdated home routers, IoT devices like IP cameras will take the router's place as the weakest link in terms of a home network's security, so the problem of malware targeting embedded devices with no security software is still there. (Also, if any guest who connects to a WiFi network can guess admin:admin or admin:12345678 and infect IoT devices, NAT is not enough to provide a reasonable level of security in many home networks. In addition, having open-source firmware or reputable open-source components is not enough to assert that a certain device is secure by design, because most home routers run outdated and vulnerable versions of Linux/uClibc/whatever, often with network stack patches and proprietary drivers from the SoC manufacturer's BSP that make it impossible to upgrade to recent, stable versions of everything; this also applies to the router manufacturers that fork OpenWRT and don't pull changes. Moreover, completely separate from the question of how to develop security updates, the problem of testing and deploying them in time on customer premises, without user intervention, still remains and detracts from the ISP's motivation to provide security: it's very expensive). A copy-paste-based software development lifecycle, unsafe C code, the cost of built-in security and the risks & costs of deploying updates in scale are here to stay for the foreseeable future. A more radical solution is needed to protect today's devices against today's and future threats: that's why in https://www.securingsam.com, we're putting a security-as-a-service umbrella on the existing, consumer-grade router which hardens and protects the router and all devices connected to it using DPI, traffic anomaly detection, auto-updated (independently of the router firmware) vulnerability mitigation patches and much much more.

It isn't Tcl, but a language inspired by Tcl. I think the manual tells the difference, once you see the more restricted syntax.

Nope. The first token in a statement is treated the same way as those that come after it. This way, you can do stuff like this (i.e. imagine a dictionary that maps HTTP methods to hander functions):

    >>> $local functions [$list.new $puts $sleep]
    puts sleep
    >>> [$list.index $functions 0] hello
    hello

Because everything is an object, including built-in functions