Ciantic

I hope something like SailfishOS [1] could take off. They do have Android support, and maybe even by pressure, they could get banking apps working in the EU via that.

[1]: https://sailfishos.org/

Finland has an operational "sand battery", which primary purpose is heating. That was discussed in HN few months ago [1].

When it comes to this article, I doubt the 500x cheaper statement, we would see these already everywhere if that were the case.

[1]: https://news.ycombinator.com/item?id=44295132

I'm looking at https://roc-lang.org Maybe once it matures, it could have the strengths of TypeScript and Haskell.

I plan to test this, but I'm still holding off. This is coming from a user who seems to have a new account on GitHub and HN. Must take caution first and read about the implementation.

P.S. "lue" means "read" in Finnish.

I use Bun for many package.json projects, but for shell scripting specifically, I find that Deno is a better choice because you can use dependencies with just import statements via NPM or JSR.

    #!/usr/bin/env -S deno run
    import { z } from "npm:zod";
    import { Webview } from "jsr:@webview/webview";

It works surprisingly well when used in npm compatiblity mode, a lot like Bun is used.

Running `deno install` in a directory with package.json will create a leaner version of node_modules, running `deno task something` will run scripts defined in `package.json`.

Deno way of doing things is a bit problematic, as I too find it is often a timesink where things don't work, then if you have to escape back to node/npm it becomes a bigger hassle. Using Deno with package.json is easier.

It's a setting in a bios, it happened to me too.

Enter BIOS by pressing ESC during the ROG logo Usually under Advanced, there is an option to disable auto-downloading of MyAsus in Windows

https://github.com/sammilucia/ASUS-G14-Debloating/blob/main/...

In Windows, hardware vendors have a bad habit of installing useless stuff. Latest trick is that the motherboard contains the payload that gets automatically installed when installing Windows. I had no idea it was even possible. This 'feature' can apparently be disabled from bios, but it needs to be done before installing Windows.

I happen to have both of those DLLs, but I had already disabled all ASUS-related services. I use this script to disable all services starting with "Asus" on startup. [1]

To disable the MyASUS auto-installer in BIOS go to Advanced, there is an option to disable auto-downloading of MyAsus in Windows. [2]

[1]: https://gist.github.com/Ciantic/76ade5f2731cbe87b70d17ff2898...

[2]: https://github.com/sammilucia/ASUS-G14-Debloating/blob/main/...

The only way out of this in the long term is via negotiations.

The US and Israel were lucky that Iran built their Fordow plant only 50 meters underground. What will the US do when Iran rebuilds it far deeper? They have a coal mine going 1200 meters deep.

Iran is technologically far more capable than North Korea, which ultimately succeeded in building the bomb. The US knows this and wouldn't have started this war if Israel hadn't done it first.

The first Iran deal in 2015 was not perfect, but it would have provided some guarantees for 15 years. If Iran is determined, how many years has this bombing bought? If I had to guess, Israel is back calling doom ~3 years when the US is having new elections.

Israel doesn't want the removal of the Iran sanctions, why would they? This means whatever deal the US makes with Iran, it's not going to be good enough for Israel.

I often think this too. I'm both. When working for a client, I'm clearly a destination programmer. Choosing boring tech that I know of to get things done, which these days coincides with a tech that is also good for LLMs, as they are famously good with boring tech.

However, when I don't have deadlines, like in my Github creations, I'm clearly a journey programmer; I don't get anything fully finished usually. In these projects tech I use is something I usually wouldn't pick if I worked for a client.

Also this: https://www.404media.co/ukraines-massive-drone-attack-was-po...

"ArduPilot can handle tasks like stabilizing a drone in the air while the pilot focuses on moving to their next objective. Pilots can switch them into loitering mode, for example, if they need to step away or perform another task, and it has failsafe modes that keep a drone aloft if signal is lost."

So it is not fully autonomous.

