@mathiasx C is a 100-year language. Even a small worthy improvement like Plan9's C dialect didn't catch on, so I guess first-to-market and compiler adoption renders any other language moot (as much as I would like to like Ada, and like Zig and Forth).
Higher-level languages is where there has been wiggle-room around Python and PHP.
Hi everyone! I am looking for a new role and would appreciate your support. Lately I've been working mostly with functional languages (#Elixir, #Erlang, #Haskell, #Elm) in web development, but I'm also passionate about programming languages and tooling (compilers, static analysis, development environments, etc). Let me know if you see an opening that you think I may enjoy!
The s390x open source team at IBM confirms the latest versions of various software packages run well on #Linux on #IBMZ. In October 2023 validation was maintained for over two dozen projects, including: the #Apache web server, #ApacheCamel & #Erlang
TIL #erlang / otp comes with wxWidgets bindings. From what i've seen so far it actually fills in a lot of the annoying gaps that i've seen in other languages. Like the event system connects very well to the established actor model..!
It's so rare that anyone remembers about #scala when talking about other #ProgrammingLanguages like #gleam in this particular case. Just happy and surprised 🧐
Various thoughts on too many programming languages, for no discernible reason.
I have been interested in Go since it's very initial release, but their dependence on Google is uncharming to say the least. I still haven't made up my mind on its GC, but its definitely better than most.
I used to do some ML work in .NET and if it wasn't dependent on Microsoft it would be a heavy contender for a great language, but it has far too many Microsoft-isms to ever really go much farther.
Rust is great, I enjoy beating my head against a brick wall battling with the compiler, and their safety is great, but overly complicated and feature-creep is a real problem on that entire project. I do a lot of work these days in Rust, for better (mostly) or worse (mostly-ish).
C is my bread-and-butter, as is Javascript for quick prototyping.
Elixir is great, but Erlang is unwieldy, the community is growing, but not fast enough - and I just can't get my mind to enjoy the syntax no matter how nice it is.
D is a lot of fun, but their GC can be slow at times, and the community is very small and packages are often broken and unmaintained.
Python was my first true love, but I really can't stand the whitespace, again love the language, hate the syntax.
Zig is fun, but just that. Fast, nimble, but early days, a bit confusing, could replace my insistence on C for core projects, but again, early days. I love to use them as a compiler for C, much faster than the defaults on any of the others.
Odin is one I love to keep an eye on, I wish I could get behind using it for more things. When I first took notice ~4 years ago the documentation was a bit scattered, but it looks much better now. The developer behind it is incredibly cool, could be seen as the next Dennis Ritchie imo. Runes are dope. The syntax is by far my favourite.
Julia, I love Julia, but performance last I tested was a bit of a miss, and by miss, it required a decent chunk of compute for basics, but when you gave it the system to throttle, it would be insanely productive to write in. Javascript is something that I prototype even syscalls in, but Julia is just the same but much better and more productive (and less strange) in many regards. I am really hoping this takes over in the ML/Data world and just eats Python alive. I've heard there has been major work in the perf department, but I haven't had reason to try it out lately.
Ada, memory safety before Rust! Great language, especially for critical applications, decades of baggage (or wisdom), slow moving language, insanely stable, compilers are all mostly proprietary, job market is small, but well paid, great for robotics, defense, and space industry types, but the syntax is... rough. Someone should make a meta-language on top of Ada like Zig/Nim/Odin do for C, or Elixir does for Erlang.
The others: Carbon, haven't tried; Nim, prefer when they were "Nimrod" (cue Green Day), decent but not my style; Crystal, seems cool, but not for me; Scala, great FP language, but JVM; Haskell, I'm not a mathematician, but my mathematician friends love it. I see why, but not my thing as much as I love functional languages. I'll try it again, eventually. I did not learn Haskell a great good.
I tend to jump from language to language, trying everything out, it's fun and a total timesuck.
Functional programming wise I like Erlang. It’s simple, to the point, surprisingly powerful with a few charming quirks. Elixir is fine but I like Erlang better. I am interested in the new set-theory type system for Elixir though. The initial presentation looks really good.
I haven’t really given Haskell a chance, but when I dabbled with Elm I liked the approach. Elm is more simple of course. What I don’t like so much about Haskell is that there are several compiler extensions and even if you decide for yourself not to use them to keep it simple they might sneak into your projects via packages. And then you still have to learn the underlying concepts.
Compared to Haskell I prefer Ocaml, although that has also some charming quirks. In total it feels to me that in functional programming the language communities there are a lot of discussions about concepts and less about actual coding. I was a fan, but I gravitate back to procedural. Especially as a lot of procedural languages have some functionality now that used to be associated with functional programming.
Scala looks great, but I haven’t got around it.
A few interesting variances of Ada are Austral, which provides a linear type model that gives interesting guarantees for memory but also file management (and more). A really interesting approach. Austral is also quite new and still growing.
Then there is HAC which currently covers a subset of Ada and has a compact compilation suitable to embed into other programs.
Last but not least Nim. A very pleasant language. Versatile, fast and you can choose to use it with or without garbage collector. This is in my view a great option as there are many problems that benefit from a garbage collector but sometimes you need to know where your bits and bytes are exactly.
Since writing this I've started looking more into Lisp, and I am starting to understand why everyone things its "gods chosen language". it's great, and you can turn/embed any language into a lisp. That's cool.
I like both Ada and C, but I work in the robotics industry, so we have to constantly switch between the two for anything hardware based. They both have their benefits, C is my preferred because of how simple (it can be, if you try...), but Ada (Primarily SPARK is what I've done work in) is great, but dated in many regards. I don't know if I've ever looked into Austral, but I'll take a look!
Haskell, tried it many times, never a good time. Ocaml isn't bad, but again, not my thing or style but definitely something I inherently understand more.
Scala, JVM, my sworn enemy. Never again. They can't get me suckered into reading Java docs again.
Elixir, great language, but I am going to agree with you - I am starting to prefer working with Erlang directly, but its early days on that. I've started looking into @lfe which looks incredible.
Nim, I dislike whitespace reqs in languages, I tend to value customization of my styles to make it all make sense to me, so Nim is too controlling for me in that regard. I read code a lot more than write it.
No real opinion on C2-3, love D, V looks interesting but not sure yet, Jai - if it ever comes out, haven't heard of Scopes, and I already mentioned Carbon.
If someone could find a way to package Rusts memory management in a tenable way to be cross-language, we would have a massive explosion of greatness. I know it's possible, but nearly impossible without some wicked genius' at the helm.
This is probably the newest #LMDB#Erlang library. It is not actively developed currently, but it is functional. I remember doing some experiments with it for VerneMQ, but I haven't kept lab notes. https://github.com/zambal/elmdb
Lasp-Lang was a project to develop a language for distributed, eventually-consistent computations (by Christopher Meiklejohn). It is an archived project now, but the Partisan sub-project (a membership and distribution layer for the #BEAM) is still active (now mainly supported by Leapsight).
We had looked into Partisan a couple of times for #VerneMQ but are currently not using it. https://github.com/lasp-lang/partisan #Erlang
The standard type of list in Erlang and Elixir being a linked list seems like it introduces a lot of undesirable patterns. It shapes how we match on them, how we add to them, what we avoid doing on them (appending, concatenating). It generally imposes and awareness and you also see it reflected in what API gets exposed. Standard libraries are trying to help you not do the less optimal thing.
Is there a way to move on from it. So much is built on it.
How would you do it? #elixir#erlang
I've been reading about #Erlang lately. I'm a little disappointed. Erlang seems real good and powerful, but it's not nearly as weird as I thought. I had somehow gotten the impression that it was #Prolog-level weird, but it's only #Lisp-level weird, which is not actually all that weird these days, since everybody else added some functional elements to their languages.
So I was ready to have my mind blown, but instead I only got it expanded.
Often, as engineers, we champion "the right tool for the job," yet we limit our knowledge of tools, intentionally or not. Please learn about Elixir/Erlang and decide if it's the right tool for the problems you face as an engineer--it's absolutely worth it!
#bitsyntax: a binary pattern matcher inspired by #Erlang's (which is an incredible feature that every language should consider implementing) for #racket
I'm trying to get into functional programming and am looking for audio resources that are interesting/helpful to listen to while driving/doing other things. I would prefer something that talks about functional programming in general and the concepts or that is haskell-oriented, but i'm open to all resources. Thank you!
I would argue than #Erlang is more suitable for writing compilers than #CommonLisp just because it has built-in pattern matching, tuples and map literals. Clojure got literals right but no pattern matching. Oh and DESTRUCTURING-BIND in CL does not count.
If you're interested in #LFE (Lisp Flavoured #Erlang) and how to use it in a mixed-with-Erlang approach, look through λMUD as an example: https://github.com/lfeutre/lmud