22 ms·

Ask HN: What less-popular systems programming language are you using?

• Jtsummers 2y ago
  Not presently, but not long ago, Fortran and Ada. I still like Ada better than the alternatives, especially as it's changed this past couple decades. I find it hard to miss Fortran, though. I'd consider it for scientific computing and that's about it, which isn't my present domain.
  • fuzztester 2y ago
    Interesting, thanks. Did you ever check out Eiffel for systems programming work? I had been checking it out some years ago, and apart from the general points about it, one use of it that I found interesting was in an article about using it for creating HP printer drivers. The author had mentioned some concrete benefits that they found from using it for that purpose. Edit: I searched for that article, and found it: Eiffel for embedded systems at Hewlett-Packard: https://archive.eiffel.com/eiffel/projects/hp/creel.html https://archive.eiffel.com/eiffel/projects/hp/creel.html
    • Jtsummers 2y ago
      I learned it once long ago, but never used it for anything other than that learning experience. I did like its concepts, though the language itself didn't quite stick with me.
  • quanto 2y ago
    How would Fortran be used other than numerics/scientific computing?
    • Jtsummers 2y ago
      This was in an embedded systems context, I came on later but it was what most of the core system was written in. It's been used in a lot of avionics systems over the years.
    • fuzztester 2y ago
      not a direct answer to your question, but the use in the domain you mentioned itself, is huge. from the Wikipedia article about Fortran, under the Science and Engineering section: https://en.m.wikipedia.org/wiki/Fortran https://en.m.wikipedia.org/wiki/Fortran Although a 1968 journal article by the authors of BASIC already described FORTRAN as "old-fashioned",[58] programs have been written in Fortran for many decades and there is a vast body of Fortran software in daily use throughout the scientific and engineering communities.[59] Jay Pasachoff wrote in 1984 that "physics and astronomy students simply have to learn FORTRAN. So much exists in FORTRAN that it seems unlikely that scientists will change to Pascal, Modula-2, or whatever."[60] In 1993, Cecil E. Leith called FORTRAN the "mother tongue of scientific computing", adding that its replacement by any other possible language "may remain a forlorn hope".[61] It is the primary language for some of the most intensive super-computing tasks, such as in astronomy, climate modeling, computational chemistry, computational economics, computational fluid dynamics, computational physics, data analysis,[62] hydrological modeling, numerical linear algebra and numerical libraries (LAPACK, IMSL and NAG), optimization, satellite simulation, structural engineering, and weather prediction.[63] Many of the floating-point benchmarks to gauge the performance of new computer processors, such as the floating-point components of the SPEC benchmarks (e.g., CFP2006, CFP2017) are written in Fortran. Math algorithms are well documented in Numerical Recipes.
      • wglb 2y ago
        > described FORTRAN as "old-fashioned" That didn't age well. My professor working on control system analysis for electrical power grids later thought that if he were to write it today, it would likely be done in matlab.
    • AlexeyBrin 2y ago
      Modern Fortran has ISO C bindings in its standard library. You can call any C library from Fortran and wrap it in a Fortran module if you want to make it easier to use. Despite its history it is a pretty modern language if you enable all warnings, set implicit none and ignore the old style of coding (a la FORTRAN 77 of older).
• pyjarrett 2y ago
  Ada The open source tooling has significantly improved since I started using it in the last five years.
• artemonster 2y ago
  Tried trying zig, but was baffled by all the allocator dance you need to do and asking nicely to access a list (catching potential exceptions?) Tried odin, but the tooling is very raw. Tried rust, didnt want to try to please borrow checker that distracts me from my thoughts. Idk, if someone just reinvents clean C without the nonsense garbage with some modules and package manager this will be a huge win. Let me access my null pointers, let me leak memory, just get the hell out of my way and let me program and hold my hand only where I want it to be held - sane types that give me refactoring, code completion and code understanding, modules with imports. Let compiler give sane error messages instead of this cryptic c++ garbage. Is this too much to ask?
  • feelamee 2y ago
    looks like zig is exactly what you want. Difference only in std. C prefer global allocator, while zig ask it explicitly. So, if only there is std with implicit allocators?
  • flowerthoughts 2y ago
    I also had a brief look at Zig for writing a WASM module, but settled for Rust. I had no real gripes with the language, but the spartan documentation made making progress into a slog. I wouldn't mind a "better C" that could use an LLM for static code analysis while I was coding. I.e. be more strict about typing, perhaps. Get out of my way, but please inform me if I need more coffee.
  • tahirmurata 2y ago
    [dead]
  • gw2 2y ago
    D's "Better C"[1] mode looks like what you describe. Has syntax similar to C with a real module system, metaprogramming, slice types etc., 1 - https://dlang.org/spec/betterc.html https://dlang.org/spec/betterc.html
  • _lvbh 2y ago
    Allocation in Zig takes some getting used to but it's actually really nice. It took me a few weeks but I honestly believe you should give it another chance and more time
• giancarlostoro 2y ago
  Every now and then Freepascal with Lazarus but the same bug being in the IDE for ten years plus kind of annoys me. If I save a new project and I move any files around it does weird stuff, or if I rename a module. Theres also D but finding libraries for whatever I want to work on proves problematic at times as well.
  • Froedlich 2y ago
    On the other hand, the Ultibo OS for the Raspberry Pi is written in FreePascal.
• rubymamis 2y ago
  I’m considering Mojo.
  • zoom6628 2y ago
    Me too for projects and tools. Would like to use Ada for IOT projects and tools.
  • kaycebasques 2y ago
    Oh, yeah! Haven't heard anything about it in the last 6 months. Any interesting developments?
    • fnands 2y ago
      Lots! [1] The biggest thing to be added recently is GPU programming, which given Mojo's focus on ML/AI makes a lot of sense. It's probably not the best language to look into for general purpose systems programming, but if you are going to be interacting with GPUs or other hardware then maybe it's good to give it a look. It is still changing a lot, so no real stability yet, but to be expected for such a young language. [1] https://docs.modular.com/mojo/changelog/ https://docs.modular.com/mojo/changelog/
• deleted 2y ago
  [deleted]
• xigoi 2y ago
  Nim, I love its “make simple things simple and complex things possible” philosophy.
  • fuzztester 2y ago
    Perl had somewhat the same, IIRC. https://www.google.com/search?q=perl+simple+things+easy+and+hard+things+possible https://www.google.com/search?q=perl+simple+things+easy+and+...
  • blashyrk 2y ago
    I absolutely adore Nim. That said, the edges are still (very) rough when it comes to tooling (generics and macros absolutely murder Nimsuggest/lsp) and also "invisible" things impacting performance such as defect handling (--panics:on) and the way the different memory management schemes introduce different types of overhead even when working with purely stack allocated data. But even with all that it's still an extremely pleasant and performant language to work with (when writing single threaded programs at least)
    • seanw444 2y ago
      Definitely agree that there are rough edges, but Nim is in a better state than ever. The LSP isn't great yet, I'll agree with that. There are great optional type libraries for working around exceptions if you don't want them, and the new memory management system (ARC/ORC) is very efficient compared to the old refc implementation (now much more like the C++/Rust approach). For parallel programming, there are also handy libraries. The best of which is Weave[1], but Malebolgia[2] is authored by the creator of Nim and works well in its own way too. There is also active work being done on a new implementation of Nim which intends to clean up the some of the long-term spaghetti that the current implementation has turned into (like most long-term projects do), called Nimony[3], and is also led by the original creator of Nim. It is years away from production according to him, but is at least in the works. I'd have to say Nim is by far my favorite programming language. The terseness, flexibility, and high performance, make it feel almost sci-fi to me. My only major complaint currently is the tooling, but even the tooling is still adequate. I'm glad it exists. Highly recommend. [1] https://github.com/mratsim/weave https://github.com/mratsim/weave [2] https://github.com/Araq/malebolgia https://github.com/Araq/malebolgia [3] https://github.com/nim-lang/nimony https://github.com/nim-lang/nimony
• lopatin 2y ago
  I started using Idris a few years ago because the idea is fascinating. Such as state machines in your type system, the size of a list being defined in the static type system, even if the list size changes over time (pretty mind blowing), etc.. But ultimately I realized that I’m not writing the type of software which requires such strict verification. If I was writing an internet protocol or something like that, I may reach for it again.
  • TOGoS 2y ago
    Similar boat. I've read about Idris (and been 'shown the door' enough times) and I love the idea of it, but sadly I haven't yet had any reason to use it.