The latest attack deep inside Russian borders were apparently using ArduPilot [1], it is mentioned in the Atlantic article [2]. ArduPilot also has C++ source code in Github [3], also adding an article specifically about ArduPilot and Ukraine [4]

[1]: https://ardupilot.org/

[2]: https://www.theatlantic.com/international/archive/2025/06/uk...

[3]: https://github.com/ArduPilot/ardupilot

[4]: https://www.404media.co/ukraines-massive-drone-attack-was-po...

I like this, I would like to add: If you don't use tmux often, then enabling only the mouse support makes it much easier:

   $ cat .tmux.conf
   setw -g mouse on

Now holding the right mouse button brings up the context menu: horizontal split, vertical split, etc. And you can swap, of course, between panes with the mouse.

This is much easier to remember than the various keyboard shortcuts.

Copy & pasting, however, can be a bit frustrating. I also use this in my .tmux.conf:

    # Ctrl+b then v to paste from tmux's clipboard
    bind-key -T prefix v paste-buffer -p

When Anders Hejlsberg did a lot of those talks to sell TypeScript, he described a lot of JavaScript as "stringly typed", which is very obvious with all the addEventListener("click", ...) and so on depending on certain strings. The term itself is not compliment, if you describe someone else's API as such, it's not well taken.

> Rust can not represent the vast majority of allocations

Do you mean cyclic types?

Rust being low-level, nobody prevents one from implementing garbage-collected types, and I've been looking into this myself: https://github.com/Manishearth/rust-gc

It's "Simple tracing (mark and sweep) garbage collector for Rust", which allows cyclic allocations with simple `Gc<Foo>` syntax. Can't vouch for that implementation, but something like this would be good for many cases.

I spent the last hour reading the release notes, very enjoyable as always. Since I'm not a game dev, I focus on random things. I keep checking their progress on meshlets (and occlusion culling) as I think it unlocks the ability to use highly complex geometry without penalty. This means it should allow amateurs to make very impressive-looking games by just obtaining meshes and materials. Now, of course, it requires a mountain of other things like GPU-driven rendering to make it actually happen. However, ever since I saw the nanite demo, I thought, if some FOSS engine has it, then the output should be very impressive.

I use KOReader with Koobo Clara BW (300 ppi screen), it's great.

I still have to remove a lot of CSS from most books before uploading, but after that, it is very good, as you can fine-tune every aspect and have every book look similar. Which, in my opinion, is necessary because e-ink readers still don't have enough resolution to use all the fancy fonts authors may have thought. Also, the ability to set margins to the same is very important to me.

This is what I would have liked too: Figure out a sufficient subset of TypeScript that can be compiled to native/WASM and then write TSC in that subset.

While I like faster TSC, I don't like that the TypeScript compiler needs to be written in another language to achieve speed; it kind of reminds everyone that TS isn't a good language for complicated CPU/IO tasks.

Given that the TypeScript team has resigned to the fact that JavaScript engines can't run the TypeScript compiler (TSC) sufficiently fast for foreseeable future and are rewriting it entirely in Go, then it is unlikely they will seek to do AOT.

One alternative is to use pglite [1] which is Postgres compiled to WASM. It can act as a sqlite replacement during development, then when you are ready to move to a server model your SQL is already in Postgres format.

[1]: https://pglite.dev/

I'm not being sarcastic, but we may soon have to torrent DeepSeek's model. OpenAI has a lot of clout in the US and could get DeepSeek banned in western countries for copyright.

Should they have launched crowdfunding right now?

I think this is the peak of interest in the new Pebble, especially with the announcement just being made. Maybe they don't need crowdfunding, which is great, but they still need buyers.

It is nice to see more ORMs, but inventing a new file format and language `toasty` isn't my cup of tea. I'd rather define the models in Rust and let the generator emit more Rust files.

Creating your own file format is always difficult. Now, you have to come up with syntax highlighting, refactoring support, go to definition, etc. When I prototype, I tend to rename a lot of my columns and move them around. That is when robust refactoring support, which the language's own LSP already provides, is beneficial, and this approach throws them all away.

