Kevin Yap

Building a Hackintosh

2021-01-23T00:00:00-08:00

2020 was an exciting year for Mac users because Apple finally released computers powered by their own custom silicon. Despite this, for some reason, it was the year that I finally caved and decided to build a Hackintosh. For about 7 years, I only ever owned laptops, and the 15” MacBook Pro was what I used as a “desktop substitute”. I liked the idea of using a portable as my primary machine, as it meant that whether I was at home, at school, or traveling, I would have access to all of my files. In addition, the most intensive activities that I used my computer for were compiling code and playing League — both workloads that MacBook Pro can easily handle.

However, when Riot released VALORANT, that was the first PC game that pushed the performance of the machine. To Riot’s credit, the game is impressively well-optimized for lower-spec devices, and I was used to playing on minimal graphical settings from my Team Fortress 2 days (loading custom ultra-low spec configs to gain every last frame), but once I started streaming gameplay for archival purposes, that really started to push the limits of the laptop.

Perhaps the straw that finally broke the camel’s back is that one day I noticed that my laptop kind of… rocked back and forth on a flat surface, and it turns out that was because the battery was starting to bulge. Feeling guilty that this was probably a result of me stressing it whilst in clamshell mode for several hours at a time, I decided it was time to build a real desktop PC to play the games that I wanted to play. Since one of my other friends who feels equally strongly about macOS built a dual-booting Hackintosh earlier this year without much trouble (allegedly), I was convinced. Also, Apple’s move to ditch Intel and move to native silicon suggests that macOS compatibility will only become worse as time goes on, meaning I might as well get in on the action now.

Onto the Build

@@ -40,7 +40,7 @@

After some searching, I stumbled upon this Reddit post in which someone with an RX Vega 64 (a similar graphics card to my own) had system freezes when performing hardware-accelerated audio encoding. They recommended running a log command to stream kernel-related logs to a file, such that when the crash occurred, it would dump the logs before the system failed, meaning information would be captured even though no kernel panic was actually produced.

Fortunately, the crash did happen during a day where I happened to remember to run the command at startup, and much like the discussion that went on in the comments of that Reddit post, the logs right before the crash seemed to be audio-related, and AppleGFXHDA.kext was the culprit. I disabled the extension by renaming it (which meant I had to first disable SIP, something I didn’t initially intend to do on my Hackintosh), and I haven’t witnessed the crash since, so I’m guessing that solved it.

All in all, building a Hackintosh was a really fun experience, and I realized just how sheltered I was from the whole world of “how modern PCs really work”. I always just nodded my head and pretended to understand when people at work or friends would talk about their BIOS and stuff like that, but now I can at least sort of join in on those discussions. Of course, now I’m a bit sad that I won’t be able to justify buying an M1 Mac anytime soon.

Architecting zeal.gg

2020-03-01T00:00:00-08:00

Back while I was interning at Riot Games, I spent one weekend throwing together a prototype for what would eventually become zeal.gg. The purpose of it was to graph the solo queue ranking of our intern cohort while we were working there, since like most of the League of Legends population, a handful of us got really competitive about it.

Architecting zeal.gg

2020-03-01T00:00:00-08:00

I ended up registering the domain name for fun; Zeal is an item you can purchase in the game, and I was surprised to find that such a short domain name wasn’t taken yet. Having a nice domain gave me grander ambitions for the site — I wanted to polish it up and make it available for other League players to use with their friend groups as well.

This was the perfect task to occupy my free time, since I ended up taking the fall semester of my the final year of my undergrad off. While the initial MVP was a single page that graphed our ranks, the final product would need a landing page where anyone could create a leaderboard for their own friend group.

I worked on final version of the site during November and December, and made an announcement on /r/leagueoflegends the week before the new ranked season started the following January. To my surprise, over 10k people visited the site on the day I made the post, and I continued to have hundreds of consistent users for weeks afterwards! To top it all off, it still hasn’t gone down yet: a mild reassurance that I at least somewhat know what I’m doing in this profession.

@@ -88,7 +88,7 @@

Since I had already created a subreddit to discuss changes to the site, I decided to leverage it. I added an endpoint to the backend that uses Reddit’s API to check for any posts pinned on the subreddit. The frontend calls that endpoint, and if it finds a pinned post, it displays an alert using the title of the post as the alert text, and links to the full post for futher context.

Even though zeal.gg is pretty straightforward at its core, it fills a niche that, to the best of my knowledge, wasn’t served by any other of the multitude of League of Legends websites out there. Figuring out that I had the skills to go from “this would be a cool idea to make for my friends” to a site that tens of thousands of League players around the world decided to check out cured my imposter syndrome for a fleeting moment.

