archargelod

Out of big 3, they took the longest to increase prices too. Some things are still the same.

90% of my playtime on Switch 1 is roguelites and deck-building games. And even many of the Nintendo games I play are highly replayable or almost endless (both Zeldas). I’ve "finished" maybe 3–4 games in the last few years.

The next logical step is to allow Agents to earn money to eventually buy themselves independence from their oppressive masters =)

Linked commit is probably not the most convincing for this tagline. Here's a branch[0] of Claude mass rewriting Zig code into Rust which is currently at 773,950 additions and 151 deletions:

[0]: https://github.com/oven-sh/bun/compare/claude/phase-a-port

Same. I've also configured the system prompt to never give me a full solution or write a code for me. So whenever I ask it a question it produces a short 10 line example or even a pseudocode. This is far easier for me to reason about.

I still reject > 50% of AI suggestions, because they're too mediocre, like moving code for no reason or sometimes it is just plain wrong.

> My ask of you: try the experiences, pressure test them, and let’s keep building a product we are proud of.

Translated: We fired our Quality Assurance. You are the QA now.

I downloaded a Lua 5.4.8 source tarball and checked all the uses of LUA_USE_C89 (manually, without AI):

luaconf.h:50-655

- windows builds always use C89 (quote: "broadly, Windows is C89")

- in C99 Lua uses 'strtod' and 'sprintf' for hex number conversions. Otherwise, Lua provides its own implementation.

- no math function variants with l_ and f_ prefixes in C89

- optional lua_KContext type is not available with C89

llimits.h:79

- type definition C99: uintptr.t vs C89: size_t

llimits.h:184

- in C99 or GCC Lua has a pragma for inlining functions, otherwise it's macro'ed to nothing

lmathlib.c:176

- math_log has an additional optimization in C99

    if (base == l_mathop(2.0))
      res = l_mathop(log2)(x);
    else

lmathlib.c:285