• netbioserror 2y ago
  Nim. Fantastic choice for modern headless software. Simple obvious type system, preference for immutability and referential transparency. Dynamic collections are by default managed by hidden unique pointers on the stack. So the default RC isn't necessary unless explicitly invoked for a ref type. Currently solo managing a 30k line data analysis application I built for my company. Easily fits in my head given the obvious pyramidal functional-like structure. Maybe two lines of memory semantics anywhere in the entire thing, and only one module that's OO with a constrained scope. Lots of static data files (style sheets, fonts) slurped up as const strings at compile time. Incredible performance. Invoked by our PHP server backend, so instead of doing parallel or async in the analysis, the server gets that through batch invocation. Working stupid well for our product, plus I can easily compile binaries that run on ARM and RISC-V chips for our embedded team just by invoking the proper gcc backend. Replaced an ailing and deliberately obfuscated 20 year old jumble of C and PHP designed to extort an IP settlement from my company. Did it in a year.
  • digdugdirk 2y ago
    Do you have any recommendations for well designed open source Nim projects for someone study to get a feel for the language?
    • archargelod 2y ago
      Anything written by Treeform[1] is a good place to start, their libraries make up a big chunk of Nim ecosystem. 1 - https://github.com/treeform/hobby https://github.com/treeform/hobby
    • netbioserror 2y ago
      Honestly hard to say. There are a number of styles of architecting Nim libraries and programs, and almost none match my own. My most particular criticism of the Nim ecosystem is the abuse of macros: There are a number of libraries implementing huge chunks of functionality behind macros such that code paths only appear at compile time and are not reflected in sources. Some libraries constrain macro use, but many are built entirely out of macros. I'd say to avoid looking to those examples.
• atemerev 2y ago
  D and Crystal always fascinate me. And if Go is a system language, Erlang and Common Lisp are even more so.
  • renewedrebecca 2y ago
    I wish Crystal had better IDE support, otherwise it’s just about perfect.
    • vram22 2y ago
      IIRC, I read somewhere, several months ago ago, that its type inference made it slow to compile anything but small programs?
      • felipeccastro 2y ago
        Yes, I believe so because it uses global type inference. I would gladly add explicit types everywhere instead of this to use Crystal if it had decent tooling, because everything else about the language is really perfect.
        • renewedrebecca 2y ago
          > I would gladly add explicit types everywhere instead of this to use Crystal Agreed. Good IDE support can easily add explicit types too.
        • vram22 2y ago
          Intriguing. You really didn't find any issues with it? Anything that you thought should / not be there, or some non-trivial bug?
          • felipeccastro 2y ago
            The language and stdlib feel like a more polished Ruby, though I haven't explored it in deep. The tooling, last I checked, is what's behind - the interpreter didn't work for simple apps, and the LSP is slow and full of bugs.
• nuudlman 2y ago
  Take a look at Pony https://www.ponylang.io/ https://www.ponylang.io/
  • fuzztester 2y ago
    I will, thanks.
  • dismalaf 2y ago
    Pony is fun and I love the actor paradigm but it definitely feels like the community lost a lot of energy when Sylvan Clebsch stopped working on it (to work on a similar project for MS).
• Froedlich 2y ago
  The only true "system programming" I've done was in Microsoft Macro Assembler, a product I grew to hate with a passion. A non-answer, but tangentially relevant: I once fiddled with Forth, but never actually accomplished anything with it. Several OSs are written in Lisp; in some of them the difference between OS and application is a bit vague. At the time none of them were available to me to play with. I discovered Oberon and fell in love. My first real programming language was Pascal, and Oberon is part of the same family. Oberon consisted of a compiler, operating system, user interface, application software, and tools, all self-hosted on Oberon. There was even an Oberon CPU at one time. But Oberon turned out to be just an academic curiosity, and wasn't available for any hardware I had access to anyway.
  • Rochus 2y ago
    Have a look at https://github.com/rochus-keller/Oberon https://github.com/rochus-keller/Oberon which runs on different operating systems and architectures. You can even generate platform-independent C which I e.g. used to port the Oberon System 3 (https://github.com/rochus-keller/OberonSystem3 https://github.com/rochus-keller/OberonSystem3).
  • Snuggly73 2y ago
    "Microsoft Macro Assembler, a product I grew to hate with a passion." Turbo Assembler FTW :)
    • lallysingh 2y ago
      MASM was always horrible. nasm has been lovely, but I haven't used in 10+ years. https://github.com/netwide-assembler/nasm https://github.com/netwide-assembler/nasm
      • 2mlWQbCK 2y ago
        Why all this MASM hate? I barely ever used it, but I noticed that MASM 5.1 is included (together with MSC 5.1 and various other Microsoft tools from 1988) in Microsoft's MIT-licensed MS-DOS repo. Trying some hello world level examples there was nothing obviously annoying about it so far. https://github.com/microsoft/MS-DOS/tree/main/v4.0/src/TOOLS https://github.com/microsoft/MS-DOS/tree/main/v4.0/src/TOOLS
• dismalaf 2y ago
  Odin. It's just too easy and fun.
  • fuzztester 2y ago
    Why is Odin easy for you? Because it is non-OOP (I think, have not confirmed that) or some other reason?
    • dismalaf 2y ago
      Build system, module system, simplicity of C but much nicer, clearer syntax, lots of batteries included, it just does a lot of stuff to make life easier versus Zig or C/C++. I personally don't think programming paradigms like OOP, procedural or functional make anything easier/harder necessarily, just talking QoL stuff. And obviously "easy" is relative: Odin is still a low level language where you need to manage your own memory.
      • deleted 2y ago
        [deleted]