At some point, when I feel like it’s not worth paying the few dollars a month to host the site anymore, I’ll get around to open-sourcing the repository. For now though, I’m keeping the code private, mostly to protect everyone else from laying their eyes upon the monstrosity of the main leaderboard React component.

The Year of Communication

2020-02-24T00:00:00-08:00

The idea of a new year being a time to reflect and set goals always felt reasonable to me, though I had never set any personally. I think I had always (correctly) predicted the difficulty of sticking with a single resolution for the entire year, even past the honeymoon phase of the first couple of weeks of January.

The Year of Communication

2020-02-24T00:00:00-08:00

Despite this, near the end of last decade, I decided to set a goal for myself — I wanted to start journaling on paper. Throughout my time learning how to become a functional human on this planet with actual responsibilities, I’ve gone through way too many different productivity and to-do apps in the quest to find one that “just works” (and have toyed on more than one occasion with the idea of just writing my own).

I had always avoided settling on a system that involved me writing on paper, since my penmanship is wanting in legibility, and I can type several times faster than I can write. However, the more I thought about it, the better idea it seemed to keep some physical planner with me, if only to provide me with a break from staring at screens all day long. Having a dedicated time before going to sleep to reflect on the day’s events would also prove cathartic.

Many people online have touted bullet journaling. The appeal of this system to me was that it was lightweight and was flexible for different styles of journaling. I thought: since I was never able to stick with any productivity apps in the past, maybe paper journaling was the secret? I went out and purchased a nice notebook and set up all my different journaling spreads, prepared to tackle the new year with my new bullet journal.

@@ -99,7 +99,7 @@

I’m not sure why, but pretty early on in high school, my brain had made up its mind and decided that sharing thoughts online was something that I should avoid. Irrational, but that’s how I have existed for the majority of adulthood. Perhaps it was wanting to maintain a cleaner divide between my online persona and my real life, Now, though, I have to accept that having opinions that people might disagree with is okay, and just a side-effect of living in our (increasingly polarized, ugh) world.

Another part of my writing paralysis is due to all of the written content that I do consume. I spend the majority of my waking hours reading articles posted on Hacker News and the more tasteful sides of Reddit. Within these circles, it really feels like every engineer and their dog is able to pump out grandiose yet captivating technical articles.

Posting more means coming to terms with a few of things: firstly, that not every blog post needs to be a groundbreaking thesis, and that that’s actually okay. Random monthly status updates are perfectly fine things to publish on this blog (after all, what else is going to go here?). Also, Twitter and Reddit are not actually read-only services, and lurking gets boring after a while. Finally, I don’t have to adopt the stiff tone that I usually have when writing. It’s hard to break from carefully curating one’s identity, but it’s what got me into this silent pickle in the first place.

Consider this post my first foray into random posting in the last five years or so. All I can hope for is that this yearly theme sticks a lot better than any resolution.

Going Fast in Advent of Code

2019-12-08T00:00:00-08:00

I have been a big fan of Advent of Code since it started back in 2015, and have spent every December since diligently solving as many problems as I can right at 9pm. Rather than a chocolate hiding behind each day like with a regular advent calendar, in Advent of Code, every day brings a two-part holiday-themed puzzle — the first part introducing the context, and the second part building on the theme of the first.

Consider this post my first foray into random posting in the last five years or so. All I can hope for is that this yearly theme sticks a lot better than any resolution.

Going Fast in Advent of Code

2019-12-08T00:00:00-08:00

I think my favourite part of Advent of Code is that, unlike with ICPC-style programming contests, the puzzles are simpler and don’t require knowledge of esoteric algorithms to solve. This makes it more approachable to a wider variety of people, and can also be done for fun and used as a learning tool.

There are a lot of developers who work through Advent of Code at a relaxed pace, either to help learn a new programming language or solidify their skills in general, but every year there is a dedicated group of people who compete for global leaderboard points.

The first 100 people to collect a “star” (ie. solve a part of the puzzle) on each day collect points based on what position they finished in. I have placed somewhere on the global leaderboard every year (peaking at 11th place in 2016), but the competition is only getting tougher. The top competitors often clock in at under 5 minutes for finishing both parts of the problem.

@@ -138,7 +138,7 @@

Edit: (December 2, 2022)

It’s been a few years since I wrote this post, and figured it was due for an update! Both betaveros and mcpower, two people who perform significantly better on the global leaderboard than I do, have written their own posts with tips and tricks for going quickly; I highly recommend giving them a read.

Also, for 2022, I’m streaming my attempts on YouTube — come watch if you’re interested!

Eval Golf (PlaidCTF Writeup)

2019-04-15T00:00:00-07:00

