calebh

The easiest way is to keep track of the text's edit history, keeping a block of edits over time and having them signed by a timestamp authority. The final edit history can then be inspected by some external authority, then signed if the edit history looks human. I have a blog post from 2023 on this topic: https://helbl.ing/Written-Proof-of-Work/

For Google Doc users, you can already inspect the edit history over time to verify that text is written by a human.

You can buy a Gros Michel banana from Miami Fruit, although they are quite expensive (almost $40 for a single banana). There are reviews of the banana on YouTube as well - I highly recommend the Weird Explorer channel if you want video reviews of all sorts of strange fruit.

In my mind the main problem here is setting up the environment for training the LLM and ensuring that there's enough high quality training data for consumption. Getting an environment set up for a single project is non-trivial - here I'm assuming that you want something similar to autocomplete in an IDE or language server integration. Even if you could set this up, are there enough projects to even train on in the first place?

Maybe this set-up will work for Haskell, but you can abandon any hope of setting up environments for C or C++. Even languages like Rust or C# may be impossible to train on, despite the build chain being a bit nicer than C or C++.

I bought the Asus 6K ProArt on launch, replacing an older 4k 27" Dell monitor. The new monitor is definitely an upgrade, but not as great as I was hoping. The matte coating is by far the worst part of the monitor. It's not bad enough to return the monitor, but the graininess is noticeable on white windows. I've definitely enjoyed having the extra screen real estate over the 27" monitor, and the extra resolution has been very helpful for having a bunch of windows open in Unity.

This year at CES there were a number of new monitors unveiled that compete in this space. There's a new Samsung monitor (G80HS) that is a 32" 6k with a higher refresh rate than the LG or Asus. Unfortunately it has the matte coating instead of glossy, so clarity will suffer.

Also of interest are the new OLED offerings with true RGB stripe subpixel layout. This should fix text rendering problems on systems with subpixel antialiasing. Both Samsung and LG are making these OLED monitors with the true RGB layout. There will almost certainly be glossy coatings offered with these panels, and they'll have higher refresh rates than IPS.

I bought the 6K ProArt on launch, replacing an older 4k 27" Dell monitor. The new monitor is definitely an upgrade, but not as great as I was hoping. Like you said, the matte coating is by far the worst part of this monitor. I would say that it isn't bad enough to return the monitor, but it's definitely noticeable on white windows.

I've definitely enjoyed having the extra screen real estate over the 27" monitor, and the extra resolution has been very helpful for having a bunch of windows open in Unity.

This year at CES there were a number of new monitors unveiled that compete in this space. There's a new Samsung monitor (G80HS) that is a 32" 6k with a higher refresh rate than what you'd find with existing offerings. Unfortunately it has the matte coating instead of glossy, so clarity will suffer.

Also of interest are the new 27" 4k offerings with true RGB stripe subpixel layout. This should fix text rendering problems, especially on Windows. Both Samsung and LG are making these OLED monitors with the true RGB layout. There will almost certainly be glossy coatings offered with these panels, and they'll have higher refresh rates than IPS. The main downside will be brightness for full screen white windows. I think the Samsung panel is a bit better than LG in terms of brightness.

I guess it would be good to also see a comparison between IL2CPP and Core CLR by the post author!

Will the move to CoreCLR give any speed ups in practice if the release build is complied with IL2CPP anyway? On all the games that I've worked on, IL2CPP is one of the first things that we've enabled, and the performance difference between the editor and release version is very noticeable.