• baddate 2y ago
  Julia https://julialang.org/ https://julialang.org/
  • akkad33 2y ago
    I don't know if Julia is a system programming language
    • brabel 2y ago
      It's quite funny to classify it as such, given you need to run your programs like a script as it's nearly impossible to compile a binary you can distribute (though I am aware they're working on this as a priority task, currently).
      • leephillips 2y ago
        Compilation to small binaries has made great progress: https://lwn.net/Articles/1006117/ https://lwn.net/Articles/1006117/ It’s not always clear what is meant by “system programming”. I’ve begun writing utility scripts in Julia; it’s practical now because the startup time is vastly improved. These can be run like bash scripts, with a shebang line that invokes Julia with the desired environment (using the --project flag).
        • brabel 2y ago
          > It’s not always clear what is meant by “system programming”. I’ve begun writing utility scripts in Julia; it’s practical now because the startup time is vastly improved. These can be run like bash scripts, with a shebang line that invokes Julia with the desired environment (using the --project flag). I think it is clear enough. The language must have a small or non-existing runtime so it is practical to write systems that do not ship the same fat runtime on every binary. The language must support compiling to binaries, otherwise it really cannot be used by itself for systems. It must provide access to the available Operating System API directly without the need for bindings (to the extent possible, as some OSs only expose the C API;ABI). What is a system, you may ask. I think you can define that as anything that can run by itself (no runtime) and perform any "low level" operation permitted by the OS.
• docandrew 2y ago
  Ada for bigger projects, D for quick one-offs and more “scripty” work.
  • fuzztester 2y ago
    I had played around with D some time ago, and wrote some small programs in it for fun and learning. I both liked and disliked things about the language. there was some Russian dev running a systems tech company, I forget his name, living in Thailand, like in koh samui or similar place. he used D for his work, which was software products. came across him on the net. I saw a couple of his posts about D. one was titled, why D, and the other was, D as a scripting language. I thought both were good.
    • docandrew 2y ago
      It’s a little like go in that it compiles quickly enough to replace scripts while still yielding good enough performance for a lot of systems tasks. It predates go and I wish Google had just supported D, it’s a much nicer language IMO
  • johnisgood 2y ago
    What are you using Ada for?
    • docandrew 2y ago
      Fun side projects mostly, my GH username is the same as here if you’re (morbidly) curious.
      • johnisgood 2y ago
        Will do! :D I did, a quick thought, regarding https://github.com/docandrew/SPARKTLS https://github.com/docandrew/SPARKTLS: you might find https://github.com/Componolit/libsparkcrypto https://github.com/Componolit/libsparkcrypto useful, too, if you have not already. Nice projects BTW!
• ajdude 2y ago
  I almost exclusively work in Ada for my hobby projects these days; It's great for doing both high level and low level programming.
  • alok-g 2y ago
    Where does tooling and platform support stand for Ada? Could one develop desktop, mobile, web apps, too using Ada? Thanks.
    • ajdude 2y ago
      Tooling is pretty good; Ada has a package manager similar to Cargo (Alice: https://alire.ada.dev https://alire.ada.dev ), and you can install it pretty easily via GetAda ( https://getada.dev https://getada.dev ), which brings in the compilers and any libraries you'd need. (disclaimer: I'm the author of GetAda) Desktop apps: definitely. There's bindings for various UI toolkits like GTK and I know of a few people working on games in Ada, usually thick bindings like SDL: https://github.com/ada-game-framework https://github.com/ada-game-framework and https://www.youtube.com/playlist?list=PLn3eTxaOtL2Oxl9HbNOhIPVozAWCeyCZ4 https://www.youtube.com/playlist?list=PLn3eTxaOtL2Oxl9HbNOhI... There's also Gnoga, which is similar to Electron for writing UI apps: https://github.com/Blady-Com/gnoga https://github.com/Blady-Com/gnoga A bunch of libraries for various drivers or other useful things on https://alire.ada.dev/crates.html https://alire.ada.dev/crates.html (to include something like "ada_gui" in your ada project, you would just use alire, e.g. `alr with ada_gui`). Much of Ada's webapp functionality is either interfacing with the Ada Web Server or gnoga (I've written a few servers using Ada Web Server, including one for an ".io" game). There's an LLVM compiler which in theory can produce wasm but I've not messed with it: https://github.com/AdaCore/gnat-llvm https://github.com/AdaCore/gnat-llvm Mobile platforms can be targetted and cross-compiled in Alire, but I'm not sure who's doing it right now. For anyone interested, I definitely recommend checking out some of the presentations of Ada's recent FOSDEM dev room https://fosdem.org/2025/schedule/track/ada/ https://fosdem.org/2025/schedule/track/ada/
  • sharedptr 2y ago
    Are there Ada jobs?
• billwear 2y ago
  (kebab-use-elisp)
• sheepscreek 2y ago
  F#! I’m in love with the language. It is my defacto pick for most things these days. Very expressive AND strongly typed. Being a part of the .Net ecosystem is also a plus.
  • vram22 2y ago
    Can you create desktop GUI apps with it?
    • neonsunset 2y ago
      Yes! https://funcui.avaloniaui.net https://funcui.avaloniaui.net https://github.com/fabulous-dev/Fabulous https://github.com/fabulous-dev/Fabulous (I'm sure there are more, these two are those which I could recall from the top off my head)
      • fuzztester 2y ago
        cool, thanks.
      • tombert 2y ago
        I've also gotten it working with FNA. I haven't done anything too elaborate in the game development world, but as far as I can tell there's really no limitations imposed by F# in that front.
  • robinsonrc 2y ago
    I wouldn’t call F# a systems programming language, but it’s definitely on my list of things to properly try out at some point
• ghfhghg 2y ago
  F# and Haxe. Love both of those languages
• gw2 2y ago
  C#. While a popular language, it is criminally overlooked for high-performance programming. Obviously, you can't use it for embedded or kernel development. For other use cases though, it can almost reach the performance of C/C++/Rust when written with proper care.
  • graboid 2y ago
    I sometimes write C# in my day job. But I think I don't know much about how to write really fast C#. Do you have any recommendations for learning resources on that topic?
    • gw2 2y ago
      Sure. Here are some resources: * Span<T>: https://learn.microsoft.com/en-us/archive/msdn-magazine/2018/january/csharp-all-about-span-exploring-a-new-net-mainstay https://learn.microsoft.com/en-us/archive/msdn-magazine/2018... * C# now has a limited borrow checker-like mechanism to safely handle local references: https://em-tg.github.io/csborrow/ https://em-tg.github.io/csborrow/ * Here is a series of articles on the topic: https://www.stevejgordon.co.uk/writing-high-performance-csharp-and-dotnet-code https://www.stevejgordon.co.uk/writing-high-performance-csha... * In general, avoid enterprise style C# (ie., lots of class and design patterns) and features like LINQ which allocate a lot of temporaries.
      • xigoi 2y ago
        C# is specifically designed for enterprise-style OOP, so if you want to avoid that, why use C# at all?
        • gw2 2y ago
          > C# is specifically designed for enterprise-style OOP Then why would they add Span<T>, SIMD types and overhaul ref types in the first place?
          • xigoi 2y ago
• deleted 2y ago
  [deleted]
  • brudgers 2y ago
    Learning a new language for the sake of learning a new language might be why they asked.
• anta40 2y ago
  Pascal. Sure these days not many folks write OS kernel in Pascal, but there are some, e.g: https://github.com/torokernel/torokernel https://github.com/torokernel/torokernel I once want to try Forth (perhaps there's a Unix clone in Forth?), but seems like most folks using it are embedded/hardware devs.
  • fuzztester 2y ago
    I had read somewhere that some of the early Apple (not Mac) software, i.e., systems, application or both, was written in some Pascal variant.
    • Someone 2y ago
      https://folklore.org/Hungarian.html https://folklore.org/Hungarian.html: “The Macintosh used the same Motorola 68000 microprocessor as its predecessor, the Lisa, and we wanted to leverage as much code written for Lisa as we could. But most of the Lisa code was written in the Pascal programming language. Since the Macintosh had much tighter memory constraints, we needed to write most of our system-oriented code in the most efficient way possible, using the native language of the processor, 68000 assembly language. Even so, we could still use Lisa code by hand translating the Pascal into assembly language.” MacOS was clearly Pascal-oriented, with its ‘Str255’, ‘Str63’, etc. data types.
      • fuzztester 2y ago
        ha ha, nice. even early Windows versions were somewhat Pascal-oriented, with things like "long far pascal" used in C function declarations, to indicate the calling convention being used, whether right to left, or left to right, iirc.
      • mistrial9 2y ago
        Pascal interfaces and direct 68k ASM for the first years of Macintosh. C language bindings were third party and discouraged by Apple. There were good reasons for that in those days IMHO, since C came with a lot of Unix software libraries and people would demand that the science libs run. Apple said "no" but third parties built the compilers anyway. Many developers were attracted to Michael Kahl's brilliant ThinkC system, later to MetroWerks. MPW built a more *nix-like environment eventually, also. source: C language developers for the Macintosh OS
• yamapikarya 2y ago
  visual basic. i learned a lot from this language because i'm able to create a system from scratch without import a library.
• kevlar700 2y ago
  Loving Ada without using exceptions or inheritance on embedded and desktop. Some love Ada full OOP tagged types. I love Ada procedural style with privacy and abstract data types. I wish Flutter was written in Ada but atleast Dart is better than JavaScript atleast for procedural code without it's oop boiler plate. You don't actually need OOP for widgets.
  • linuxlizard 2y ago
    I'm a big fan of Ada. I first encountered exceptions in Ada. When I first saw Python, way back in version 1.5, I was happy to see exceptions.
  • dominicrose 2y ago
    But is Dart better than Typescript? I prefer Typescript for multiple reasons but one of them is that you don't have to use classes to use the advanced typing system. Without a typing system I like Ruby the most, but sometimes we just need a typing system.
    • IshKebab 2y ago
      Dart is better in some ways and worse in others. 1. It has an actually sound type system. 2. The language and standard library are waaaaaaaay ahead of Javascript. 3. The tooling is top notch. Better than JS/TS. But on the other hand: 4. Way smaller ecosystem. 5. Debugging is worse if you're compiling to JS. The fact that the code you run is basically identical to the code you write in TS can be a big advantage. Only really applies for web pages though. 6. Type unions are way nicer in TS. 7. Non-nullable types interact badly with classes. It can make writing methods correctly really awkward - you have to explicitly copy member variables to locals, modify them and then write them back. 8. Way smaller community.
      • ohmahjong 2y ago
        As someone curious about learning more about type systems, would you mind elaborating on 1.? I'm assuming you mean the formal definition of "sound", not just as a synonym for "sensible". Sound typing is often something handwaved away as not being particulary consequential in practice; what benefits have you seen there?
• neonsunset 2y ago
  C#, to match the performance of reference implementations in C and Rust, and completely crush the performance of those in Go :)
  • fuzztester 2y ago
    what do you mean by reference implementations, in this context?
    • neonsunset 2y ago
      All sorts of algorithms for processing data useful in high-load scenarios: checksum calculation, text searching/analysis/transformation, data compression, networking (request analysis, routing, filtering), interop with other C ABI dependencies, etc.
      • fuzztester 2y ago
        got it, thanks.
  • Thaxll 2y ago
    Why do you need to downvote / compare Go on every of your post? Do you have insecurities with Go? I was reading another post about someone showing some AI stuff and then: https://news.ycombinator.com/item?id=43246127 https://news.ycombinator.com/item?id=43246127
• mkovach 2y ago
  Free Pascal, but I am interested in Ada and will be learning it more this year. I love the readability of the syntax, and on the outside looking in, the community seems good. I have also moved back hard to using TCL as my scripting language. I like it too much, and bouncing between Python, Go, and such for DevOps glue tires me out. For systems, I love using plan9 (9front) to solve problems, which grounds me to C, awk, sed, and the rc shell.
• fuzztester 2y ago
  commenting after seeing multiple comments here, after about a day. first of all, thanks, guys, to all who replied. that's a wealth of info to follow up on. referring to the comments seen so far: I considered mentioning (Free) Pascal, but thought of not doing it, because I thought it is nowadays too niche, even though it is one of my early programming language loves (forgetting that the title of my post says "less popular languages" :) and I also didn't think of Ada at all, somehow, although have been interested in it, too, lately, and have been checking out websites and blogs about it, and also have been searching hn.algolia.com for posts about it. so it was cool to see multiple mentions of Ada here, by people who like and use it.
  • UncleOxidant 2y ago
    > so it was cool to see multiple mentions of Ada here, by people who like and use it. I'm surprised how popular Ada is here in these comments. I like some of the ideas (ranged types, for example) in Ada, I'm inspired to give it a try after seeing all the comments here.
    • fuzztester 2y ago
      heh. same.
• zerr 2y ago
  Haxe and Dart (without Flutter) are quite nice.
• em-bee 2y ago
  i don't know if pike counts as a systems language, but i consider it an alternative to C, if only because it has good C integration so that you can easily include a module written in C. pikes syntax is also very close to C, which may be appealing to some (ironically that's an aspect i don't really care about myself) if the question of go being a systems language is controversial, then pike is even more so. i would situate pike somewhere between python and go. pikes major drawback is that it doesn't produce standalone executables. the real question i'd like to ask is, what actually is a systems language?
• rganesan 2y ago
  zig is coming along quite nicely. If you've not heard about zig, take a look at https://ghostty.org/ https://ghostty.org/ (a terminal for Linux/Mac and Windows in future), https://tigerbeetle.com https://tigerbeetle.com (a database for financial accounting) and http://bun.sh http://bun.sh (a modern, faster alternative to nodejs).
• whateveracct 2y ago
  Haskell + copilot (from Nasa) and/or MicroHs when targeting embedded (like RPi Pico)
  • 0x6c6f6c 2y ago
    Any good examples for these in systems projects?
  • kaycebasques 2y ago
    Very cool, was not aware of either of them. Thanks for sharing https://github.com/copilot-language/copilot https://github.com/copilot-language/copilot https://github.com/augustss/MicroHs https://github.com/augustss/MicroHs
• meta-level 2y ago
  Micropython of course
  • nickpsecurity 2y ago
    I'll link to it because many people don't know a version of Python runs on microcontrollers: https://micropython.org/ https://micropython.org/
• ptspts 2y ago
  I do systems programming in i386 (32-bit) assembly language with NASM. For me it doesn't scale beyond a few dozen kilobytes (executable program file size) per program. For others (such as Chris Sawyer) assembly scales much better.
  • az09mugen 2y ago
    Did you get a look at fasm [0] ? It has nice capabilities [0] : https://flatassembler.net/ https://flatassembler.net/
    • ptspts 2y ago
      fasm is indeed great. It has many features, it can do all the code size optimizations, it even knows the sizes of variables (e.g. `mov myvar, 5` depends on `myvar db 0` vs `myvar dw 0`). NASM and fasm syntax are quite similar. NASM supports more output file formats (i.e. .o files for many systems), and it can receive macro definitions from the command line (e.g. `nasm -DDEBUG`).
• DASD 2y ago
  Chicken Scheme for personal projects.
• cjj_swe 2y ago
  It hasn't been released yet, but I'm very excited for Carbon :)
• jdougan 2y ago
  D language (Dlang). It is especially good if you are porting from C as the semantics are the same enough to rum a lot of code via copy and paste, or if not it will fail to compile.
• yellowapple 2y ago
  I've pretty much settled on Zig at this point, if only for how dead-simple it is to cross-compile for other hardware platforms. The process of compiling working code for oddball platforms (in my case the Nintendo 64) was way easier than I expected it to be. The only downside is the stdlib being as fast-moving of a target as it is. Right now I've had to put a pin on getting panic stack traces to work on my N64 code because apparently the upcoming release changes a bunch of stuff around panic/stacktrace handling (and it's already changed quite a bit over the years even before these new changes).
  • nyjah 2y ago
    What N64 code are you working on? I am intrigued.
    • yellowapple 2y ago
      Current progress is here: https://fsl.yellowapple.us/zig64/dir?ci=trunk https://fsl.yellowapple.us/zig64/dir?ci=trunk Right now it's just a bunch of WIP Zig interfaces for the N64's hardware, but the end-goal is to get it developed enough for homebrew gamedev.
      • nyjah 2y ago
        Wow - will follow. Awesome!
  • Galanwe 2y ago
    > The only downside is the stdlib being as fast-moving of a target as it is. Ah that's an interesting take, my opinion is that the stdlib doesn't move fast enough. In its current state it's pretty broken, most of the "process", "os" and "posix" modules are either straight up raising unreachable in normal scenarios, or simply badly designed. I would like the stdlib to be much more fast moving and fix all these issues, but I had the impression most work on it is frozen until 0.15 or 0.16, after incremental compilation is done.
    • 2y ago
• qingcharles 2y ago
  If the support was still there I'd still be using VB.NET. I've coded professionally in a dozen languages, including a lot of time in x86 assembler, C++ etc. Still like VB.NET better than any other. To me, it was the most readable code.
  • wglb 2y ago
    Is it not still supported?
    • drewnoakes 2y ago
      it is still supported and developed.
    • qingcharles 2y ago
      It is, but it's really on life support. It's supported for legacy development in the most part. There are so few people coding in it now you'll never see any example or tutorial .NET code in VB.NET.
  • aqueueaqueue 2y ago
    You may like Python! At least the syntax.
• creakingstairs 2y ago
  I've been using Odin [1] for my hobby game development and I've been liking it a lot. Feels like a more ergonomic C. Things I like: - Vendor libraries like Raylib and MicroUI make it easy to get started - I can pass around memory allocators and loggers implicitly using context, or explicitly if I need to. - natively supports vector math and swizzling - error handling with `or_else` and `or_return` Things I don't like: - Name spacing is a bit annoying. The convention is to prefix the procedures but I don't like how they look. It really isn't a big issue. Have a quick read of the overview and if you are still interested, I highly recommand 'Understanding the Odin Programming Language' book by Karl Zylinski [2] [1] https://odin-lang.org/docs/overview/ https://odin-lang.org/docs/overview/ [2] https://odinbook.com/ https://odinbook.com/
  • johnisgood 2y ago
    I like Odin, but the creator is not too motivational (or rather, actively un-motivational)[1]. I still use it nonetheless for some of my own stuff, for now. Regardless, I do recommend people to try it out. I use Linux and OpenBSD, too, despite Linus and Theo. :) [1] The reason for why I think this can be found in their pull requests, but it's been some time I think.
    • amjoshuamichael 2y ago
      What do you mean by "motivational?" Are you talking about how the creator is against adding new features to the language? I actually think that's perfectly fine. One of my favorite things about Odin is the simplicity; the entire language and all of its rules can be understood by reading the Odin overview document. I'm actually thrilled to have a creator that doesn't want to bloat the language.
      • johnisgood 2y ago
        No, suppose you make a contribution to a project and its creator belittles you instead of providing constructive criticism, for example. This contribution is not a new feature to the language, however, perhaps a 3rd-party library. It has nothing to do with adding new features. I agree with you, I do not want the language to be bloated, nor do I want new features blindly added. I prefer simplicity, too. FWIW you can see him losing his "cool" on Discord, too, at times.
• greenheadedduck 2y ago
  Python.
  • neilv 2y ago
    It's not a systems programming language, but I actually wrote a userland "device driver" in Python, for startup MVP pragmatic firefighting reasons. It was somehow rock-solid in over a year of factory production overseas. Which might not have been the case, if I'd written it in C and put in the kernel, like might normally be good practice. (It hooked into some kernel interfaces, did a little multiple USB device management, and low-level keyboard-like decoding with efficient I/O, and buffered and parsed and did something with the output of that.) I have mixed feelings about Python: it often it hurts more than it helps (if you know better ways to do things), but the ecosystem has some nice off-the-shelf components, and it's popular/employable. However, due to the popularity, the average quality of any article you might find through Web is unfortunately low. (For an unpopular language, you'll get a few people writing articles from a junior/neophyte knowledge level, as part of their learning, or because someone said it was good for resume-boosting. That can be good. But no one is going to waste time pounding SEO low-quality filler for a language that doesn't make money. Well, at least they wouldn't before LLMs, but who knows how the economics have changed, now. :)
