grumbel

There is '-Wconversion' to catch things like this. It will however not trigger in this specific case since g++ assumes converting 1000.0 to 1000 is ok due to no loss in precision.

Quantity(100) is counterproductive here, as that doesn't narrow the type, it does the opposite, it casts whatever value is given to the type, so even Quantity(100.5) will still work, while just plain 100.5 would have given an error with '-Wconversion'.

I'd be more impressed if they'd used a hyperlink. But that's apparently forbidden in modern journalism.

That requires having an account on the other machine. What's missing is anonymous scp, where the other side just opens up a directory, and you can copy into it. One can build something like this with rsyncd, but it's not a pretty shell one-liner to get it going and it still requires both devices to be on the same network.

Money alone wouldn't fix this, as a Web where every page has a paywall wouldn't be much better either. Which in turn would concentrate most of the Web in a few services just as it is today and enshittyfication would bring the ads back sooner or later, even if you pay for the service.

Give every Internet user a domain name and routable IP for free with their Internet account.

That won't magically fix all the problems in an instant, but the core of everything wrong with the Internet starts with the Internet being separated into consumers and providers, instead of being a true peer2peer network.

Even in the olden days of the Internet when ISPs would give you free webspace with your Internet account, you still didn't get your own domain name, meaning all your Web presence would bust when you switched providers.

Alternatively, get Freenet, IPFS/IPNS or any of the other distributed alternatives working, but after 25 years of people trying, I kind of given up hope of it ever happening.

Not much. A horizontal split (C-x 2) can be quite useful to keep the top of a file in view while editing around at the bottom of a file. A vertical split (C-x 3) is useful when comparing files side by side. But that's about as far as I go, beyond that it just becomes annoying, as popups like from magit will show up in random subwindows, often rendering them unusable, due to that subwindow not being big enough.

Yes: https://en.wikipedia.org/wiki/Brian_Dunning_(author)#Wire_fr...

Ignoring AI would be foolish, since AI is the best programming tutor you can wish for and will speed up your learning noticeably, since you can always ask for clarification or examples when something isn't clear. It's also a great way to get random data for testing. And it will help you unearth lesser known corners of a programming language that you might have overlooked otherwise.

The downside is that at the current speed of improvement, AI might very well already be at escape velocity, where it improves faster than you, and you'll never be able to catch up and contribute anything useful. For a lot of small hobby projects, that's already the case.

I don't think there are any easy answers here. Nothing wrong with learning to code because it's fun. But as a career choice, it might not have a lot of future, but then, neither might most other white-collar jobs. Weird times are ahead of us.

In Linux/Xorg with a compose/multi-key one can do:

<Multi_key> <minus> <minus> <period> : "–" U2013 # EN DASH

<Multi_key> <minus> <minus> <minus> : "—" U2014 # EM DASH

More in /usr/share/X11/locale/en_US.UTF-8/Compose

> They are, indeed, calculators.

And that's relevant exactly how? Do you think "thought and expression" are somehow uncomputable? Please throw science at that and collect your Nobel prize.

That's only a "problem" if you assume human exceptionalism and begging the question. It's completely irrelevant to the actual problem. The human is just a cog in the machine, there is no reason to assume they would ever gain any understanding, as they are not the entity that is generating Chinese.

To make it a little easier to understand:

* go read about the x86 instruction

* take an .exe file

* manually execute it with pen&paper

Do you think you understand what the .exe does? Do you think understanding the .exe is required to execute it?

Define "intentions" and "understand" in a way that is testable. All you are doing here is employing intuition pumps without actually saying anything.

> LLMs are language calculators.

And humans are just chemical reactions. That's completely irrelevant to the topic, as both can still act as Universal Turing machine just the same.

See System Reply, the Chinese Room is a pseudo problem begging the question rooted in nothing more than human exceptionalism. If you start with the assumption that humans are the only thing in the universe able to "understand" (whatever that means), then of course the room can't understand (except for every reasonable definition of "understanding" it does).

> LLMs are token predictors. That's all they do.

That's a disingenuous statement, since it implies there is a limit to what LLMs can do, when in reality an LLM is just a form of Universal Turing Machine[1] that can compute everything that is commutable. The "all they do" is literately everything we know to be doable.