Sticking with the theme of CTF writeups, here’s one of a fairly simple challenge from PlaidCTF 2019. Given that Python is my programming language of choice, it was fun to work on a Python-based challenge (rather than the low-level exploits that are more common in CTFs).

Also, for 2022, I’m streaming my attempts on YouTube — come watch if you’re interested!

Eval Golf (PlaidCTF Writeup)

2019-04-15T00:00:00-07:00

The service that we’re trying to retrieve the flag from executes this script:

#!/usr/bin/env python3
 
@@ -196,7 +196,7 @@
 conn.interactive()

This 22KB payload is accepted by the service and gives us our flag!

Rickety Roulette (picoCTF Writeup)

2019-03-25T00:00:00-07:00

Recently, I’ve taken an interest in CTFs: computer security competitions with tasks that have been specifically designed to have a specific weakness. The goal is to exploit these weaknesses through various methods — such as reverse engineering, binary exploitation, or cryptanalysis — in order to recover a “flag”: a password that follows a specific format, like flag{s3cret_c0de}.

This 22KB payload is accepted by the service and gives us our flag!

Rickety Roulette (picoCTF Writeup)

2019-03-25T00:00:00-07:00

My university started a CTF club last month, and since I’m quite new to this field, I’ve been working my way through picoCTF, which is an oft-recommended beginner resource. Since I haven’t written any technical articles in a while, I thought it would be interesting to provide write-ups for some of the more interesting problems, starting with one called roulette. (The source code as provided by picoCTF can be found here, in case you’d like to try the challenge yourself first.)

If we connect to the service, we see the following:

Welcome to ONLINE ROULETTE!
@@ -444,7 +444,7 @@ Wow, I can't believe you did it.. You deserve this flag!
 picoCTF{redacted}

Success! This was an interesting problem because all it took to find the vulnerabilities was a careful pass through the source code. In addition, both the bugs are things that could easily sneak their way into an actual codebase if not careful. For my next writeup, I’m planning on tackling a problem that requires more sophisticated tooling and background knowledge.

Breaking the Enigma Code With Rust

2017-04-17T00:00:00-07:00

If I had to pick something from the humanities to study in university, I would probably go with history. Not only is history interesting in and of itself, but having a good grasp on history clarifies a lot of modern geopolitics. War is probably one of the more “exciting” aspects of history, and while it goes without saying that war is terrible, a lot of technologies and even new fields of research are the product of wartime conditions.

Breaking the Enigma Code With Rust

2017-04-17T00:00:00-07:00

The Enigma machines are a series of electromechanical cipher machines that were famously used by Germany in World War II to encrypt military communications. Breaking the Enigma code had a huge impact on the Allies’ ability to win the war. Most of what I could write about the history of cracking Enigma is already covered by this Wikipedia article (or if you prefer a more dramatized version, a certain movie starring Benedict Cumberbatch), so I won’t go over it in detail.

Inspired by the computers that were born out of cryptanalysis, I decided to write my own Enigma-cracking program in Rust — ultra. “Ultra secret” was the classification level used by the Allies to refer to intelligence obtained via deciphering German communications at Bletchley Park. If the Germany had discovered that the Allies could read their messages, they easily could have switched to a completely new encryption method, nullifying all the effort spent breaking Enigma in the first place.

To demonstrate how the Enigma cipher was employed, here is some example usage from ultra. First, we encrypt this plaintext message using some random machine settings:

@@ -528,10 +528,10 @@ A few mile

The sequential version of ultra already runs about twice as fast as the C version, and after adding the parallelization described above, it jumps to nearly 10 times as fast!

When writing ultra, I didn’t explicitly set out to implement a hyper-optimized version of James’ code. Instead, I used the description of the algorithm described in his blog post and wrote what I felt was idiomatic Rust. I think this nicely demonstrates the fact that Rust makes it easy to write programs that are readable and also performant.

Cargo also plays a large role in making Rust nice work with. Nothing is more annoying than coming across an open source project that seems useful, but struggling to figure out how to even compile it. With a Rust project, however, you’re essentially guaranteed that cargo build will work — no Makefiles or manual dependency management required.

I really enjoyed learning about Rust while building ultra, and will definitely be using it more in the future. Given the results of Stack Overflow’s recent developer survey, it seems like Rust is growing in popularity — it will be very exciting if it becomes adopted by industry.

The Joy of Problem Solving

2016-12-30T00:00:00-08:00

This past semester, I took one of my favourite computer science courses to date — Intermediate Algorithm Design and Analysis. The course helped me realize my passion for reasoning about interesting problems, and being able to convey ideas about these problems to others. After all, the human mind has evolved to be shockingly good at identifying patterns, and solving puzzles is one of many ways to scratch that itch. This is what I personally find so appealing about programming: a problem that may initially seem straightforward can almost always be approached from many different angles.