Roc language can get away with using only Result because of its novel error handling. It will "infer" the error types for functions. Normally having a lot of error types is kind of cumbersome to handle, but inferring error types makes it easy to add safe error types, then why not replace all Options, etc with a single type as well?

If you are interested more there is a good YouTube from five months ago by Richard Feldman: https://www.youtube.com/watch?v=7R204VUlzGc error handling starts from 28 minutes, at 42 minutes you can see the inferred error types, which is very neat.

> It would be great if the SQLite team published an official npm package bundling the WASM version, could be a neat distribution mechanism for them.

I think they've been doing that for a while, in JS script you can already do this:

    import sqlite3InitModule from "https://cdn.jsdelivr.net/npm/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3-bundler-friendly.mjs";

    const sqlite3 = await sqlite3InitModule({
        locateFile(file: string) {
            return "https://cdn.jsdelivr.net/npm/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3.wasm";
        },
    });

    // SQLite's C API
    const capi = sqlite3.capi;
    console.log("sqlite3 version", capi.sqlite3_libversion(), capi.sqlite3_sourceid());

    // OO API example below oo1 docs https://sqlite.org/wasm/doc/tip/api-oo1.md
    const oo = sqlite3.oo1;

    const db = new oo.DB();
    const createPersonTableSql = `
    CREATE TABLE IF NOT EXISTS person (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        age INTEGER NOT NULL
    );
    `;
    db.exec([createPersonTableSql]);

It works in regular old script tag with type=module, or Deno. I have example HTML here:

https://github.com/Ciantic/experimenting-sqlite-wasm/blob/ma...

Yes, my experience as well. That's why having an alternate small display (8" or smaller) for your laptop/desktop is better. You can then drag any application on it and use it as a timer or busy sign or whatever. It's way more convenient than an extra device you have to reach and fiddle with.

Incidentally Bootstrap 5.3 seems to have the same problem as the article describes. There is a gap which doesn't do anything if clicked, right between the radio button and the label.

The utility of tracing is great, I've been using Azure Application Insights with NodeJS (and of course in .NET). This is relatively simple because it monkey patches itself everywhere if you go through the "classic" SDK route. Then adding your own data to logs is just a few simple functions trackTrace, trackException, trackEvent, etc.

However, if you want to figure out how it works you might be scared, it is not lightweight. I just spent a few days digging through the Azure Application Insights NodeJS code base which integrates with OpenTelemetry packages. It's an utter mess, a huge amount of abstractions. Adding it to the project brought 100 MB and around 40 extra packages.

Yes, I loved MIP models too. I'm really annoyed that the last Gramin Forerunner watch with an MIP display was 955, and it's now discontinued and was recently removed from Garmin's website. All their new models have OLED, and I kind of understand as it looks better indoors but wastes a huge amount of battery when used outside.

I would have preferred they investigate some of these newer LCD screens that can work reflectively and optionally with backlights on.

Here is one example from the PDF:

    FROM r JOIN s USING (id)
    |> WHERE r.c < 15
    |> AGGREGATE sum(r.e) AS s GROUP BY r.d
    |> WHERE s > 3
    |> ORDER BY d
    |> SELECT d, s, rank() OVER (order by d)

Can we call this SQL anymore after this? This re-ordering of things has been done by others too, like PRQL, but they didn't call it SQL. I do think it makes things more readable.

I started to listen to Bill Gates' interview [1], just to hear what he had in mind back then. Sounded almost topical in today's world. AI was mentioned, and predicting users' input in the distant future.

Side note, archive.org has two players. The first one doesn't have a timestamp where you currently are. The second player, the Winamp clone does have it, but I don't think one can link to specific parts.

[1] The Bill Gates interview starts at 10:10 https://archive.org/details/the-famous-computer-cafe-1984-11...