@ChristosArgyrop@mjgardner It's a good prototyping language, but there comes a point when you should probably pivot to something like #Nim once you start grabbing 50 pip modules and having to force users to have Python 3.9.4 specifically =P
So far I always added tasks to our Elixir monolithic app, but it always required making a new deployment and starting a new Heroku console instance which always start a new pool of DB connections (fake it till you make it!).
Or I'd write plain Bash scripts.
There's no way to always avoid plugging into the Elixir code, but for others, I'll keep using Nim from now on. #Nim#NimLang
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.
This was a walk in the park compared with the previous one, fun little problem, managed to get short work out of it using some sets, and some simple iterators.
Does anyone have any information about a #polygonal or #vector#tilemap ? Perhaps treating a live-rendered #svg file (or grid-based coordinates in code) as a #tileset for #raylib ?
Polygon tiles on their own wouldn't be so bad, but it'd be nice to have the polygons connect/merge (visuals and performance, basically treating each tile as its exposed edge) plus autotiling (/bitmasking?) and other tilemap features.
An editor would be great, also #hexagon grid. Vertex colors and extra data (shape+color palette+item/decoration) would be nice too.
Or would it be more supported to just go with low-poly 3D? Though even in that case it would be good to have a gridmap.
Note that Godot 4 might allow polygon tiles (using scenes, I haven't tried it, I expect it might be clunky) but I want to use #nim ( #NimLang ) and the bindings aren't where they were for Godot 3 (there are at least 2 people who were working on their own bindings, but I wouldn't know where to begin on testing them).
Personally, I have nothing against the emergence of new #programming languages. This is cool:
the industry does not stand still;
competition allows existing languages to develop and borrow features from new ones;
developers have the opportunity to learn new things while avoiding #burnout;
there is a choice for beginners;
there is a choice for specific tasks.
But why do most people dislike the :clang: #clang so much? But it remains the fastest among high-level languages. Who benefits from C being suppressed and attempts being made to replace him? I think there is only one answer - companies. Not developers. Developers are already reproducing the opinion imposed on them by the market. Under the #influence of hype and the opinions of others, they form the idea that C is a useless language. And most importantly, oh my god, he's unsafe. Memory usage. But you as a #programmer are (and must be) responsible for the #code you write, not a language. And the one way not to do bugs - not doing them.
Personally, I also like the :hare_lang: #harelang. Its performance is comparable to C, but its syntax and elegance are more modern.
And in general, I’m not against new languages, it’s a matter of taste. But when you learn a language, write in it for a while, and then realize that you are burning out 10 times faster than before, you realize the cost of memory safety.
Personally, I also like the :hare_lang: #harelang. Its performance is comparable to C, but its syntax and elegance are more modern.
That exactly why I like #nimhttps://nim-lang.org/ --- it's IMHO much more mature than Hare and offers more targets (e.g. compile to C, C++, JavaScript, WASM or various embedded devices).
So I'm kind of experiencing some cognitive dissonance the last days, I really enjoy the #nim programming language, but the BDFL is kind of really getting more and more unhinged with a lot of statements. And as a person that actually cares about people and things like social issues, it's very much grating, they are also in many cases making the community less welcoming, to the point that I would suggest anyone learning the language to stay away from the official forums.
The problem is that I really enjoy using the langauge, there is very few languages that has the clearity and simplicity of working as nim does, it's a really comfortable langauge to work in that just suits how I think. Probably I could just continue on using it and just stay away from the community, I don't know, it's all kind of saddening.
I implemented "game over" and "restart" logic for my #playdate game. But I forgot that the terrain logic for recycling the ground sprites doesn't have a way to go backwards, only forwards. So when you jump back to the start, this happens... #nim#indiedev#TheLongArc
So, to get back onto having fun with programming after some bad experiences with #rust people I decided to do a bit of #nim (skull) to get back into the groove again.
One thing that I really like about nim is just how natural and extremely readable it feels. just being allowed to overload stuff, being able to pretty easily just extend stuff small things like indexing a 2D array with a point or that making a contains functino automatically lets me use the "if point in grid" style syntax is really nice.
The one thing from #zig that I kind of miss is that each struct kind of works like a namespace where you can add your functions that works on that type, it kind of makes the code more ordered, because as I end up doing it in my code, it does become a bit more cluttered since everything is on the top level.
Another really nice thing that I like with nim is that it allows me to use the (oca)ml type function calls, so that I can do "seq.add blah" rather than having to do "seq.add(blah)" it's a small thing, but it's really nice.
Did day 2 in nim :Nim: as well for @futureisfoss to read over, and you can see it's pretty similar to my gleam version, just that I know nim a bit better, so I think at least this might be a bit more readable :)