The Joy of Problem Solving

2016-12-30T00:00:00-08:00

One of the best ways to improve one’s problem solving skills is being exposed to a lot of different problems and approaches to these problems. The web is a goldmine for this type of content, and I really enjoy reading long-form articles that go in-depth into a given topic. I have a lot of respect for anyone who can take a complex idea and distill it into something that is both approachable and engaging; this skill that I would like to perfect. After all, in the grand scheme of things, knowledge that cannot be shared is virtually worthless.

After I moved my blog to Pelican, I wrote a few posts of this sort of explanatory nature, but haven’t done so over the past couple of years. I think the problem is that whenever I set out to get some writing done, I imagined the final product as some sort of grandiose thinkpiece. This is clearly a flawed approach, as I didn’t end up publishing any posts this year (apart from this one). Throughout high school, my ability to produce coherent essays at the last minute was something I prided myself upon. Now that I’m studying computer science, proofs of correctness are the most writing I ever have to do, so I’d really like to return to writing informative blog posts.

Fortunately, the New Year is that time where people arbitrarily decide to make drastic changes to their lives. I’ve learned my lesson from last year, and this time around, I think I’ll make some more general resolutions. I’ll be trying out a few ideas from Alex Vermeer’s page on life hacking. I want my Twitter feed to be more of a stream of consciousness rather than meticulously curated timeline. I want to write a bunch of blog posts that other people (might) find useful. Let’s see what comes of 2017.

Reflections and Resolutions

2015-12-31T00:00:00-08:00

It’s already the last day of 2015, and I’ve only published a single post this year (and on the first of January, no less). It turns out I’m not actually limited to posting technical articles here, so I figured I would ramble on about various things from this year and set some goals for 2016. With any luck, this might even become a regular occurrence!

Reflections and Resolutions

2015-12-31T00:00:00-08:00

The computer science courses that I took this term were based around C and C++ rather than Java, and so thankfully I was able to forgo using an IDE for development. As a result, this also meant that I could ditch my Chromebook and pack even lighter. I decided to try using an iPad as my computing device because iOS 9 made multitasking a viable option, and it worked quite well. I was able to SSH into the department machines to write and compile code, which gave me the perfect excuse to learn Vim to some degree of competency.

I also spent the my most recent academic term applying for jobs through the co-op program at my university, and I’m excited about spending the next few months interning as a software engineer — quite the change in scenery from the perpetual lecture hall. If there’s one piece of advice I have for others applying for their first internships, it’s to work on personal projects. Not only do projects demonstrate your technical ability, but they also provide talking points for the more behavioural aspects of interviews. The important part isn’t so much that they’ve gone viral or are hundreds of thousands of lines of code long, but that you are able to discuss decisions you made and things you learned during the process.

@@ -544,7 +544,7 @@ A few mile

Another observation I’ve made is that extended, gapless music has become increasingly key to my bursts of productivity. When I’m not listening to podcasts, I tend to throw on an hour-long mashup or medley, since it allows me to better concentrate. I haven’t composed anything for years now, so this is yet another thing I’d like to focus on. The one quantifiable goal I have for 2016 is to release at least 30 minutes of music, which I’ll hopefully be able to transform into some sort of continuous mix.

One of the most rewarding aspects of the software industry is the emphasis placed on continual learning; there’s always a new language or technology cropping up. At times, this goes from interesting to overwhelming, but for the most part, it’s possible to filter out the extraneous. Apple’s open sourcing of Swift earlier this month was monumental for the OSS world, and contributing to Rust was a valuable learning experience for me as well. This year, I’d like to actually develop projects using these two languages.

As it turns out, natural languages are pretty important as well for communicating with fellow Earth-dwellers. As far as language acquisition goes, the younger the better, so the best time to learn a new language is now, not later. I’ve always been fascinated by Japanese due to the combination of logographic (kanji) and syllabic (kana) characters used in its writing system. It’s been a long time since I’ve learned a new language so I’m not sure how much progress I will make, but my final resolution for the new year is to begin learning Japanese.

Here’s to a great 2016, everyone!

On Git and GitHub Flow

2015-01-01T00:00:00-08:00

Recently, I have been making an added effort to seek out and contribute to open source projects on GitHub. The motivation behind this was largely the 24 Pull Requests project, which encourages developers to submit one pull request for each day in December leading up to Christmas. The prospect of being a new contributor to a large, open source project can be daunting, especially to the novice programmer, so this little bit of extrinsic motivation was a nudge in the right direction.

Here’s to a great 2016, everyone!