[1] Memory limits do apply as with any other form of real world computation.

As other have mentioned, this models just puts emphasis on pixels and compression artifacts, so it's of not much use for improving old or low quality images.

I tried doing some pixelart->HD conversion with Gemini2.0Flash instead and the results look quite promising:

* https://imgur.com/a/t9F94F1

The images are however all over the place, as it doesn't seem to stick very close to the prompt. Trying to fine tune the image with further chatting often leads to overexposed looking pictures.

All the results are done with prompts along the lines of "here is a pixelart image convert it into a photo" or some variation there of. No img2img, LoRA or anything here, all plain Gemini chat.

While I don't disagree with that observation, it falls into the "well, duh!"-category for me. The models are build with no mechanism for long term memory and thus suck at tasks that require long term memory. There is nothing surprising here. There was never any expectation that LLMs magically develop long term memory, as that's impossible given the architecture. They predict the next word and once the old text moves out of the context window, it's gone. The models neither learn as they work nor can they remember the past.

It's not even like humans are all that different here. Strip a human of their tools (pen&paper, keyboard, monitor, etc.) and have them try solving problems with nothing but the power of their brain and they'll struggle a hell of a lot too, since our memory ain't exactly perfect either. We don't have perfect recall, we look things up when we need to, a large part of our "memory" is out there in the world around us, not in our head.

The open question is how to move forward. But calling AI progress a dead end before we even started exploring long term memory, tool use and on-the-fly learning is a tad little premature. It's like calling quits on the development of the car before you put the wheels on.

The problem with FOSS isn't a lack of politics (they have plenty of that), but tunnel vision focus on software, when everything that is going wrong with the modern Internet is based around data (who stores it, who controls it, who can access it, who pays for it, ...).

One would expect something like the similar to the GDPR to grow out of the FOSS movement, but it didn't. The FOSS movement still has nothing similar on offer. Handling of data remains a complete blind spot for the movement.

It's not even a "one-time disable", it's off by default until you enable it and the icon in the URL takes two clicks to hide.

And more generally, lack of easy payment is at the root of so many problems with the modern Internet, that I really can't blame Brave for trying this, quite the opposite, that's exactly the kind of feature we need.

I don't think the probabilistic prediction is a problem. The problem with current LLM is that they are limited to doing "System 1" thinking, only giving you a fast instinctive response to a question. While that works great for a lot of small problems, it completely falls apart on any larger task that requires multiple steps or backtracking. "System 2" thinking is completely missing as is the ability to just self-iterate on their own output.

Reasoning models are trying to address that now, but monologueing in token-space still feels more like a hack than a real solution, but it does improve their performance a good bit nonetheless.