• ztetranz 2y ago
  I've been learning Elixir just for fun. I wish I was using it in my day job.
  • nesarkvechnep 2y ago
    Elixir is not a systems programming language.
• keyle 2y ago
  Have a look at hare. It's got some interesting bits [1] Also C3 [1] https://harelang.org https://harelang.org [2] https://c3-lang.org https://c3-lang.org
  • xxami 2y ago
    I'm a fan of C3, I like that it's not trying to be _too_ far removed, but adds enough to rid you some of the tedious chores of C. Dev and their community is also really nice.
    • keyle 2y ago
      Nice to hear! I will definitely give it a go now. It was on my list.
• standeven 2y ago
  The IEC 61131-3 languages, though 95% of my work is Structured Text. Anyone need a PLC programmed?
• therealfiona 2y ago
  My team hates when I write POSIT shell.
• Terr_ 2y ago
  Using Elixir and Elm at my day job. Coming from a more Python/Java/PHP/JS background, Elixir was a lot easier to pick up and doesn't frustrate me as much. Most of the remaining scary bits involve concurrency and process supervision trees. Macros are powerful, but also easy to use in a way that makes everything hard to debug. For those unfamiliar with them, it's a bit like a function except any expressions you call it with are not evaluated first, but arrive as metadata that can be used to assemble and run new code.
  • mikercampbell 2y ago
    Why elm over LiveView? I know “why” elm, I liked everything I saw about it, but how do you combine the two, if you do?
    • Terr_ 2y ago
      There's a bit of a struggle between sections that use just one or the other, but Elm has the managerial blessing right now. While I think Elm is neat, it suffers from ecosystem issues. It drive a large amount of Not Invented Here because JS invented somewhere else is hard to incorporate. Also, good luck rendering arbitrary HTML that comes in as data from somewhere else.
      • ghayes 2y ago
        Yeah, I loved Elm, but the restriction that you can't build your own "effect" modules really made it impossible to embrace. Say you want to use a new web API similar to using Elm's core `Http`, well... you can try and fork Elm...
        • boxed 2y ago
          You can use webcomponents to work around a few of those limitations.
  • never_inline 2y ago
    The question is about systems programming.
