sotolf, to rust
@sotolf@alpha.polymaths.social avatar

So, to get back onto having fun with programming after some bad experiences with people I decided to do a bit of (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 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.

https://gist.github.com/sotolf2/fc66ac3ae9e217f9dcc932b8900c23dd

sos, to programming
@sos@mastodon.gamedev.place avatar

Every single time I check out one of those upcoming shiny new programming languages that claim to be simple:

sos,
@sos@mastodon.gamedev.place avatar

I just checked out NIM and it says "Simple Example" right there, and it does stuff that C can do but in way more steps.

A 2024 programming language that's more convoluted than C from 1975 calling itself "simple"

publicvoit, to programming
@publicvoit@graz.social avatar

What happens, when you join two paths in a language when the second one is an absolute one?

join("foo", "/bar")
returns "foo/bar" or "/bar"?

The wonderful @meisterluk wrote a great article about that you might want to read: https://lukas-prokop.at/articles/2024-05-03-filepath-join-behavior

I can not tell what version I'd actually prefer. There are situations where both versions would be "proper".

#C++

modev, to programming
@modev@emacs.ch avatar

Personally, I have nothing against the emergence of new 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 ;
  • there is a choice for beginners;
  • there is a choice for specific tasks.

But why do most people dislike the :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 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 are (and must be) responsible for the you write, not a language. And the one way not to do bugs - not doing them.

Personally, I also like the :hare_lang: . 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.

This is that cost:

holgerschurig,

@modev

Personally, I also like the :hare_lang: . Its performance is comparable to C, but its syntax and elegance are more modern.

That exactly why I like https://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).

markgritter, to random
@markgritter@mathstodon.xyz avatar

Suppose you modify with the additional rule that taking the last chip in any heap immediately takes all other heaps as well.

It looks to me an awful lot like the Grundy function (for two heaps) is

G(a,b) = 1 + (a-1) XOR (b-1)

But I can only get halfway there on a inductive proof. Is there a clever remapping of the game that shows this formula holds?

Question on Quora (with my partial answer proposing the above): https://www.quora.com/If-you-modify-the-rules-of-nim-so-that-the-game-ends-as-soon-as-any-heap-is-empty-how-to-calculate-the-Grundy-value-of-a-game-from-the-heap-sizes

I haven't even started at looking at whether this handles more than two heaps, either.

ncrav, to nature
@ncrav@mas.to avatar

Time for a re- for newer mastodon souls!

Hello! I'm Nuno and this is Lua :DsaprvingLua: !

I do solution architecture, data processing, statistics, and machine learning for a living.

Lua is a master and a connoisseur of the best gourmet woods.

My interests are:






of ideas











paul, to random
@paul@snac.notnull.space avatar

Is it just me, or is https://nimble.directory down at the moment?

gregorni, to Julia
@gregorni@fosstodon.org avatar

Any Nim or Julia people out there that also do app development? Can I get some ✋?

thindil,
@thindil@mastodon.social avatar

@gregorni Perhaps, but only with and only small apps. 😉

Nycto, to Playdate

I implemented "game over" and "restart" logic for my 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...

video/mp4

charadon, to random

Hey all, I'll be migrating this account to @charadon, follow me if you want! =)

Direct Link: https://8bit.red/@charadon

charadon,
@charadon@8bit.red avatar

@ChristosArgyrop @mjgardner It's a good prototyping language, but there comes a point when you should probably pivot to something like once you start grabbing 50 pip modules and having to force users to have Python 3.9.4 specifically =P

igordsm, to random
@igordsm@fosstodon.org avatar

I've been trying in the last few weeks. It's a strangely nice language with many cool features. It's shame it's not used more...

sotolf, to random
@sotolf@alpha.polymaths.social avatar

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 :)

https://bin.benjaminhollon.com/orrivallbo.nim

futureisfoss, (edited ) to random
@futureisfoss@fosstodon.org avatar

I just made a git repo for my solutions, so if any of you wanna see my spaghetti code you can find it here on - https://codeberg.org/rokosun/AOC

I'm using the programming language since I started learning it a while ago, still very much a beginner tho 🙃

P.S. Also check out @amin's private leaderboard for - https://alpha.polymaths.social/@amin/statuses/01HGA3787ZYTGJ60MQRW09RH5E

CanLehmann, to random
@CanLehmann@mastodon.social avatar

Just added an initial implementation of Gtk.ColumnView to owlkettle. The widget allows displaying large tabular datasets.

https://github.com/can-lehmann/owlkettle/blob/main/examples/widgets/column_view.nim

sotolf, to random
@sotolf@alpha.polymaths.social avatar

So I'm kind of experiencing some cognitive dissonance the last days, I really enjoy the 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.

tomo, to random
@tomo@floss.social avatar

I've been using at work for the last three days for a non-essential, one-off tool. I like it very much so far.

me, to facepalm
@me@social.taupehat.com avatar

I love how -c told me it was OK

mjgardner,
@mjgardner@social.sdf.org avatar

@me It’s just a comment to . The same happens with , , , , , , , , ,

macleod, to haskell

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.

[ # ] :: #c #d

marcuse1w,

@macleod

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.

macleod,

@marcuse1w Not sure why I didn't see this!

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.

[ # ] :: #C

CanLehmann, to linux
@CanLehmann@mastodon.social avatar

A pretty large PR by PhilippMDoerner was just merged in Owlkettle! 🎉

It adds a system for automatically generating forms that allow you to interactively play with the fields of each widget.

Here is how it is used in some of Owlkettle's examples:

RadioGroup example with form that allows editing all fields of the RadioGroup widget

Joe_0237, to random
@Joe_0237@fosstodon.org avatar

Im adding to my list of languages i want to know

sotolf, to random

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.


https://codeberg.org/sotolf/adventofcode2020/src/branch/main/day21.nim

insomniac_lemon, (edited ) to gamedev
insomniac_lemon avatar

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).

  • All
  • Subscribed
  • Moderated
  • Favorites
  • megavids
  • thenastyranch
  • DreamBathrooms
  • ethstaker
  • InstantRegret
  • Youngstown
  • magazineikmin
  • osvaldo12
  • slotface
  • khanakhh
  • rosin
  • kavyap
  • everett
  • tacticalgear
  • JUstTest
  • ngwrru68w68
  • GTA5RPClips
  • cisconetworking
  • mdbf
  • cubers
  • Durango
  • anitta
  • modclub
  • normalnudes
  • tester
  • Leos
  • provamag3
  • lostlight
  • All magazines