blog

This series of tutorials might be of interest: https://github.com/a327ex/blog/issues/30 > It's aimed at programmers who have some experience but are just starting out with game development, or game developers who already have some experience with other languages or frameworks but want to figure out Lua or LÖVE better. Also on the topic of game engines with lua scripting, the wonderful Defold always deserves a mention https://defold.com/

I may also recommend the BYTEPATH tutorial [1] as it was my first introduction to LOVE game making. [1]: https://github.com/a327ex/blog/issues/30

In a similar vein, the developer of BYTEPATH used to use Github issues as their blog. I also thought it was clever. You even get a commenting and reaction system for free! https://github.com/a327ex/blog/issues

> Those same personas seem to have correlations in other ways: dynamic vs static typing, languages, monolith vs micro service. Your theory needs to account for progression over time. For example, the first programming languages I've learned were C++ and Java, so I believed in static typing. Then I worked a lot in PHP, Erlang and Lisp, and became a dynamic typing proponent. Later on, with much more experience behind me, I became a static typing fan again - to the point that my Common Lisp code is thoroughly typed (to the point of being non-idiomatic), and I wish C++ type system was more expressive. Curiously, at every point of this journey, I was really sure I have it all figured out, and the kind of typing I like is the best way to manage complexity. -- EDIT: your hypothesis about correlated "frames of mind" reminds me of a discussion I h

For anyone interested in the links he provided, I'll add a third, a nice tutorial that introduces you to LÖVE[0] [0]: https://github.com/a327ex/blog/issues/30

Well, I still disagree. I've also played lots of games in my life so I also think I know what I'm talking about. You view roguelikes and roguelites as positively addicting because of your personality and the fact that those games test for the traits you care about, not because they're objectively better than other games that focus on another trait. You probably don't view MMORPGs where the entire point of the game is just grinding mindlessly for months or years as positively addicting because your personality isn't the type that would like that, but there are tons of people in the world who aren't like you and like the average HN reader who would agree with you. I've written more extensively about this before so I feel like keeping arguing here might be pointless, but in case you're curious for a more full version of the argument: https:/

I read this twice and still couldn't make heads or tails of it. Maybe because I learned programming in BASIC, and some variants of BASIC support 'Option Base (0|1)'? Or had to port 1-based Algol code to 0-based Python? Algol, of course, is usually compiled to machine code while CPython, like Lua, compiles to bytecode. And Algol allowed you to specify your own base, with "LWB" and "UPB" as a way to get the lower and upper bounds without needing to know the index. Similarly, perl back when I used it let you set '$[' to change the array base index. And there's Dijkstra's famous essay on the topic, at https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/E... I don't know how to characterize all of those languages and people along the simple axis of "borders" and "no-borders", and the author didn't explain how that axis works. I also r

I am a big fan of the Lua LOVE framework. It's all Lua and very minimal boilerplate code. Recently there was a post about a game called BYTEPATH and the developer put up an entire tutorial on how they made the game including hacking into what little required code there was (the main event loop). https://github.com/a327ex/blog/issues/30 https://love2d.org/

The author explains their reasoning about globals here. https://github.com/a327ex/blog/issues/24 It mainly boils down to the fact that an indie game written by one person and never maintained after release doesn't need to be written for maintainability. Supposedly there are productivity gains the author receives from doing this. Personally, I disagree from past experiences dealing with hundreds of globals in legacy code, but to each their own.

The author has some relevant blog posts (in GitHub issues) too: https://github.com/a327ex/blog/issues/35 - BYTEPATH Postmortem (2018) https://github.com/a327ex/blog/issues/44 - One Year Sales Data for BYTEPATH (2019)