• inetknght 2y ago
  > Less popular Bash. > I used C for both application programming and systems programming Gross. Learn C++, it's better than C in every way! shotsfired.jpg > I've been wanting to get back to doing some systems programming, but preferably in a more modern language (than C) which is meant for that. Use C++ then. Or if you're a hater and/or don't know how to keep footguns pointed away from your legs, use Rust. > less commonly used ones but tbqh why not Xojo?
• frizlab 2y ago
  Swift
• bitwize 2y ago
  Ada and Scheme.
• rixed 2y ago
  I personally mix languages, using higher level languages for the structural work and calling C for the code or data structures that require it. So a good FFI to C has always been an important requirement for me.
• henning 2y ago
  I've written a non-trivial (5K SLOC) app in Zig and it's very nice.
• purpleidea 2y ago
  Using the `mcl` DSL language in https://github.com/purpleidea/mgmt/ https://github.com/purpleidea/mgmt/ It's awesome. But I'm biased because I designed it. You can't build anything, but you can build many things much more easily. Particularly distributed systems.
• cisrockandroll 2y ago
  RPG
  • degrees57 2y ago
    Dude, you're taking the easy way out. Please go purist and pull the wiring boards out of the closet.
• deevus 2y ago
  I am currently contracted 3 days a week writing Zig. I can't say much because NDA, but I just love working with Zig almost every day. I think for the right projects, it is such a great choice for mission critical software. You get the added benefit of being able to easily consume C libraries without much fuss. The fuss is in navigating the C APIs of decades old libraries that we all still depend on every day.
  • johnisgood 2y ago
    In LuaJIT and Odin it is also easy to do FFI.
  • goeiedaggoeie 2y ago
    I write a fair bit of rust/c for my day job. Do you find zig easier than the ffi interface in Rust?
    • deevus 2y ago
      I've somehow avoided Rust, so I can only comment on what I see in the documentation. In Zig, you can just import a C header. And as long as you have configured the source location in your `build.zig` file, off you go. Zig automatically generates bindings for you. Import the header and start coding. This is all thanks to Zig's `translate-c` utility that is used under the hood. Rust by contrast has a lot more steps required, including hand writing the function bindings.
      • steveklabnik 2y ago
        Zig is easier than Rust here, but you can auto generate bindings, you don’t have to write them by hand.
      • dlivingston 2y ago
        You only hand-write function bindings in simple or well-constrained cases. In general, the expectation is that you will use bindgen [0]. It's a very easy process: 1. Create a `build.rs` file in your Rust project, which defines pre-build actions. Use it to call bindgen on whatever headers you want to import, and optionally to define library linkage. This file is very simple and mainly boilerplate. [1] 2. Import your bindgen-generated Rust module... just use it. [2] You can also skip step 1: bindgen is also a CLI tool, so if your C target is stable, you can just run bindgen once to generate the Rust interface module and move that right into your crate. [0]: https://rust-lang.github.io/rust-bindgen/ https://rust-lang.github.io/rust-bindgen/ [1]: https://rust-lang.github.io/rust-bindgen/tutorial-3.html https://rust-lang.github.io/rust-bindgen/tutorial-3.html [2]: https://github.com/Charles-Schleich/Rust-Bindgen-Example/blob/master/src/main.rs https://github.com/Charles-Schleich/Rust-Bindgen-Example/blo...
• auntienomen 2y ago
  Cython. Writes like Python, runs like C. Strangely underappreciated.
  • DmitryOlshansky 2y ago
    It certainly doesn’t run like C. I once thought to port my JSM machine learning engine to python and it felt Cython might just be what I needed. Simply put it’s tight loops doing bitwise ops on bit-vectors. In reality no amount of adding type annotations would help the thing was slower then C++ by an order of magnitude.
    • auntienomen 2y ago
      I've generally found it to be within a factor of 2 of hand-tuned C. (It's literally autogenerated C.) But implementation matters, and I doubt we're going to check your work here in the comments.
• worthless-trash 2y ago
  Fuzztester here is asking about system languages. I see a lot of people suggesting things I'd consider non systems languages.
  • tmtvl 2y ago
    Yeah, but unfortunately 'systems programming language' is a bit vaguely defined. I'd call any language which can deliver a binary executable and which offers some degree of lower-level control (like getting the disassembly of a procedure or deliberately being able to stack-allocate things) systems languages, but others may have different ideas.
• uwagar 2y ago
  tcl
  • ripe 2y ago
    I agree, tcl is pretty sweet (if totally weird). I use it because it's the mother tongue of sqlite.
• eadmund 2y ago
  Common Lisp. It offers powerful abstractions and high speed. I’m happy with it.
  • tmtvl 2y ago
    Seconding CL. For my personality, purposes, and preferences it's the closest thing to a perfect language.
    • flavio81 2y ago
      +1, it is my go-to language whenever I have no idea how complex the task will get
  • wglb 2y ago
    I do as well. I've replaced a lot of my production bash scripts with Lisp. Pretty much all SBCL.
• harry_ord 2y ago
  Perl is kinda less popular now. I use that at work. Used to write perl6/raku in my previous job, I loved the grammars made a nice way to try and Wirte an nginx configuration manager.
  • warpspin 2y ago
    Perl here, too. We still use it for all kinds of web services development work, mainly because there's years of in-house modules for everything and the malleability Perl has.
• anonymoushn 2y ago
  I've been using Zig for nearly 4 years now. A lot of changes in that period were not great, but I haven't really wanted to use anything else.
  • lukan 2y ago
    I just looked into Zig and it looks great on first glance. What recent changes were not great in your opinion?
  • anacrolix 2y ago
    I have been watching with interest. I can't help but think Rust will easily win. Zig isn't different enough, and it's somewhat opinionated (in good ways but not always clearly better)
• pjmlp 2y ago
  That would be mix of D, Object Pascal, Swift, Ada, C#, Java. A few decades ago plenty of Oberon dialects. As language geek, I randomly select languages when doing hobby coding. Regarding Go's remark, even if I dislike Go's authors decisions, back in my day writing compilers, linkers, firmware, networking stacks, and OS services was considered systems programming. Likewise .NET team has been making wonders catching up to what C# 1.0 should have been for low level code, given its Delphi linage. Java, in the context of being whole Android userspace, including drivers, there is very little systems exposed in the NDK. Vulkan is one of the few things not exposed to Java land, and that is being fixed with WebGPU like API in an upcoming version.
  • deleted 2y ago
    [deleted]
  • gnz11 2y ago
    What are your thoughts on D? My experience is limited but seems like a very underrated language.
    • sfpotter 2y ago
      I started using it recently for a prototype of something I'll eventually rewrite in C++ at work. I really like it. Discarding the preprocessor and replacing it with a proper module system is huge. I got burnt by templates and horrifying compile times in C++, but haven't had any problems with D templates. The module system makes templates feel much more natural to use. The syntax for templates is a huge improvement, and throwing `static if` into the mix results in concise and easy-to-read code. I also quickly realized (with the help of some people on the D discord) that the garbage collector is fine for my needs. So I don't have to spend any time thinking about memory management... put stuff on the stack when I can for speed, othrewise just GC and don't think about it. I think there may be some issue with multithreading and the GC, but this is supposed to get fixed with the new GC that's on the way. There are a few other nice QOL improvements. Getting rid of `->` is honestly worth its weight in gold. There's nothing difficult about forgetting to change a `.` to a `->` or vice versa in C++, but not having to trip over it periodically when you're compiling makes the language that much smoother. I was also initially confused by the `inout` keyword but have come to really like that, as well. Little niceties like `const(T[])` are small but, again, reducing just a little bit of friction like this across the language makes D much, much more pleasant to deal with than C++. I think the main challenge the language is facing right now is that it's huge and a lot of it is still getting worked out. I never thought I'd pine for C++'s "rule of 3/5/0", but it's a lot tighter and more logically consistent than the equivalent in D. But part of that is there being a huge community of C++ developers who have taken the time to promulgate rules of thumb in the community. I'd kill for an "Effective D" book to short circuit some of this process... after all, I'm trying to write code, not play at the margins, tinkering with D's idiosyncracies.