On Git and GitHub Flow

2015-01-01T00:00:00-08:00

In learning how to properly make use of Git and GitHub, I’ve referenced a multitude of different resources. With 2015 having just arrived, I’m sure many people have “contribute to more open source projects” on their list of New Year’s resolutions as well, so hopefully this article serves as a useful starting point.

Finding a Project

Choosing a project is left as an exercise to the reader. However, here are my suggestions:

@@ -620,7 +620,7 @@ git push -

Commit the changes that have been staged. Continue to commit new changes and rebase when needed.

Push the my-feature branch to remote repository aliased as origin (your fork), using the -u flag to add the branch as a remote tracking branch. (Subsequent pushes will only requre a git push with no additional parameters.) Then, open a pull request using GitHub’s web interface!

For other Git-related problems that one may run into, Google can usually provide the answer. Be sure to look at GitHub’s help page and the Git documentation itself. Here’s to lots of open source contributions in 2015!

EulerPy — Streamlining Project Euler

2014-06-27T00:00:00-07:00

As someone relatively new to the world of programming, I’m always looking for resources that will help me become more experienced. I had read the name Project Euler countless times, but had attempted to work through the problems before, and ultimately became annoyed at the process of solving the problems. I had to switch between writing code in Sublime Text, debugging the output in Terminal, and finally, comparing my solution to the accepted solution found somewhere on the Internet. Because of this, I put Project Euler on the backburner.

EulerPy — Streamlining Project Euler

2014-06-27T00:00:00-07:00

When learning about the world of programming, I was fascinated by the fact that you could install packages or formulae with a simple pip install or brew install command from the terminal and instantly be able to run it, and was determined to write my own package (if only for the novelty of being able to pip install something that I had written).

It wasn’t until a few weeks ago that the thought of going through the Project Euler problems revisited my mind, and of course, it was during the point of time when Project Euler was down. Remembering my prior experience with Project Euler, I set out to write a tool that would streamline the process of solving problems — EulerPy. Essentially, it helps with two aspects of Project Euler: it creates a file containing a docstring with the problem as its body (for reference), and it verifies whether a problem has been solved correctly.

I started out with an idea where the script would parse the problem’s page on Project Euler using a library like Beautiful Soup in order to determine the problem body. I had a working prototype and was testing it on problems, and all seemed to be well until I got to problem #4, where the times symbol is displayed as an image rather than a character. I then did some searching and found a feature on Project Euler where a minimal version of the problem text could be accessed through a /minimal=n page where n is the problem number. However, I think that this functionality was linked to the Project Euler account system, and since it was only brought back as a static site, it is not accessible anymore. While I could have improved the logic of the script to automatically translate images to their text-based equivalents, I realize that this wasn’t the best solution at all, since it would require Internet access to fetch new problems.

@@ -628,7 +628,7 @@ git push -

Making use of Armin Ronacher’s click library to parse command line arguments, I put together EulerPy. I tried to make it as easy as possible to solve Project Euler problems. With this goal in mind, I wrote the package so that it would check the output of a .py file containing the attempted solution to the problem. Because of this, some of the problems can be solved with simple print one-liners, allowing the ability to quickly run euler to move on to the next problem.

Also convenient is the fact that the euler command itself will automatically print the output of the Project Euler file to the terminal. Because of this, debugging is made (ever so slightly) easier by the fact that you don’t need to switch between two different commands when testing the output of the problem file and verifying if it outputs the correct solution.

Having just been introduced to Travis CI after setting it up to automatically deploy the latest version of my website, I figured it would be interesting to set it up for EulerPy as well. I ended up writting a couple of simple tests to ensure anyone updating problems.txt had not transcribed the problems in an errant fashion.

Hopefully there aren’t too many faux pas in my coding, as EulerPy is one of my first Python projects.

Deploying Pelican Sites Using Travis CI

2014-06-11T00:00:00-07:00

After learning about Travis CI through browsing open-source projects on GitHub, I became interested in seeing if it was possible to incorporate it into my already existing workflow based on GitHub Pages. Even though Pelican is a static site generator, adding Travis CI into the mix would allow changes to the theme or content to be made from anywhere that can push to a Git repository — even directly from the GitHub website — and the newly generated files would be pushed to the live server in a fairly timely manner, almost like a WordPress site. Thankfully, quite a few other people had already combined Pelican and Travis CI, so setting it up was fairly straightforward.

Hopefully there aren’t too many faux pas in my coding, as EulerPy is one of my first Python projects.

Deploying Pelican Sites Using Travis CI

2014-06-11T00:00:00-07:00

