logimame
logimame on Hacker News
Position based dynamics is far more than just Verlet integration though. The meat of the algorithm has to do with dealing with various constraints (which is done by sequentially projecting positions related to each constraint while adhering to both the constraint and Newton’s laws (momentum conservation). PBD’s main strength is that it can incorporate various types of constraints at once with relatively simple code and good performance.
The knowledge of making and maintaining these tools is still incredibly important and should be handed out through generations (while also inventing innovations to make more efficient and powerful tools).
But what many older generations in tech who constantly lament about the “new generation of tech-illiterates” ignore is that there are actually quite some people (both old and young) who understand this and are actually dedicating towards learning, teaching, and creating low-level mechanisms and systems (such as the people in the Handmade Hero Network, the young new Linux hackers contributing to the kernel, and hobbyists creating their own game engines). And it’s a grave disrespect against them to say that nobody actually cares about anything. If you really are worried about this, don’t just complain and cry about it, be the change you want to see in the world.
D, Nim, and Haxe had it for quite some time (Along with Jai, which is yet unreleased to the public), although you can argue that Zig’s implementation is conceptually the simplest (it has merged compile time semantics with generic types in a unified way).
Actually, slashes in filesystem::path is one of the operator overloading uses I really like in the C++ standard library (It’s time-saving, it’s useful, it’s easy to read). What I really don’t like is the IO operators << and >>, which I think is an incredibly horrid language design mistake. (It’s slow in performance, it’s hard to add formatting options, hard to read).
When you're doing any sort of non-trivial gamedev, graphics, or physics simulation work, there are so many instances when you have to get a bunch of magic numbers by trial and error, and it's usually all over your code. If you try to "refactor" these cleanly into a separate JSON file (hint: it NEVER is that clean), it still takes time and effort away from you to by writing boilerplate code, which seriously kills your momentum for experimenting and iterating with your code. It's kind of a niche domain-specific thing which most gamedevs and graphics programmers would sympathize with.
Also there are also a shit-ton of minor logic-changing modifications when you're writing prototype gamedev code, (for example, moving an if statement here or there to tweak the physics of your platforming). These cannot be easily represented in config files, and this is why people attach lightweight scripting languages like Lua to their game engines (so that you don't have to wait for those atrocious C++ compile times when tweaking your gameplay code).
(Ironically, serde is known for its atrocious compile times, which really makes the situation even worse. Because of this some frustrated Rust gamedevs wrote their own serialization libraries such as nanoserde (https://github.com/not-fl3/nanoserde)... but you get the point.)
Basically yes. Godot’s main userbase (hobbyists/small indie developers) aligns more with Unity than Unreal. Although Unreal has also appealed to some indie devs recently, it is still a heavy, bulky, monstrous beast of an engine that appeals more to AAA gamedevs and high-profile indiedevs.
The Corona SDK always have a special place in my heart. I was in middle school when I've used it back then, and it tremendously helped in me learning programming at a young age.
Before, I would try to learn how to make games by dabbling with SDL/DirectX/Cocos2D/etc, but figured out that you can't really do much with these frameworks as a beginner than just copy-pasting code in the books and tutorials. I was really able to make "complete" apps once I've grabbed a no-nonsense batteries-included framework like Corona, and I would have wasted far more time on useless low-level stuff if I haven't stumbled upon it.
Oh, and about the unfortunate name they've decided with: who really knew that this coincidence would happen haha...
I use Thunderbird - The only desktop client which has both Windows/Linux versions (with identical UIs), doesn't use Electron, and doesn't need you to make an online account for it. (I'm looking at you, MailSpring!) And the experience is... not that great for me. There doesn't seem to be a way to view email conversations cleanly, and the whole app seems a bit bloated. I really wish someone made a cross-platform email client that just simply works - I would gladly pay money for it.
This is why I think the Mastodon-like federated networks are better for these kinds of things. The majority of Mastodon users are Japanese because lolicon isn't permitted in Twitter, but you can still safely ignore those users because of Mastodon's federated nature.
They aren't your typical average Twitter users, they're artists (although not the industry-professional kind; one is making small indie games, and the other is drawing fanart). Those small-scale artists (who are earning barely enough money for their skills) are probably gonna look down pretty harshly at the investors who seem to look at dollar signs as the ultimate goal... I guess the language is a bit harsh but I could understand.
(Maybe HN isn't that sympathetic to those type of people, so I might get downvoted to oblivion - but you still can't generalize them as average Twitter users...)
Although LuaJIT is crazy fast, it can't be used on iOS, so we first need to compare this with the unJITted version of Lua.
Lua is pretty simple and elegant, but has its woes on being too flexible and wonky (especially with nil and global variables). It also doesn't support OOP syntax directly, so everyone started to create their own wonky class system, which broke easily because of Lua's wonkiness. Gravity seems like a good embedding language packaging a nice OOP syntax with a lot of syntactic sugar (such as properties and access specifiers), so I think some UI/game developers would choose this over Lua.