In practical terms all this means is that current LLMs still need a hell of a lot of hand holding and fail at anything more complex, even if their "System 1" thinking is good enough for the task (e.g. they can write Tetris in 30sec no problem, but they can't write SuperMarioBros at all, since that has numerous levels that would blow the context window size).

Plenty of software has been developed on the command line, chat is just a more powerful and flexible version of that. The missing part with current AI systems is a persistent workspace/filesystem that allows you to store things you want to keep, discard things you want to get rid off and highlight things you want to focus on.

> whether old games were intended to be seen on CRTs, or intended to be seen on LCD screens created years later.

A lot of older games were designed on grid paper or workstations, not on the consoles or homecomputer that were running them later on. Just look at all the NES and SNES games with broken aspect ratio (i.e. circles not being round), that's not rare outliers, but like half of the library.

Also the CRT vs LCD comparison are extremely disingenuous to begin with, since you are not supposed to be so f'n close to the TV to begin with. If you watch a game at its intended viewing distance and screen size your eyeballs will smooth out the LCD picture just the same as they would a CRT. If you sit close enough to see the shadow mask of your CRT, you are using it wrong.

While I agree that the pixel-art look is drastically overdone in modern retro games, it's not like it didn't exist back in the day. Most old hardware had sprite or layer scaling that allowed you to enlarge the image. The Pokemon in the battle screen on GameBoy for example are all heavily pixelated, so are many SNES games that make use of Mode7 or the enemy sprites in games like AstroBot on GBA. Meanwhile most of the C64 library uses a mode that requires pixels be twice as wide as tall, which also makes everything look blocky.

In PC gaming most of this didn't matter to begin with, since the monitors where capable of far sharper and higher resolution images than your average TV, much like a LCDs, while most of the early games where still doing 320x200. So things did end up look blocky even on original hardware.

That's not to say that CRTs don't have benefits, the motion clarity is much better than sample-and-hold/full-persistance LCDs and LCD scaling gets incredible ugly when it's not a integer multiple of the original resolution and colors/vibrancy of early LCD was also horrible. But most of those are slowly going away with black-frame insertion, 4k resolution and HDR.

And yes, sometimes you come across a Sonic waterfall that is designed to specifically take advantage of CRT TVs, but those effects are pretty rare.

The directly support you get with HTTP is rather terrible. It works ok for a human browsing a directory manually, but if you want to actually download one it becomes a mess, since you can't tell if "index.html" is a file or just something Apache generated on the fly. There is no "list directory" command in HTTP (there is PROPFIND in WebDAV) and there is no "download directory" in your browser, you have to fiddle with wget and friends.

It's one of the things I love about IPFS, it has native directories along with fuse services, so you can just `cd /ipfs/...` and browse around. That has a lot of beautiful side effects in that you no longer need .zip to package directories and for a lot of things you no longer even need to download anything, you just access them directly via your file system.

Especially with FTP being removed from browsers, we could really need a proper official successor that can act as an online file system.

The issue with composition is only a problem when you rely on a pure text prompt, but has been solved for quite a while by ControlNets or img2img. What was lacking was the integration with existing art tools, but even that is getting solved, e.g. Krita[1] has a pretty nice AI plugin.

3D can be a useful intermediate when editing the 2D image, e.g. Krea has support for that[2]. But I don't think the rest of the traditional 3D pipeline is of much use here, AI image generation already produces images at a quality that traditional rendering just can't keep up with, neither in terms of speed, quality or flexibility.

[1] https://www.youtube.com/watch?v=PPxOE9YH57E

[2] https://www.youtube.com/watch?v=0ER5qfoJXd0

The part that is especially annoying there is that it's not just about speed, but about AI tools being closely tied to a specific architecture. Lots of them only work on Nvidia cards, but not on AMD. A fallback to CPU is often not provided either. If you don't have enough VRAM a lot of them won't work at all, not just run slower.

Mozilla had half a billion dollars each year to work with, I am sure they could have figured something out if they cared. But hey, instead of fixing some HTML tags lets reinvent a completely new format and require every singe website on the planet to adopt that, that'll sure work out well...

I am not talking about RSS, I am talking about plain old bookmarks. Browser never would give you notification when something you bookmarked changed.

The RSS feature was always kind of useless, since it required that the website provided a RSS feed to begin with, which most don't. The implementation in Firefox was also horrible on top.

HTML is a markup language, with header, datetime and article tags, parse that and do something useful with it, we don't need yet another format that duplicates the information that is already on the website.

If RSS could solve the problem it would have done so a decade ago.

The core issue is that browsers have completely failed at offering anything to keep track of websites. Why aren't notifications simply build into the bookmark system? I don't need the website to provide that information via yet another special format, my browser should be able to figure that out itself from plain .html. But bookmarks haven't changed one bit in about 30 years, instead we moved that functionality server-side for no reason.

At 1:02 it shows the optical mouse sensor pretty clearly.

Crossing is easier because you can simply hold your finger in front of your eyes and look at that for practice.

Diverging requires you to look past the image, meaning you have nothing to really look at, which makes it difficult to figure out what your eyes are even supposed to do.

Those stereograms aren't helping much either, since they look like nothing until you get it right. With cross-eye you have instant double-vision that you just need to align.

Cross-eye also works across much larger distances, diverging fails when the images are too far apart.

It's not a hard concept, but it is a stupid one. Phone numbers for example you can take with you when you switch providers. Email has the provider hardcoded into your email address, thus every new provider means you have a new email.

The Web still lacks a first-class concept of a user identify that you can take with you across servers.