• creshal 2y ago
  I like nim so far, but I have to admit I haven't done all that much with it yet.
  • jasfi 2y ago
    Nim is great, I wrote a crypto trading engine with it. The performance is excellent, memory safety works well, and it was much easier to write compared to Rust.
    • maxresdefault 2y ago
      What kind of profits are you seeing with it?
      • jasfi 2y ago
        No actual profits yet, I've just been back-testing as well as forward-testing various strategies. It looks like writing the trading engine was the easy part.
• johnisgood 2y ago
  Ada and Odin that I would consider less popular, rarely Forth.
  • johnisgood 2y ago
    OCaml and Factor, too, but I am not sure OCaml is not popular. Factor rarely, but I love it, too, just do not use it as much. I actually write more Factor than Forth.
• kagevf 2y ago
  OK, here's a pretty niche blast from the past: the boo programming language. It ran on the CLR (.NET) and had syntax similar to python. I recall using it back around 2006 - 2008 because it offered scripting features for .NET on Windows. https://boo-language.github.io/ https://boo-language.github.io/ "A scarily powerful language for .Net". I didn't use it for too long before switching to Iron Python.
  • vram22 2y ago
    I remember reading about the Boo language and IronPython some years ago. Do you still use IronPython?
    • kagevf 2y ago
      I do not. These days I would reach for a shell script for general scripting, filling in the gaps with maybe a C# console app or something in Common Lisp if I want/need some interactivity. Something that happens pretty frequently is I'll take information I've written into an emacs org doc and run it through a CL function, whose output could be an org mode table which I can from there export to a different document format if necessary.
• atiedebee 2y ago
  I recently dabbled in "hare" which was quite a nice experienced. I liked how the language stayed pretty simple compared to other C-replacements. The standard library is also pretty nice. It is however an extremely niche language, but still quite capable
  • sakras 2y ago
    I was pretty excited about Hare until Devault said that Hare wouldn't be doing multithreading as he preferred multiprocessing. That was a pretty big dealbreaker for me. The rest of the language looks quite clean though!
    • shakna 2y ago
      hare-ev [0] is using epoll under the covers, which means multithreading is there, already. Especially as ev may be merged into the stdlib at some point. [0] https://git.sr.ht/~sircmpwn/hare-ev https://git.sr.ht/~sircmpwn/hare-ev
      • sakras 2y ago
        Maybe I'm misunderstanding something, but it seems like ev is still multiprocessing? Reading the code, it looks like you can read/write to files, and if you want to kick off some other work it spawns a process. I don't see any instance of threads there.
        • shakna 2y ago
          epoll is threaded, not multiprocess. [0] hare-ev is using rt to make the epoll syscalls. [1] > On Linux, ev is implemented with epoll. Note that, on Linux, I/O on regular files is always blocking. [0] https://www.man7.org/linux/man-pages/man7/epoll.7.html https://www.man7.org/linux/man-pages/man7/epoll.7.html [1] https://docs.harelang.org/rt#SYS_epoll_create https://docs.harelang.org/rt#SYS_epoll_create
          • sakras 2y ago
• namshe 2y ago
  I will put in a plug for Mercury: https://mercurylang.org/ https://mercurylang.org/
  • adastra22 2y ago
    Wow, I haven’t heard about that language in a long time. What do you use it for?
    • johnisgood 2y ago
      Looks like Prolog. I wonder what the major differences are.
      • adastra22 2y ago
        I guess it's like Prolog in the same sense that Rust is like C? It's a modern functional programing language that also supports logical programming. I never got a chance to actually code with it though.
  • vram22 2y ago
    I read a while ago, when checking out Prince XML (a high-end HTML to PDF conversion tool), that is written using Mercury. https://www.princexml.com/ https://www.princexml.com/
• jlengrand 2y ago
  I still absolutely love my Elm. Never a programming language has made me as confident and joyful when writing code <3.
  • pclowes 2y ago
    Are people using Elm for systems level programming? I have only used it on the front end.
    • vram22 2y ago
      Roc was inspired by Elm, and has CLI as one of its "platforms", which is systems in a loose sense. Early days for Roc, though there may be orgs using it in productiom.
• Peteragain 2y ago
  I've used c and java, and have recently been thinking about go. It's interesting that the comments here only mention go in the negative. Can someone give me the back story about go?
  • anta40 2y ago
    I think Go is fine for application development (any stuffs that runs on top of OS). But for system programming, which is generally understood as developing OS kernel (filesystem, memory management, device driver etc) or embedded which you built a mini OS), then Go is not the proper choice (features like coroutine, AFAIK, needs OS). You'd want C/Pascal/Rust/Zig/<what else?> ...
  • hereonout2 2y ago
    I don't know if go counts as "systems programming" like the other commenter mentions. But I have been recently using it for some tooling and small servers on personal projects where I'd have used python before. Frankly it's been a joy and I wish I'd started earlier. The concurrency primitives are great, and the static binaries make deployment easy (raspberry pi in this case). Struggle to use anything other than python professionally, the need to settle on a common denominator trumps pretty much everything else.
• noelwelsh 2y ago
  I've been writing some Scala Native recently. See https://github.com/creativescala/terminus/ https://github.com/creativescala/terminus/. It's a high-level language but you can still reach down and grub about in memory if necessary. I'm having fun.
• Nales 2y ago
  I am using Haxe which compiles to other languages (C++, JavaScript, PHP...). This is a nice language when you want to create a web application or a even a CLI. If you have played video games by Shiro Games (Evoland, Dune Spice Wars) or Motion Twin (Dead Cells) or even Paper Please!, then you had been exposed to this language.
• chris_armstrong 2y ago
  OCaml The compiler is very fast, even over large codebases. Mostly trying to bring AWS tooling to the platform[1], or experimenting with cross-compilation[2] using another less well known systems language, zig. [1] https://github.com/chris-armstrong/smaws/ https://github.com/chris-armstrong/smaws/ [2] https://github.com/chris-armstrong/opam-cross-lambda https://github.com/chris-armstrong/opam-cross-lambda
  • MrMcCall 2y ago
    It's my understanding that OCaml does not allow its programs to specify the size and signedness of its ints, so no 16-bit unsigned, 32-bit signed, etc... Being a huge fan of F# v2 who has ditched all MS products, I didn't think OCaml was able to be systems-level because its integer vars can't be precisely specified. I'd love to know if I'm wrong about this. Anyone?
    • cmrx64 2y ago
      You’re wrong, not sure where you got that conception but the int32/64 distinction is in the core language, with numerous libraries (eg stdint, integers) providing the full spectrum.
      • MrMcCall 2y ago
        Thanks. They're not in the basic-data-types, but you are correct, they are available in the stdint module, which has a pub date from Oct 19, 2022. It can be found here: > https://opam.ocaml.org/packages/stdint/ https://opam.ocaml.org/packages/stdint/ It's been a while since I investigated OCaml, so I guess this is a recent addition and is obviously not a part of the standard integer data types (and, therefore, the standard language), that not only have no signedness, and only have Int32 and Int64, but have "one bit is reserved for OCaml's runtime operation". The stdint package also depends on Jane Street's "Dune", which they call a "Fast, portable, and opinionated build system". I don't need or want or need any of its capabilities. As well, the issues page for stdint has a ton of more than year old open issues, so, as I understood, OCaml does not, like F#, have all sizes and signedness of ints available in their fundamental language. Such a language is simply not a good fit for system-level programming, where bit-banging is essential. Such low-level int handling is simply not a part of the language, however much it may be able to be bolted on. I just want to install a programming language, with its base compiler and libraries and preferably with man pages, open some files in vi, compile, correct, and run. That is my requirement for a "systems-level" language. I would never in my life consider OCaml with opam and Dune for building systems-level software. I wish it could, but it's not copacetic for the task, whose sole purpose is to produce clean, simple, understandable binaries. Thanks for helping me understand the situation.
• nodramallama 2y ago
  [dead]
• nodramallama 2y ago
  I’ve been using Odin and really enjoying it lately. In my free time I’ve been using it for gamedev and for some Python interop at work
• Surac 2y ago
  Forth. Old but very versatile. wrote the runtime myself years ago in portabel c.
