I’ve been researching programming languages to find a good, high level language that compiles to a single binary that is preferably pretty small. After tons of research, I landed on Nim and used it to make a quick txt parser for a project I’m doing.

Nim seems absolutely fantastic. Despite being sold as a systems programming language, it feels like Python without any of its drawbacks (it’s fast, statically typed, etc.) - and the text parser I made is only a 50kb binary!

Has anyone here tried Nim? What’s your experience with it? Are there any hidden downsides aside from being kinda unpopular?

Bonus: I want to give a shoutout to how easy it is to open a text file and parse it line-by-line in this language. Look at how simple and elegant this syntax is:

import os

if paramCount() == 0:
  quit("No file given as argument", 1)

let filepath = paramStr(1)

if not fileExists(filepath):
  quit("File not found: " & filepath, 1)

for line in lines(filepath):
  echo line
  • FizzyOrange@programming.dev
    9·
    2 days ago

    I just use Rust for this. You can make the binaries fairly small if you put a bit of effort in. Plus it’s not a niche language, and you get the benefit of a huge community. And your code is pretty much fast by default.

    The only real downside is the compilation time, which is a lot better than it used to be but still isn’t great.

    • communism@lemmy.ml
      5·
      2 days ago

      Yeah tbh I’m not sure what the reason for using a systems programming language other than either Rust or C would be. Rust by default for safety (and it’s as performant as any other systems language), C if you either need to work with an existing C codebase or want to be able to more easily do unsafe stuff. Or if you need to compile quickly. I’m sure the other languages have their benefits but not to the extent where I would both want to learn it and have use cases for it where I would choose that language over Rust or C for a project.

      • msa@mastodon.sdf.org
        91·
        2 days ago

        @communism @FizzyOrange Sometimes you want modern features and safety without the headache that is writing Rust. Rust is a complicated language. I just want something simple without a million footguns.

        • FizzyOrange@programming.dev
          41·
          2 days ago

          Rust is fairly well known for not having footguns (except async Rust at least) and for not being a headache.

          I guess it can be more complex than something like Python or Typescript though. I would say that extra complexity is not a big deal compared to the pain you’ll have to deal with working with a language as niche as Nim though.

              • TehPers@beehaw.orgEnglish
                2·
                2 days ago

                uv is love. uv is life.

                I’m still trying to get people at work to use it. It’s one of the few tools out there that takes Python from intolerable spaghetti to readable and maintainable.

                  • TehPers@beehaw.orgEnglish
                    1·
                    2 days ago

                    conda isn’t much of an alternative to pip. It’s more of an alternative to venv. Unless you’re referring to conda’s dependency management, which I’ve admittedly never used.

                    And until pip uninstall foo uninstalls unused transitive dependencies too, you’ll have to drag me back.

        • communism@lemmy.ml
          2·
          2 days ago

          I’m not really sure what people mean by Rust being a headache/weird/hard/etc honestly. It was a learning curve but nothing crazy, and I’ve come to really like the ways Rust works—it makes my life way easier in the long run to be able to solve problems at compile time so I don’t have to debug undefined behaviour at runtime. But to each their own of course—if another language works for you then it works for you.

      • sus@programming.dev
        1·
        2 days ago

        Nim is more “high level, automatic memory management by default, but you can go 100% manual if you need to”, though the reality of doing that is basically the opposite of rust’s “everything you need to do is well-documented and solid”