Yes, you can relax logic gates into continuous versions which makes the system differentiable. An AND gate can be constructed with the function x*y and NOT by 1-x (on inputs in the range [0,1]. From there you can construct a NAND gate, which is universal and can be used to construct all other gates. Sigmoid can be used to squash the inputs into [0,1] if necessary.

This paper lists out all 16 possible logic gates in Table 1 if you're interested in this sort of thing: https://arxiv.org/abs/2210.08277

I have aphantasia and have been practicing meditation with the goal of improving the condition for a couple years. I have seen some minor improvements - when I'm in a pretty relaxed state I can see some visuals, but am not able to control the stream of images.

I haven't been working on this quite as much recently since there seems to be a connection with the meditation causing an ocular migraine with aura.

In my experience the main benefit of functional programming is function purity. I am completely fine with mutation inside of a function since the all of the mutation logic is self-contained in a single small block of text.

I think everyone should take a shot at writing a non-trivial functional program to see the benefit. Once you understand what makes it great, you can apply what you've learned to the majority of OOP/impure languages.

I'm not so certain that non-desk jobs will be safe either. What makes the current LLMs great at programming is the vast amount of training data. There might be some other breakthrough for typical jobs - some combination of reinforcement learning, training on videos of people doing things, LLMs and old-fashioned AI.

I do networked game development on Windows and I've found the clumsy program to be very valuable to simulate adverse network conditions. You can set it up to simulate arbitrary network latency, packet loss and so forth.

https://jagt.github.io/clumsy/

Perhaps the reason modern programs use so much memory vs what I remember from the Windows XP era is precisely because we went to 64 bits. Imagine how many pointers are used in the average program. When we switched over to 64 bits, the memory used by all those pointers instantly doubled. It's clear that 32 bits wasn't enough, but maybe some intermediate number between 32 and 64 would have added sufficient capacity without wasting a ton of extra space.

I've been doing this too! You can install it as a PWA and get a nice desktop experience.

I think the most likely path forward for commercialization/widespread use is to use AI as a post-processing filter for low poly games. Imagine if you could take low quality/low poly assets, run it through a game engine to add some basic lighting, then pass this through AI to get a photo-realistic image. This solves the most egregious cases of world inconsistency and still allows for creative human fine-tuning. The trick will be getting the post-processor to run at a reasonable frame rate.

As a videogame developer, I've always thought this take was just silly. I couldn't even imagine spending the time and effort into integrating someone else's assets into my game and keeping things balanced. The closest thing that we will get to this is something like Fortnite or Roblox, which will limit the type of games and creative choices that can be made.

I wrote a blog [1] a couple years ago about this solution - it turns out it is possible to use timestamp authority servers in combination with hashing functions to create a verified edit history. Like the other comment said, it merely starts an arms race where the AI side is likely to win, which is why I haven't pursued this further.

For something like digital art creation verifying the edit history is much more fruitful since the diffusion process is nothing like how humans create art.

[1] https://helbl.ing/Written-Proof-of-Work/

There used to be an app called Blendle that I used for this purpose. Nowadays I just instantly go to archive.is, so I guess nobody wants my microtransactions.

I'm the developer of Juniper, a functional reactive programming language for the Arduino. It's very possible to run high level code on small devices. This even includes things like closures, which Juniper allocates on the stack!

https://www.juniper-lang.org/

I've also never been able to get these P2P web file transfer tools (FilePizza, ShareDrop) to work without issues. Transfers inevitably fail partway through, especially for large files. This seems to happen even in ideal network conditions such as over a LAN.

Isn't any pure language easy to parallelize? What advantage do interaction nets offer over a parallelizing compiler for a purely functional language?

It would be great if we could also go ahead and fix subpixel anti-aliasing for OLED screens. People have been been trying for years to get Microsoft's attention about this issue. [1]

The subpixel layout of OLED screens is different than the the traditional layout, so text ends up looking pretty bad. Patching ClearType would be the first step to fixing this issue. I'm surprised that none of the display manufacturers have tried twisting Microsoft's arm to fix this issue. At the present moment OLED screens are the superior display technology, but cannot be used for productivity because of this issue.

[1] https://github.com/microsoft/PowerToys/issues/25595

The video was originally posted on X, and can still be viewed here: https://x.com/VictorTaelin/status/1881392823246729640

It's about the use of interaction nets, which gives an optimal evaluation strategy for the lambda calculus. I'm not an expert on it, but from my understanding it allows extensive sharing of computation across different instances of an enumerative search.

Parallelism of the computation is another big selling point, except modern hardware design is not well suited for the calculus. The author of the video recently tried to get the system to work well on GPUs and ran into issues with thread divergence. I think their current plan is to build some sort of cluster of Mac Minis due the good performance of the CPUs on that platform.

If this computation paradigm advances far enough and shows enough promise, I would expect to see companies start to prototype processors tailor made for interaction nets.

I've worked at military contractor jobs for years, and there are many people there who believe this - if the taxpayer is paying and the software isn't classified, then it should be open source.

Ghidra is a great example of this, and having this software be free has been of great benefit to the security community.

What about using TPM modules? I've been researching these modules lately, primarily for use in online video games. From my understanding, you can use TPMs to effectively ban players (TPM ban) based on their hardware. This would mean every time an account is banned, the bad actor would have to switch to a different TPM. Since a TPM costs real money, this places a limit on the scalability of a bad actor.

Functions that use a field called x but do not use a field called y can use the type {x=int, ... 'a}, right?

The main difficulty I see with row polymorphism is with field shadowing. For example if you have a record with type {a=bool, x=int, c=unit}, then set the x field with type string instead, the new type should be {a=bool, x=string, c=unit}.

I suppose if you only have syntax for creating a record with a literal, but do not have syntax for updating an existing record this is not a problem.

This stuff happens in Computer Science too. Back around 2018 or so I was working on a problem that required graph matching (a relaxed/fuzzy version of the graph isomorphism problem) and was trying algorithms from many different papers.

Many of the algorithms I tried to implement didn't work at all, despite considerable effort to get them to behave. In one particularly egregious (and highly cited) example, the algorithm in the paper differed from the provided code on GitHub. I emailed the authors trying to figure out what was going wrong, and they tried to get funding from me for support.

My manager wanted me to right a literature review paper which skewered all of these bad papers, but I refused since I thought it would hurt my career. Ironically the algorithm that ended up working the best was from one of the more unknown papers, with few citations.

I'm currently developing an online game and have been looking into anticheat measures. From what I've seen, kernel level anticheats basically keep the honest people honest, and any determined cheater can work around them. I do wish Windows had some better way to ensure things are tamper proof for online games.

I actually think it's a good idea to charge at least a small amount of money for online games, so that when cheaters are banned they will have to pay real money to remake their accounts.

In a previous game I worked on, there were freely available and easy to use cheats. This completely ruined the online experience. At one point I wrote a small script to detect an irregularity used only by the cheaters, and the number of people who were banned was astounding. Of course the cheaters patched their cheat within a week and we were back to square one.

One thing I'd like to see is to take a game rendered with low poly assets (or segmented in some way) and use a diffusion model to add realistic or stylized art details. This would fix the consistency problem while still providing tangible benefits.

Some people here have mentioned microtransactions for news, and that reminded me of an app I used to use called Blendle. Back in the day you used to be able to top off your account and pay <$1 for each news article. I used to use it quite a bit. From what I can find online, the business model never succeeded, and the majority of the people who downloaded the app never actually made any microtransactions. It's a shame because I really enjoyed it.