• Rochus 2y ago
  My major system programming languages are C and C++, but I did some projects in Oberon (which turned out to be not particularly suited for systems programming), and then created a modified, better suited version of it called Oberon+ (https://github.com/rochus-keller/Oberon https://github.com/rochus-keller/Oberon), which I e.g. used to create platform-independend versions of different Oberon System generations. But Oberon+ is still too high-level for many system programming tasks. So I'm designing a new system programming language called Micron (for Micro Oberon, see https://github.com/micron-language/specification https://github.com/micron-language/specification) which has the full power of C without its disadvantages. You can even use it for the OS boot sequence when there is no stack and no heap, but also for higher-level application development, due to its selectable language levels.
• mrweasel 2y ago
  I'm not very good at using it, but every now and then try to do a small project in Chicken Scheme. Mostly I'm unsuccessful, but I enjoy the language a lot and have a great time using it.
• brigandish 2y ago
  I’ve replaced Ruby as the “glue” language on my machine with Crystal, being able to plop out a binary and not worry about the myriad things that can go wrong with needing the entire environment to be perfect, including reinstalling gems for every version etc is such a relief. Bundler is just a frustrating sticky plaster over that. I’d like to give Zig and Nim a go, but Go and Elixir are probably next on the list, simply because I have unread books for them staring at me.
  • raffraffraff 2y ago
    I stopped buying tech books, started a safari online subscription. Much better. Now I have just one thing staring at me (virtually) from the internet, instead of a dozen things staring at me from the book shelf. It's less intrusive.
• deleted 2y ago
  [deleted]
• morphle 2y ago
  Squeak[1], Cuis. Metacircular Smalltalk VM[2] written in itself. We sometimes call it SqueakNOS for 'Squeak no operating system needed'. [1] https://ftp.squeak.org/docs/OOPSLA.Squeak.html https://ftp.squeak.org/docs/OOPSLA.Squeak.html [2] https://tinlizzie.org/VPRIPapers/ https://tinlizzie.org/VPRIPapers/
  • guestbest 2y ago
    An FTP link for documents? That’s a real throwback
    • morphle 2y ago
      It is a html link and a subdomain name that is the same as a protocol. Here pdf link: https://dl.acm.org/doi/pdf/10.1145/263698.263754 https://dl.acm.org/doi/pdf/10.1145/263698.263754
• gibsonf1 2y ago
  We have had a great experience using Common Lisp [1] for our causal space-time systems digital twin [2] [1] http://sbcl.org/ http://sbcl.org/ [2] https://graphmetrix.com/trinpod-server https://graphmetrix.com/trinpod-server
  • codr7 2y ago
    I so envy people who manage to find interesting Common Lisp work, it's like we live in different dimensions.
    • zelphirkalt 2y ago
      Requires open minded middle management and that is rare.
      • felideon 2y ago
        or the CEO of Franz, Inc. as an advisor, it seems.
        • gibsonf1 2y ago
          Also helps that the CEO of the company does Common Lisp Dev.
    • wglb 2y ago
      There are many independent consultants working in Lisp. Yes, it is rare.
• mirekrusin 2y ago
  MoonBit [0] It's still being developed but on man the language is good. You read its documentation and pretty much every-single-thing is right decision (from my PoV). Beautiful language if you like OCaml, Rust. Primary target is wasm, but compiles to native as well. [0] https://www.moonbitlang.com/ https://www.moonbitlang.com/
• Pompidou 2y ago
  J
  • MortyWaves 2y ago
    By what metric is that a systems language?
• dfawcus 2y ago
  Playing with D, while reading up on Odin and the various Cyclone papers.
• egberts1 2y ago
  Cobol, Vimscript/VimL and Ada
• flohofwoe 2y ago
  C99 ;) ...compared to 'popular C' (which is essentially C89 plus some common extensions taken from early C++) C99's main improvements (designated initialization and compound literals) haven't really caught on yet even among many C programmers, but those features (IMHO) completely revolutionize the language, and especially library API design. Also on a more serious note: I started some projects in Zig and even though most of my future projects will be built on a bedrock of C code, more and more of the top-level layers will happen in Zig.
  • codr7 2y ago
    There it is again, the urge to port my Lisp back to C. https://github.com/codr7/eli https://github.com/codr7/eli What I love most about C is the fact that it doesn't talk down to me no matter what crazy ideas I come up with. It's therapeutic for me, reminds me why I started writing code in the first place. I realize that's also what many hate about it, the fact that it gives other people freedoms they would never trust themselves with.
  • dfawcus 2y ago
    Designated initialisers and compound literals, sure they have caught on, one just has to know where to look: https://github.com/danos/vyatta-dataplane/blob/master/src/npf/config/gpc_hw.c#L600-L623 https://github.com/danos/vyatta-dataplane/blob/master/src/npf/config/npf_rule_group.c#L252-L280 That is code which is around 4 years old. For the latter example, one could theoretically avoid declaring the variables 'event' an 'rg_match', instead direcly including the compound literals in the respective function calls. However it is a question of taste, and what is more readable. (The above have designated initialisers, I'm can't remember if there are any compound literal examples there. There is however one here, when the BSTR_K macro is also expanded, also the earlier BSTR_INIT: https://github.com/danos/vyatta-dataplane/blob/master/src/npf/bstr.h#L199
  • cassepipe 2y ago
    I remember reading this some time ago : https://floooh.github.io/2019/09/27/modern-c-for-cpp-peeps.html https://floooh.github.io/2019/09/27/modern-c-for-cpp-peeps.h... I do use those so thank you :)
• hansvm 2y ago
  I've been using Zig for years, and for the last year I've been using it at work. I've coded professionally in all the usual languages, but Zig does what I want much more easily.
• deepsquirrelnet 2y ago
  Does Cython count? I’ve been trying to learn more advanced usage. It’s pretty small and reasonably familiar. I also have messed around with nim a little bit. I like it, I’m just not sure it’s worth putting a lot of effort into.
  • sfpotter 2y ago
    I don't think I would recommend using Cython outside of writing Python bindings. In my experience, the community is too small and the documentation is too lacking. Even writing bindings, I spent an inordinate amount of time debugging inscrutable compilation errors.
• titzer 2y ago
  These days I write nearly all my code in Virgil (https://github.com/titzer/virgil https://github.com/titzer/virgil). It has features like classes, first-class functions, tuples, ADTs, unboxing, and a little data layout language, some unsafe features, like support for generating and integrating new machine code, and can talk directly to kernels.
• ChrisMarshallNY 2y ago
  I think that it depends on the system. Firmware is probably still best done in C (sometimes, C++), mostly because so many SDKs, libraries, and toolkits are done in those languages. Also, there's decades of "prior art" in C. Lots of places to look for solutions. I worked on a project, where we tried using a very "less-popular" language for firmware. It didn't end well. I'd say that being a "Systems Programmer" means that you are operating at a fairly "advanced" level, where the benefits of "safer" languages may be less of a factor, and the power of more "dangerous" languages is more attractive. Of course, on HN, suggesting C or C++ is suggesting "less popular" languages...
  • zelphirkalt 2y ago
    Though we see "fairly advanced level" of C and C++ leading to 70 percent of the vulnerabilities in the Chromium project. So I would bet on anyone's advanced level.
    • ChrisMarshallNY 2y ago
      Good, safe, code tends to come from Discipline, Humility, and thoroughness. I've known many highly experienced and intelligent software devs that are terrible at that stuff, and are like coding time bombs.
  • spauldo 2y ago
    I highly doubt they're less popular, it's just that most people who use them aren't as vocal as their detractors.
    • ChrisMarshallNY 2y ago
      This is my thought, also (it was basically a joke). Another "unpopular" language, is PHP: https://w3techs.com/technologies/history_overview/programming_language/ms/y https://w3techs.com/technologies/history_overview/programmin...
• deleted 2y ago
  [deleted]
• sim7c00 2y ago
  what do you understand as 'systems programming'? there are people making operating systems for AMD64 in Pascal etc.... so there's plenty of choices, odd and even ones. some examples of different interpretations of 'systems programming'. low level systems code - like interacting with devices directly on bare metal. (mmio/io etc.) kernel code - like writing a new subsystem in linux, which uses other drivers. high-level systems - like game engines, automation frameworks, other high performance oriented systems-with-lot-of-subsystems? These different domains, on different targets, might have more or less plausible options for you to try.
• Rounin 2y ago
  D. It's quite C-like, but more concise, has a richer standard library, garbage collection, threading, etc. etc.
• srik 2y ago
  Elm. Gonna hold on to it for as long as possible because it’s fantastic for personal projects - drama free, functional, simple, typed and comes with batteries and great errors and tooling.
• tonis2 2y ago
  Trying to make a game with https://c3-lang.org/ https://c3-lang.org/, quite happy so far.
• glonq 2y ago
  I had a college prof who in his real job wrote -all the things- in Modula-2.
• whitehexagon 2y ago
  I'm looking forward to getting back to Zig soon, especially now that there is support for Asahi linux. I like that for low level SoC stuff, there is now the packed struct, which makes register representation very nice to deal with, especially with the definable int types, although I'm often torn between a u1, bool and sometimes even a enum(u1) for certain flags. I tend to let the SoC documentation (naming convention) drive that decision. Otherwise there is a lot of nice and simply designed language stuff in Zig that also takes me back to my C / asm days. My least fav. part is maybe multi-line string literals that look like comments. I prefer the kotlin approach there. I'd like to find a non walled-garden Zig community if there are other Zig fans here, ie just a forum. Or tips on editor to use? since I am tired of electrons being burned needlessly, and almost feel like I need to VM these modern dev tools.
  • bsder 2y ago
    Does https://ziggit.dev/ https://ziggit.dev/ not cut it for you in terms of non-walled garden? It seems to be good enough that I basically don't interact with the Zig Discord anymore.
    • whitehexagon 2y ago
      I'm lurking so far, but looks like just what I was searching for. Thanks!
  • deevus 2y ago
    I’m doing all my Zig editing in Zed and it works great. For version management I use mise (or scoop on Windows).
    • whitehexagon 2y ago
      Thanks. I managed to find a build of sublime that kinda works (menu bar issues), but not figured out code completion, just seems to spam recent tokens at me. I had a look at Zed thanks, but didnt fancy the tight AI integration stuff. I'm a bit grumpy old mad and like my tools totally offline.
• deleted 2y ago
  [deleted]
• moechofe 2y ago
  Rebol
• seanw444 2y ago
  My two recommendations are easily Nim and Zig. If you want something that is essentially just a modernized C, go with Zig. The concept of compile-time programming having the same appearance as runtime programming is very cool in my opinion. My only major complaint at the moment is that duck typing is fairly prevalent. Sometimes function arguments are declared `anytype` and you occasionally have to dive down multiple function calls to figure out what's going on, though that's not too much of a hindrance in practice, in my experience. My personal favorite language is Nim. Efficient, but simple, memory management (drawing from C++/Rust). You rarely have to think too hard about it, yet making fast programs is not complicated. You can stick to the stack when you want to. The flexibility at compile-time gives you great power (but it requires great responsibility -- easy to abuse in a bad way). The type system is awesome. The only downside for me is the tooling. The LSP needs much optimization, for example.
  • winrid 2y ago
    I find the type system in Nim to be pretty poor. It's difficult to reason about what is on the stack vs heap by looking at the business logic and not the types themselves, and also hard to reason about when you do copies vs pointers, since everything is defined on the type itself. I find it to be a bad design decision, I wouldn't build anything large with it.
  • sph 2y ago
    My issue with Nim is its import system. If you have a function "foo" it's hard to tell where is it imported from. I'm not sure why this bothers me when C is the same... probably because I'm familiar by now which header defines any C function. Also, I believe high-level compiled languages suffer from the fact that it is very hard to tell which construct is expensive and which is a zero-cost abstraction. Rust has the same issue, but "zero-cost" is a major feature of the language so you don't feel bad using an Iterator, for example, in kernel code. With Nim it is hard to tell.
    • seanw444 2y ago
      It makes logical sense to do imports that way when operator overloading exists. Otherwise your custom operators would look like: import other varA other.`+` varB Which is very ugly. At that point, we might as well just go with the function name approach that languages like Go take: customAdd(varA, varB) I suppose you could change it so operators are imported into the same namespace, and non-operators still require a separate namespace when referred to. But that makes it even more complicated in my opinion. I agree it's less obvious what's coming from where, but I think when your libraries have distinct responsibilities, it usually ends up being pretty straight-forward what function comes from where based on how it's named (if it's written well).