Most of the solutions that I found suggested using the ghp-import package to handle pushing to the GitHub repository. I was not satisfied with this solution as I wanted to keep intact the incremental changes being tracked by the repository itself (one of the upsides of using GitHub Pages as a host, in my opinion). I came across Andrea Zonca’s post, which described a setup using rsync and git clone to update the branch. Since his blog post is written in a very detailed manner, I won’t rewrite it here verbatim. In short:

Add .travis.yml (which describes to Travis how to build your project) and requirements.txt (which lists the packages to be installed via pip) to the source file branch of your site’s repository.

Since my version of deploy.sh was based on the script that I used to test and deploy changes locally, I wrote it so that it could be executed from a local development machine by checking against the $TRAVIS variable. When run locally, it can be used to check what changes would be pushed to the GitHub Pages branch given the modifications that have been made locally. In practice, it wouldn’t ever be useful to push changes manually since Travis would automatically repeat the exact same steps, but if the integration between GitHub and Travis were to ever stop working, I would still have a way to make modifications to the GitHub Pages branch.

On Programming and Turtles

2014-01-05T00:00:00-08:00

Minecraft is one of my favourite games. At the time of writing, over 13 million copies have been sold for the PC alone — an impressive statistic considering the game was in alpha merely three years ago. Minecraft’s popularity is due primarily to its open-ended nature. The ever-growing variety of blocks appeals to those who enjoy the building aspect of the game, and survival mode only augments the gratification of building by having the player work for their building materials. As for PvP combat, there are numerous community-created custom maps with their own unique rulesets. Expanding on this, through the use of elaborate server-side modding, Minecraft functions more as a game engine than a standalone game, enabling players with unmodded clients to instantly connect to a server and play game modes such as a Minecraft version of the Hunger Games. There is a niche in the game for every type of player.

On Programming and Turtles

2014-01-05T00:00:00-08:00

Added in Minecraft Alpha 1.0.1, Redstone opened up an entirely new world in terms of gameplay. Redstone Dust carries a Redstone current between various Redstone components while Redstone Torches function as a signal inverter. In conjunction with one another, it is possible to construct elementary logic gates, and therefore, fully functional ALUs and other more complex circuits. This means that Minecraft is Turing-complete, but I digress.

The concept of Redstone captivated me even though I had no experience with anything involving logic gates prior to playing Minecraft. At first, using Redstone involved searching for designs that had the functionality that was required. However, as I became more exposed to it, it became increasingly second nature to build circuits based on their constituent logic gates rather than needing to search for schematics. With this learning process came realizations such as the fact that an XOR gate is what controls circuits where two light switches are linked to a single light bulb, or that an AND gate can be constructed as an OR gate with its inputs and output inverted (which De Morgan’s laws prove). In other words, I learned about logic gates by playing Minecraft — a peculiar yet satisfying realization. Using boolean logic when programming felt very straightforward despite never having formally learned about it.

My theory of why Redstone was so appealing is that situations arose where building a circuit was necessary in order to overcome a problem in-game. The lack of tangibility of learning boolean logic in a different manner would have probably been discouraging, or at least uninteresting. By learning through Minecraft, it felt substantial, even though in reality, the product being created was only changes made within a video game world. I thought back to this while learning how to program. Most coding examples that novice programmers are supplied with output text to a terminal without producing a tangible product. Many exercises attempt to teach the basics of writing a program, but to someone without much programming experience, it may prove difficult to bridge the cognitive gap between theory and practicality in terms of how lines of code can be applied to real-world scenarios.

@@ -739,7 +739,7 @@ M index.html

In an educational environment, ComputerCraft could be used to create coding assignments for students. An interesting result of this is that all of the students could simply connect to the same LAN world through pit their Turtle scripts against one another in order to determine whose algorithm is the most efficient; after all, friendly competition is always a good motivator. For a younger audience, this would be more engaging than nearly any other approach to teaching programming that I can think of, considering Minecraft’s popularity with the younger demographic. Perhaps this style of teaching would be better suited for a club or co-curricular activity rather than a class, since all of its participants would need to have Minecraft accounts. That being said, Minecraft has been used in academic settings to teach subjects from logic gates to an electronics class to perspective in art. Organizations such as MinecraftEdu seek to bring Minecraft into the classroom by offering a discount on bulk sales and also providing a mod to the game that improves the teaching process.

If something unexpected were to happen to a Turtle on a long mining expedition, it could get stuck, and time and resources would need to be spent in order to locate and retrieve it. To avoid this, it would be wise to debug the Turtle’s movements in a low-risk environment before actually deploying it on a mining expedition. This might include checking to see how the Turtle would react if a mob wandered in front of the Turtle and obstructed its movement functions, for example. These debugging habits can be applied when the code being written is no longer a Turtle script but rather a more conventional computer program.

