Early on in my career, when I saw a function that returns an anonymous function, I felt a weird mix of emotions. It was just a weird thing to do, especially when you’re coming from C, where there are no anonymous functions. Such concepts as lambdas in C++ were hard to grasp, and I’m thankful that instead of continuing to hit my head against the C++ wall I picked Scheme, and it helped me understand many core concepts, such as higher-order functions that we’ll be mainly talking about in this post.
Tags / Lua
Well, It’s unfortunate, but I couldn’t make the game in these 4 weeks. August is just too much of a pain in terms of the amount of different events - maybe even the busiest month in the whole year, for me personally. Judging by the commit history, I was able to work only for 11 days out of the 28 days given to me by the challenge - and I tried to do at least some work every day and commit everything I did.
Why is it the third week that I finally gain any interest in actually working on the game? Now, when I think of it, this may be the whole reason I couldn’t get into game dev during earlier attempts in the past years.
Didn’t have much progress on the Game2 this week. Mostly worked on some additional assets, and rendering the world into an isometric grid. In the last post, I mentioned that it is very hard to come up with floor tiles that leave enough colors for things to be seen.
First week, second game! This time I opted to go with plain Lua. Don’t get me wrong, I like Fennel, but I wanted to get a bit more authentic experience. Apart from having a nicer standard library, Fennel doesn’t add anything to the table in the case of the TIC-80 environment.
Lua is one of the most pleasant languages that I’ve used so far. Well, I’m not writing in Lua directly, instead, I use Fennel - a compiler for a Clojure/Lisp-like syntax to Lua. Because of that, I actually don’t really know Lua syntax that well, even though it’s really simple, it still has some quirks.
Lately, I’ve been into understanding asynchronous programming. Since my background is mostly bare metal C, which has no asynchronous programming whatsoever (apart from running on multiple chips, and communicating via shared memory), and I did only a little bit of C++ and Rust, it’s fair to say, that async is pretty new for me.
Today’s topic will be about lazy sequences and how these are different from iterators. I’ve wanted to make an article on this topic for some time, but unfortunately, there was no good way to show the differences using a single language (that I know), because usually, languages stick to one of those things.
Not long ago I posted a small article on a Condition System in Clojure language. In that article, I was mostly trying to understand what a condition system is, and how it can enhance error handling in the code I write. Since that time, I’ve understood this system a lot better, by actually trying it in the Common Lisp language, the place where it came from, as far as I know.
Previously I decided to implement a rather basic raycasting engine in ClojureScript. It was a lot of fun, an interesting experience, and ClojureScript was awesome. I’ve implemented a small labyrinth game and thought about adding more features to the engine, such as camera shake, and wall height change.
Newer Page 1 of 1 Older