• unquietwiki 2y ago
  As the founder of r/altprog on Reddit (been following random languages for 12 years now), my favorite "alt" language is Nim. It feels like Python & Javascript had a baby that was C++. Wish it had lambda operators like C# and JS, but it does have the cool feature of defining your own language constructs. Also, shoutouts to Zig, Crystal, and Ballerina: those are other interesting ones off the top of my head, that folks should look into.
• deleted 2y ago
  [deleted]
• HHalvi 2y ago
  Lua: Picked it up when I was dabbling in building Games relying on Love2D which uses Lua as the underlying language. CoffeeScript: Felt in love with CS as I wanted to rapid protypes with (now defunct) Framer Classic. Smalltalk/Squeak/Vala are something I have wanted to dabble with for a while but haven't gotten around to.
• slevis 2y ago
  I am using Ada atm. Not a "modern" language but I believe it might have a great future :)
• kazinator 2y ago
  I don't work in Seed7 by Thomas Mertes but it deserves to be better known. https://en.wikipedia.org/wiki/Seed7 https://en.wikipedia.org/wiki/Seed7 It has a SourceForge page that actually doesn't suck and you will not hate landing into, unlike almost anything else SourceForge: https://seed7.sourceforge.net/ https://seed7.sourceforge.net/ Though there is an old school SourceForge file area with tarballs, the project page also links to a GitHub repo.
• myko 2y ago
  I'm converting an old C codebase to Swift, though given Swift's non-support for mix-language targets I'm considering switching to Zig. Unfortunately the Zig compiler crashes when building my project and I haven't looked into debugging the compiler to find out why. There's a lot of gnarly code in this project (based on dikumud from ~1989?) with many inexperienced hands touching it over the decades.
• creer 2y ago
  Perl 6 / Raku. The swiss army chainsaw (Perl) raised to the power of the swiss army chainsaw. For its expressiveness in spite of some learning curve.
  • raffraffraff 2y ago
    I had to take a look at some examples, because my last Perl work was over 15 years ago. This is neat: grammar Parser { rule TOP { I <love> <lang> } token love { '♥' | love } token lang { < Raku Perl Rust Go Python Ruby > } } say Parser.parse: 'I ♥ Raku'; # OUTPUT: ｢I ♥ Raku｣ love => ｢♥｣ lang => ｢Raku｣ The same thing in other languages would require a lot more code, without a parser module. An LLM tells me that functional languages can handle this stuff well too, but that Raku code is just extremely simple to grasp
    • creer 2y ago
      So to be fair, "extremely simple to grasp" because looked at superficially. Once you dig into it, there is a lot happening in there. Both in what can go into an actual production grammar, and what is present in the parsing output. which is why I was mentioning learning curve. But yeah, most stuff is easy, there is more than one way to do it, and the impossible isn't. Or something.
• mococa 2y ago
  Lua in my 2D engine https://github.com/willtobyte/carimbo https://github.com/willtobyte/carimbo
• gallier2 2y ago
  D such a fantastic language.
• julianeon 2y ago
  An interesting takeaway from this is that it looks like Rust has really fallen off, in terms of popularity. There was a time when it would've topped these lists (and yes I know you mentioned it - I mean people would've mentioned it anyway). It seems like Nim has claimed 100% of its mindshare.
  • ohazi 2y ago
    Rust hasn't fallen off, it's just largely considered mainstream now.
  • marcosdumay 2y ago
    Some time ago, Rust had no viable replacement at all. If somebody came asking "hey, how can I replace Rust on this system level software" the only possible answer was "you don't". Nowadays, alternatives exist, and so people can answer with one. None of that has any meaning for the popularity of Rust or lack thereof.
  • VertanaNinjai 2y ago
    The prompt explicitly says “not Rust”. So the answers don’t say Rust.
• dlivingston 2y ago
  Does anyone remember BlitzBasic / BlitzPlus / Blitz3D? They were my first programming languages. I loved how dead simple it was to spin up a DirectX-based 3D game or a GUI application. There was something very nice about a simple, performant, batteries-included programming environment.
  • Sodaware 2y ago
    I started with DarkBasic but moved to BlitzBasic after a few months. Wrote a couple of small games and really enjoyed just messing around with it - it felt just like when I started programming on my first computer. I still use BlitzMax for game development (when I get time) - there's an updated version with some nice language additions support for more architectures, including the Raspberry Pi: https://blitzmax.org/ https://blitzmax.org/
• matej-almasi 2y ago
  Ada (safety critical stuff) in work. Not a great fan, but it has its passionate defenders.
• pyuser583 2y ago
  Fortran. Had to use it for some obscure projects a while back. It’s still kicking.
• mxvanzant 2y ago
  Lately I've been using: https://janet-lang.org/ https://janet-lang.org/ It's not a systems programming language, but it can be embedded in C. https://jank-lang.org/ https://jank-lang.org/ looks interesting to me --I have not tried it yet. I'm not sure if this language could qualify as a systems programming language. What do you think?
• bragur 2y ago
  I’ve been using ReScript and ReasonML (derived from OCAML, originating from Jordan Walke) for the better part of 7 years now professionally instead of TypeScript/JavaScript and couldn’t be happier. Blissfully enjoying a fully sound type system with stronger type inference vs. TypeScript and without all the complex type jugglin, null hell and an insane compiler with good errors, enormous speed and output of optimized JS code. It does indeed have a learning curve (these days far less steep than it used to be) but the benefits are just so many in my eyes. At the same time TypeScript has come a long way but it still struggles in comparison and I never feel as safe when writing TypeScript. One downside is, of course, far less adoption and libs usually will have to have ReScript bindings written for them but that's fairly straight-forward and not something I have to do very often.
• markldevine 2y ago
  Raku, for scripting jobs. It is a huge language, done right imo. It has more "flow" phenomenon than any other language I've encountered (like playing a great video game). Not write-only like its ancestor. So many language criticisms solved. A true pleasure. Still in its function-first development phase but apparently near the end. AST rewrite is still underway, then the team will address performance.