Another benefit of learning programming through ComputerCraft is that ideas for new features or added functionality arise simply by using the program. Perhaps the mining script could be extended to instruct the Turtle to automatically return to the start of the branch when its inventory fills up or throw out unwanted materials and only keep ores. Maybe fuel could be a factor, and it could automatically consume any fuel sources that it mines in order to extend the mining expedition. This process of beginning with a basic program and expanding its functionality can be applied when programming independently of ComputerCraft.

I believe that ComputerCraft is a great way to teach people who are already interested in Minecraft the basics of programming. Lua is a very beginner friendly language as, much like Logo, it features a syntax similar to normal English. Turtles will almost certainly more engaging to a novice programmer than a Lua prompt. The mod is not only limited to working with Turtles, either; a more traditional approach can be taken to the programming involved. There are a wide variety of programs that various people have written, from basic APIs to operating systems with GUIs. In this age of computing, more unorthodox approaches to teaching and learning can be experimented with, and with ComputerCraft, ~~the sky~~ Y = 255 is the limit.

Styling Code Blocks Using Pelican

2013-12-10T00:00:00-08:00

Although Monokai is my colour scheme of choice when coding in Sublime Text 2, it was not the best option for displaying code blocks on my website. Favouring a lighter colour scheme, I opted to use a GitHub style colour scheme and also add line numbers (because why not). Referring to a blog post by Alex Peattie explaining how to implement this using Pygments, I made some modifications to make it work with my website. While the process is largely the same as what he already explained, I felt like writing this Pelican-specific guide on the off chance that it might be useful to somebody in the future.

Styling Code Blocks Using Pelican

2013-12-10T00:00:00-08:00

While Alex’s tutorial implemented line numbering using CSS, the CodeHilite extension for Python-Markdown has the option to add line numbers automatically, which saves a bit of work. To enable them, CodeHilite’s linenums setting needs to be set to True. This can be done through the MD_EXTENSIONS option in the settings file supplied to Pelican.

#!python
 MD_EXTENSIONS = ['codehilite(linenums = True)']
@@ -777,7 +777,7 @@ M  index.html
 }

After following these steps, everything should be working properly. Of course, the stylesheet used and properties of the code blocks can be changed depending on personal preference.

Hosting With GitHub Pages

2013-12-07T00:00:00-08:00

Over the past couple of days, I made the switch to using GitHub as the hosting platform for my website by using GitHub Pages. This felt like a natural progression as I already used GitHub for version control for the source of my website. I initially thought the move would be confusing and time-consuming, but after the DNS changes propagated, everything was up and running just as it had been before the move.

After following these steps, everything should be working properly. Of course, the stylesheet used and properties of the code blocks can be changed depending on personal preference.

Hosting With GitHub Pages

2013-12-07T00:00:00-08:00

When dealing with User Pages with GitHub Pages, the hosted files must be located in the master branch of the repository. Since I didn’t want to have separate repositories for the source of the website and for the generated files, I opted to make an orphaned branch named src which would contain the source files. While I thought this would be complicated, it turned out to be quite straightforward.

Within the root directory of my website’s source, there is an output directory that the static site files generated by Pelican go. Prior to using GitHub Pages, I had written a Bash script that would run the pelican command to generate the static site files and upload them using rsync. Obviously, this script had to be rewritten, as in order to use GitHub Pages, changes need to be pushed to a Git repository rather than being uploaded to a web server.

To accomplish this, there are two Git repository: one in the root directory of my website’s source and one in the output directory. Both remotes are configured to push to the same remote repository stored on GitHub. The local repository in the root directory has the output/ directory in its .gitignore file and commits to the src branch while the output/ repository commits to the master branch. While they are technically part of the same remote repository, each local repository is completely separate from the other.

@@ -801,11 +801,11 @@ git push

The command git rev-parse HEAD returns the hash of the last commit in the Git repository’s history and is stored in the variable $commitHash. The directory is then changed to output/ and git checkout is run to ensure the branch that changes will be committed to is the master branch (not that it should change, but in case I were to accidentally change branches manually, this would prevents anything problematic from happening). Any changes made are then added via git add -A.

Following this, the script prompts for an extended commit message (what gets shown on GitHub after expanding the message). The first line of the commit message is “Generated by” followed by the hash of the last commit made in the src branch, and if an extended commit message is provided, the script will add it in. Finally, the commit is pushed to the master branch on GitHub.

All in all, this solution seems to work very well. I would highly recommend using GitHub Pages for static sites.

The Great (White) Pelican Migration

2013-07-14T00:00:00-07:00

