You can use WebAssembly today, but you still need some JS interop for a bunch of browser features (like DOM manipulation). Your core logic can be in WebAssembly though. C# has Blazor, and I wouldn’t be surprised if there’s some Rust WebAssembly projects. I seem to recall that there’s a reimplementation of Flash player that’s built in Rust and compiles to WebAssembly.

Python supports type hints, but you need to use a type checker like Pyre or Pyright to actually check them. Python itself doesn’t do anything with the type hints.

You can enable a persistent connection to get alerts directly without relaying them through Google, but then you need to have a connection to your Home Assistant server all the time (eg by using a VPN or by exposing it publicly)

I don’t see anything in that article that says that Google store the contents of the notification. It just says that they link push tokens to emails, which is true - they have to know who to send the push notification to.

In any case, if you don’t want Home Assistant notifications being relayed through Google, you can use a persistent connection so that the app connects directly to your Home Assistant server.

Most libraries have TypeScript types these days, either bundled directly with the library (common with newer libraries), or as part of the DefinitelyTyped project.

There’s a few comments like this in this thread, from people that I guess didn’t actually read the post :)

They weren’t asking how to do it; they were asking why it works out-of-the-box with the standard Home Assistant notifications.

You don’t need ntfy; the standard Home Assistant app notifications work anywhere since they route via Google Firebase.

That’s what I was thinking of! It’s not in the settings section I’d expect it to be in (notifications) so I thought it wasn’t doable any more.

Use TypeScript, and nonsensical things like adding arrays to objects will be compile-time errors.

Notifications go through Google Firebase servers. This is documented here: https://companion.home-assistant.io/docs/notifications/notification-details/. Your HA server sends the notification to Google, which then sends it to your phone. They don’t store the notification they just relay it.

Most mobile apps do something like this. One reason is to improve battery life - your phone can have a single connection to a Google server instead of every app needing its own separate connection.

There used to be a way to use local notifications (meaning you have to be on the same network, either locally or via a VPN), but I can’t find the setting any more so maybe it’s gone now. (edit: this is still possible)

I’m starting to like the htmx model a lot. Server-rendered app that uses HTML attributes to configure the dynamic bits (e.g. which URL to hit and which DOM element to insert the response into). Don’t have to write much JS (or any in some cases).

you literally can’t hyperlink to any of the data

I thought most React-powered frameworks use a URL router out-of-the-box these days? The developer does need to have a rough idea what they’re doing, though.

I remember WS_FTP LE leaving log files everywhere. What a pain to clean up.

deleted by creator

For some of my sites, I still build on my PC and rsync the build directory across. I’ve been meaning to set up Gitlab or something similar and configure automated deployments.

That’s one nice thing about Java. You can bundle the entire app in one .jar or .war file (a .war is essentially the same as a .jar but it’s designed to run within a Servlet container like Tomcat).

PHP also became popular in the PHP 4.x era because it had a large standard library (you could easily create a PHP site with no third-party libraries), and deployment was simply copying the files to the server. No build step needed. Classic ASP was popular before it, and also had no build step. but it had a very small standard library and relied heavily on COM components which had to be manually installed on the server.

PHP is mostly the same today, but these days it’s JIT compiled so it’s faster than the PHP of the past, which was interpreted.

FTP isn’t really used much any more. SFTP (file transfers over SSH) mostly took over, and people that want to sync a whole directory to the server usually use rsync these days.

No, because there’s use cases for systems that aren’t connected to the internet. Also, public IPs can be dynamic, so you might not want to rely on them internally.

Note that Android doesn’t support DHCPv6, just in case you have Android devices and ever have to debug IPv6 on them.

Yeah I’m not using NAT, sorry for the confusion.

My router doesn’t support RAs for a ULA range though, so I’m running radvd on my home server.

your external IPs might change, such as when moving between ISPs

This is true

You would NAT a hosts external address to its internal address.

This is usually not true.

If you’re worried about your external IP changing (like if you’re hosting a server on it), you’d solve it the same way you solve it with IPv4: Using dynamic DNS. The main difference is that you run the DDNS client on the computer rather than the router. If there’s multiple systems you want to be able to access externally, you’d habe multiple DDNS hostnames.

Having a large range has a number of benefits though. Companies that have dozens of IPv4 ranges may be fine with a single IPv6 range, which simplifies routing rules.

A lot of features in IPv6 take advantage of the fact that networks have at least a /64 range (at least if they’re built correctly according to RFC4291 and newer specs). SLAAC is a major one: Devices can auto-configure IP addresses without having to use something like a stateful DHCP server.