Not too long ago I started to dabble in low-level graphics programming again. I set a goal of creating a basic scene that can be defined in a similar way to production-grade game engines like Unity and friends. I felt comfortable with basic OpenGL at the time, however the guides that I followed never told me how to create a hierarchical scene.
App Engine is a service by Google that provides hosting for web applications. Depending on how much traffic your application receives, App Engine will dynamically allocate resources to your infrastructure. App Engine has historically been somewhat limited in functionality when it comes to language support and control over your infrastructure; however this has changed with the advent of App Engine Flexible Environment which is more resemblant to services like Elastic Beanstalk.
With the rise of cloud computing and the proliferation of new users to the web, it has become a necessity for successful web applications to be able to serve thousands of users whilst being reliable, fast, and secure. People depend on web services for their day-to-day lives much more than they did during the internet’s infancy, and it’s expected that applications meet user expectations in order to stay relevant.
A few months ago after a tiring day at work, I came across a post on /r/programming about livecoding a N64 emulator in rust and instantly became hooked. That stream piqued my interest in the subject of emulation, along with giving me that wonderful feeling I had when I first got into programming. After reading some discussion in the stream comments, I decided the best way to get introduced into the emulation scene was to write a CHIP-8 virtual machine.
Traditionally, Go has handled dependencies by installing them all in the same directory under
$GOPATH/src. This works fine if you’re working on a small application you do not care too much
about; but if the project is large or has lots of developers, version locking dependencies becomes a
must, lest library version mismatches will ruin your day.