When browsing /r/programming a while back, I came across a link to a blog post written by Greg Reda. While reading the post, I noticed the platform that his website was generated with — Pelican — and at the time, I was in the process of searching for a replacement for WordPress. When I initially created kevinyap.ca, WordPress was appealing due to being easy-to-install CMS and versatile in its support and compatibility (themes and plugins), but over time I realized that it was too bulky; what I actually needed was a simple blogging platform rather than a full-fledged CMS.

All in all, this solution seems to work very well. I would highly recommend using GitHub Pages for static sites.

The Great (White) Pelican Migration

2013-07-14T00:00:00-07:00

I decided that it would be wise to make the move to another platform sooner rather than later, so I began the migration to Pelican. The transition from WordPress to Pelican was quite simple; the installation itself was fairly straightforward, and I manually transferred over my previous blog posts. (Pelican does have an automatic blog importer, but with the tiny number of previous posts, it was simpler to just complete the process manually.)

In my opinion, one of the most appealing features of using Pelican for a blog is the fact that posts (and pages) can be composed in Markdown, an easy-to-use and familiar markup language. This change also made it easier to incorporate iA Writer into my blog-writing workflow instead of fumbling around with the WordPress dashboard consistently. Also, iA Writer’s iCloud integration makes it easy to write anywhere.

One minor hitch that I had was with setting up the CodeHilite extension for Markdown. In the configuration file for Pelican, I had the entry MD_EXTENSIONS = ['codehilite'], as the documentation stated that MD_EXTENSIONS needed to be defined as a list. Although this did not raise any warnings when generating the site through Pelican. When I added the Markdown Extra to the list of extensions — MD_EXTENSIONS = ['codehilite', 'extra'] — the code highlighting worked. Apparently there needed to be more than one item in the list of Markdown extensions.

Many thanks to Greg Reda whose Pelican theme (which can be found in the GitHub repository for his website) I am currently using on my website.

The Power of AppleScript

2012-11-28T00:00:00-08:00

One of my favourite genres of music is video game music. Because of this, it was no surprise that I was ecstatic when OverClocked ReMix announced that ReMixes 1-2500 were available to download via torrent, and that every file contained “complete and consistent ID3 tags”. While the tags for most fields are great, I wasn’t particularly fond of the format of the track titles. Instead of TrackName (GameName) like I would have preferred, the format was GameName ‘TrackName’ OC ReMix. There are a few reasons why I don’t like the provided format (namely that the “OC ReMix” suffix feels redundant to me and it feels more appropriate to not see the songs grouped by their source game), but that’s besides the point.

Many thanks to Greg Reda whose Pelican theme (which can be found in the GitHub repository for his website) I am currently using on my website.

The Power of AppleScript

2012-11-28T00:00:00-08:00

Obviously, manually renaming nearly 2500 tracks in iTunes would be a ridiculous undertaking. Luckily, AppleScript happens to be the perfect tool to automate this task. While I had never used AppleScript previous to this, the syntax was easy enough to learn quickly. Doug’s AppleScripts for iTunes proved itself to be a useful resource for learning (and happens to be where I downloaded other scripts from in the past). It is also where I derived the skeleton of this script from. At first, I attempted to figured out how to handle regular expressions within strings in AppleScript, but I soon realized that a crude piece of code would work just as well; it just wouldn’t be useful for any other situation. I set off in search of AppleScript documentation to learn to to manipulate the track name string in the way that I wanted.

The easiest part of the track title to manipulate was removing the OC ReMix text at the end of every track. The way I did it was by setting the track name track to itself after removing 9 characters from the end of the string (as it includes the leading space character). With AppleScript, this was very easy to do: set trackName to text 1 thru -10 of trackName (-1 represents the last character in the string, so -2 would remove the last character, and so on).

After that, to search for the part of the string that contained the song name, I initially tried looking for the first apostrophe in the track title and used the next character as the beginning of the song name string, and ended the string one character before the end of the track title. In most cases, this would (as expected) take the text between the apostrophes — the song name — and store it in a dedicated song name string. Great! Fortunately, I tested this script in batches of 10 tracks or so at a time and manually vetted the result, as this definitely did not work. The flaw with this method may already be obvious; if the game name itself contained an apostrophe (for example, Legend of Zelda: Link’s Awakening), the script would use all the characters after this apostrophe until the final apostrophe as the song name, which is incorrect.

@@ -834,7 +834,7 @@ git push end repeat end if end tell -

Hello, Blogosphere!

2011-10-15T19:35:00-07:00

After much consideration, I’ve finally decided to start a blog. One reason is to expand my writing skills (I don’t write nearly enough), but the main reason I’ve decided to do so is because I now have my own space on the Internet to write about, well, anything really.