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 =(

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.

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?

Comments URL: https://news.ycombinator.com/item?id=47013566

Points: 5

# Comments: 1

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.

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

Comments URL: https://news.ycombinator.com/item?id=46791836

Points: 6

# Comments: 2

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

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%

And to my surprise, the latest 32-bit release of Nim simply works out the box. But Nim compiles to C, so I also needed C compiler. Many versions of mingw I could find online - they all failed to launch.

After some time I managed to find very old Mingw (gcc 4.7.1) that have finally worked [1].

[0] - https://nim-lang.org/

[1] - https://ibb.co/TBdvZPVt

Nim has good support for Clang, so it works by just switching a single flag: `nim c --cc:clang main.nim`

For zigcc - there is a wrapper package you can install with nimble: `nimble install zigcc`

Then you can use it with: `nim c --cc:clang --clang.exe=zigcc --linker.exe=zigcc main.nim`

Of course, you can save the flags in configuration files. You can look at my setup for inspiration [0].

[0] - https://codeberg.org/janAkali/grabnim/src/branch/master/conf...

Nim is a full, independent modern language that uses C as one of its backends. It has its own runtime, optional GC, Unicode strings, bounds checking, and a huge stdlib. You write high-level Nim code and it spits out optimized C you usually don't touch.

Here’s a little comparison I put together from what I can find in the readme and code:

    Comparison          ZenC           Nim
    
    written in          C              Self-Hosted
    targets             C              C, C++, ObjC, JS, LLVM (via nlvm), Native (in-progress)
    platforms           POSIX          Linux, Windows, MacOS, POSIX, baremetal
    mm strategy         manual/RAII    ARC, ORC(ARC with cycle collector), multiple gc, manual
    generated code      human-readable optimized
    mangling            no             yes
    
    stdlib              bare           extensive/batteries-included
    
    compile-time code   yes            yes
    macros              comptime?      AST manipulation
    
    arrays              C arrays       type and size is retained at all times
    strings             C strings      have capacity and length, support Unicode
    bounds-checking     no             yes (optional)

Sure, Void doesn't have the endless options of Arch+AUR for packages, but it had everything I needed. Even the well-maintained, latest versions of less common software, like Nim compiler.

The author might also missed that Void has a non-free repository, that you have to install for stuff like proprietary drivers, DRM and Steam.

    zmodload zsh/zprof
    .. rest of your zsh config ..
    zprof

It's just a handful of files and I manually source them in my zshrc[2]:

    source $ZSH/lib/async_prompt.zsh
    source $ZSH/lib/key-bindings.zsh
    source $ZSH/lib/completion.zsh
    source $ZSH/lib/history.zsh
    source $ZSH/lib/git.zsh
    source $ZSH/lib/theme-and-appearance.zsh

It also fixed another issue I had with Oh-My-Zsh: whenever they (very rarely) tweak their default config - it breaks my muscle memory.

[1] https://codeberg.org/janAkali/dotfiles/src/branch/main/confi...

[2] https://codeberg.org/janAkali/dotfiles/src/branch/main/zshrc

https://nim-lang.org

I don't see these flags in Nim compilation config. The only extra option used is "-march=native"[0].

[0] https://github.com/niklas-heer/speed-comparison/blob/9681e8e...

It’s mainly for personal use because converting, renaming, and packing mods in bulk can be very tedious. Especially if you're always changing your mod list (which is a given).

However, once I make it more user-friendly and add a proper GUI, I’ll likely release it to the public.