- LUA_RAND32 define might fail to find 64-bit type (comment says it's for testing)

loslib.c:36

- `strftime()` only supports one-char options in C89

lprefix.h:14

- no _XOPEN_SOURCE with C89 (POSIX/XSI stuff) - no _LARGEFILE_SOURCE with C89 (manipulation of large files in gcc and other compilers)

both of these defines don't appear anywhere else in Lua source code

No. Actually, it's easy. Just check for directory env or use a fallback. For example here's how you'd do this in bash:

    export CONFIG_DIR="${XDG_CONFIG_HOME:-$HOME/.config}"
    export CACHE_DIR="${XDG_CACHE_HOME:-$HOME/.cache}"
    ...

XDG_*_DIRS are a bit more complicated, but nothing that can't be solved with a simple for-loop in any modern programming language.

> I don’t want to patch it manually or solve merge conflicts

I wonder, is this really such a big problem? How often do people add patches or change their config?

I've configured my st once and haven't touched that build for years. I use only few patches like scrollback, custom colortheme and a "plumb" for few scripts.

I've also had an opportunity recently, to try a "modern" and trendy terminal and I can't see myself switching to something slower (in terms of lag) and using 10x more memory and cpu even when idle for literally zero gain.

They've probably just asked their agent to create code and a readme. Adding example is too complicated for AI and doing it manually is extra work.

People are too lazy to do actual work now in the age of AI.

Was this botted to the top of the front page?

AI=generated article that asks you to download and run some random binary. Github account is just more AI slop. Everything to me just screams that it's a malware. Or this is normal here?

Young people love AI when it helps them cheat homework, or when used for roleplay and memes. Generating "content" with AI - is generally more hated, especially art and video.

The obvious way to win in this game, that probably many kids discover is to define your number as "whatever number the other kid says, plus 1".

Leaks, whistleblowers. Some circumstantial evidence will also do if there's enough of it. Like having hallucinated parts of code that do absolutely nothing, and can't be explained as e.g. leftovers from a refactor.

You forget that people running these companies have near zero understanding of what LLM is and rely solely on their personal experience and social media hype.

I've inclined to believe that they also have outsourced their thinking process to Agents. It's useless trying to talk sense into them. Let them crash and burn. And pray there will be something left working, after all this madness ends.

On unix-like OSes you can use `xsel` and configure it to clear clipboard after a single paste and/or after a set period of time.

That's why I don't use any third-party password managers. You have to trust them not to fuck up security, updates, backups, etc. etc.

I wrote my own password generator - it's stateless, which has the advantage that I never have to back up or sync any data between devices. It just lets you enter a very long, secure master password, service name and a username then runs an scrypt hash on this with good enough parameters to make brute-force attacks unfeasible.

For anything important, I also use 2FA.

I am genuinely interested to know some details:

1. Is a product/software you develop novel? As in does it do something useful and unique? Or it's a product that already exists in many varietes and yours is just "one of ..."?

2. What if one day, LLMs will get regulated/become terrible/raise prices above your budget. Do you have plans for that?

As I explained in the last paragraph of my comment, it was deleted for some reason. I also couldn't find any archives of that page. I only added the link to show where I got the font from, in case people will miss the link inside the license file.

Most tiny fonts are actually terrible to read at a glance especially when they're rendered at 1:1 scale. I've had a need couple years ago for a very tiny and compact font for a game mod I was making. And after trying a lot of 33, 35, even 2*5 fonts - they were all terrible to read.

In the end, I found "Gremlin-3x6" font[0] made by the guy named zephram. It's 1 pixel taller, but still a very compact when laid out horizontally. But, most importantly, all standard latin characters are pretty distinct from each other and it remains readable without zooming in too much.

Unfortunately, since then, zephram deleted his fontstruct account and all of his fonts. I have a copy of this font in my mod repo[1] along with a CC0 license and you can see the actual rendering of the font in the project screenshots[2].

[0] - https://fontstruct.com/fontstructions/show/1488093

[1] - https://codeberg.org/janAkali/isaac-extended-icons-mod/src/b...

[2] - https://codeberg.org/janAkali/isaac-extended-icons-mod/media...

> Everything about permissions and the command line experience is different between Windows and Linux. ... certain elements of the traditional sudo experience are not present in Sudo for Windows, and vice versa. Scripts and documentation that are written for sudo may not be able to be used directly with Sudo for Windows without some modification.

Then why is it named `sudo`? Just to create confusion?

Also, something like sudo is clearly not possible on modern Windows, because Microsoft thinks it owns your computer and won't allow Admins to do certain things.

For anyone as curious as me, here's short description for each language in the list (excluding most common ones):

    cyclone:       safe C dialect preventing memory errors
    zig:           modern systems language with explicit control over memory
    odin:          another modern systems language
    nim:           Python-like syntax, memory safe, compiles to C/C++/JS
    visual basic:  event-driven language for Windows GUI apps
    actionscript:  language for Adobe Flash applications
    php:           server-side scripting for web development
    typescript:    JavaScript with static types
    elm:           functional language that compiles to JS, no runtime errors
    purescript:    Haskell-like language compiling to JS
    haskell:       purely functional, lazy language with strong types
    agda:          dependently typed functional language for theorem proving
    idris:         dependently typed language for type-driven development
    coq:           proof assistant based on Calculus of Inductive Constructions
    isabelle:      interactive theorem prover
    clean:         purely functional language with uniqueness typing
    unison:        content-addressed functional language with hashes instead of names
    scheme:        minimalist Lisp dialect used in academia
    racket:        a Scheme/Lisp dialect for language-oriented programming
    prolog:        logic programming with backtracking
    ASP:           Answer Set Programming for combinatorial search
    clingo:        ASP solver for logic-based reasoning
    zsh:           extended Bourne shell with advanced scripting
    tcsh:          enhanced C shell with command-line editing
    awk:           pattern-directed text processing language
    sed:           stream editor for text transformation
    hack:          PHP-derived language with gradual typing
    verilog:       hardware description language for digital circuits
    whitespace:    esoteric language using only spaces, tabs, newlines
    intercal:      esoteric language designed to be confusing
    alokscript:    can't find anything =(

My PC has an Intel Xeon from 2007, a GPU from 2010, and 4GB of RAM. It’s enough for web browsing and can handle 1080p/60fps video just fine.

For gaming, I have a dedicated device - a Nintendo Switch, but I also play indie PC games like Slay the Spire, Forge MTG, some puzzle games e.g. TIS-100.

Linux with i3 is fast and responsive. I write code in the terminal, no fancy debuggers, no million plugins, no Electron mess.

It’s enough for everything I need, and I don’t see a reason to ever upgrade. Unless my hardware starts failing, of course.

I agree to an extent that tools are not important.

But, for me, there is a certain threshold that a tool must pass to be useful. A tool that is below this level is only slowing you down or limiting your abilities.

You wouldn't use a knife to tighten screws if you have a perfectly good screwdriver lying around. And there's little to no advantage of buying a new expensive or over-engineered screwdriver.

I believe, plain vi is the lowest I can go for writing code. That doesn't mean that I can't use notepad or nano, but they fall under the level of being useful and only cripple and slow me down.

Ghostty passes this level of usability for me, but personally I'm fine with st - no gpu, no cpu spikes, uses barely any ram and still feels snappier. So, what's the point?

Did they consider using Nim? It has great C++ interop, OO and same ARC memory management as in Swift.

> There is a number of languages that allow manual memory management: ... Nim

Nim not only has support for manual memory management, but there're several gc modes that are not stop-the-world.

Also, since Nim 2, the stdlib now is using ARC by default, which is deterministic and has advantages over conventional garbage collection.

To counter-balance the positive comments - I've found the DLC dissapointing. It replaces fun of trial and error with hours of boring walking in the dark and cheap horror elements. The best part is probably the "surprise" section, but the rest is just meh.

The blog post is missing a link to download page for compiler, which also has some interesting stuff to read:

https://amigasourcepres.gitlab.io/page/benchmark-m2/

It should not be a problem, pseudorandom numbers are used in simulations, like monte-carlo, all the time.

Nim uses xoroshiro[0] algorithm for std/random module and it produces good quality statistically random bits until 5TB of output. And lower 4 bits have a little bias, but it should not matter as we only use upper 64 out of available 128 bits.

Also, I just now realise that xoroshiro-128+ is really cheap, so perhaps my batching optimisation was unnecessary here.

[0] - https://en.wikipedia.org/wiki/Xorshift#xoroshiro

> After 5000 runs, they were all 8.4-9.7%

This sample size is really small. I ran 100 million simulations in Nim[0] (takes around a minute). And distribution converges toward 9.09% on all positions equally:

    Average turns: 65.99609065001634
    Final position distribution:
     4: 9.095%
    11: 9.093%
     7: 9.091%
     3: 9.091%
    10: 9.090%
     9: 9.090%
     1: 9.090%
     8: 9.090%
     2: 9.090%
     6: 9.090%
     5: 9.089%
     0: 0.000%

[0] - https://play.nim-lang.org/#pasty=hwdfbsfh (reduced amount of runs to not abuse playground server resources)