Here’s something I’ve been working on recently: a Youtube channel of my guitar covers. I’ve been playing guitar for a few years now (I started in first year university) and I thought it would be fun to record myself playing my favorite songs.
At time of writing, I have 11 videos. Here’s a few of them:
I’m going to upload more as I have time. Please subscribe!
I just finished my first internship — since it’s my first ever “real” full-time job, I feel it’s a rite of passage of some sort.
The internship, or co-op work term, lasted 4 months from January to April. My position was titled “Software Developer”, and the company I worked for was [redacted], a small startup in Kitchener.
Like most students at Waterloo, I found my job through Jobmine. The process was intimidating at first: the whole slew of resumes, interviews, jobmine cycles, ranking systems, etc, were a lot to take in. But as I brushed up my resume and tentatively submitted a few cover letters, I began to relax a little.
In the end, I applied to 25 jobs (the limit is 50 applications). Most of these were in the Kitchener-Waterloo area, mainly because I leased a house here and didn’t want to relocate. Out of these 25 positions, 5 of them were cancelled before the interview stage. Out of the 20 jobs remaining, I got interviewed for 10 of them.
The interviews came and went, and in the end, 4 of the 10 companies that interviewed me gave me an offer. So I had the good fortune to take my pick between 4 jobs, any one of which I’d be happy working for. I ended up simply picking the job that looked the most interesting.
Edit (May 2018): This section has been removed at the request of my employer.
All in all, my first internship was a positive experience, as I learned a lot and worked with very smart people. I learned how to work my way around a large codebase, also got a taste of what a startup is like. I suppose the only downside was that there was almost no social activity.
This sums up my co-op experience. Starting this week, I will be doing another 4 month study term (2B Computer Science) until August.
Anyone who’s played piano, or any other musical instrument, would be familiar with the “standard” musical notation. It’s clear, unambiguous, accepted worldwide, and has been basically unchanged since Bach. It looks like this:
Now there’s a reason this notation has survived this long — it’s good. It’s easy to read, and allows a musician to read and play a piece he’s never heard before.
But when you try to write music, you find that the notation is actually quite cumbersome to write. The notes are positioned on groups of 5 lines, so you’d better either have sheets of these lines printed, or be prepared to tediously draw these lines with a ruler. The timing of notes is very precise, so if you slightly exceed the allowed time for a bar, sorry, your notation is not valid anymore.
To solve these frustrations, I created an alternate system of recording music, with the primary goal of being easy to write. It’s possible to jot down a melody in 30 seconds, with just a pencil and normal (not printed sheet) paper.
I do not claim my notation to be better than the standard notation. Rather, I achieve a different goal, sacrificing information for the ease of writing.
Standard notation is good for recording a song so that a musician can play it without having heard it before.
My notation is good for reminding a musician how to play a song he has heard before.
A common use case would be reminding yourself the notes of a song you’re playing, or accompanying a recording of the song. In a way, its purpose is similar to that of guitar tablature.
Here’s my justification for doing this. Most people can produce rhythm intuitively — that is, after hearing a passage a few times, he can clap back the rhythm. It’s much more difficult to find the correct notes after hearing the passage — I stumble upon it by trial and error.
So if you write down the notes but leave out the rhythm, it would often be enough information to play the song.
The tradeoff should become clear if you compare the same passage written side by side (from Bach’s Minuet in G Major):
Start by writing the notes in a line, and separate bars with a vertical | line. Indicate the key signature at the beginning of the page, if needed. Feel free to liberally clump notes together or space them apart based on rhythm.
Next is the rule for jumps. When the melody goes upwards by a perfect fourth or more (like from C->F), write the jumped note on an elevated line.
Remain on the elevated line as long as the melody is still increasing or stays the same. But as soon as the melody descends, immediately drop back down to the neutral line.
Here’s an example:
As long as the melody consists of small intervals (like C->E->C), we stay on the neutral line. Only when the jump is large (C->F) do we go to the elevated line.
Typically in music, a large jump in one direction is followed by a small step backwards. This means that we spend most of our time on the neutral line. It’s very rare for a melody to have multiple jumps in the same direction.
Here’s another example (Twinkle twinkle little star):
The melody does a large jump on the third note (C->G), so the third note (G) is on the elevated line. On the seventh note, the melody descends one note from A->G, so we immediately drop back to the neutral line. It does not matter that the same G was on the elevated line before.
You do not always have to start on the neutral line. It might be useful to start on an elevated or depressed line. Here’s an example (Harry Potter):
You might be wondering, why make this jump rule so complicated? Why have a jump rule at all?
Well, we need some way of indicating octaves. Otherwise, a interval like C->F would be ambiguous: are we going up a perfect fourth, or going down a perfect fifth?
On the other hand, if we decreased the jump threshold, say a major third (C->E) is a jump, then the melody would be littered with jumps up and down, which would be a nightmare to handle. Setting the threshold to the perfect fourth is a good balance.
The complexities of the jump rule ensures that when you’re shifting upwards, the melody is actually going upwards. It would be confusing to the reader if there was a situation where we return from the elevated line down to the neutral line, while the melody is going upwards!
Another distinct alternative to the jump rule is to divide all the notes into distinct octaves: for instance, put any notes between C4 (middle C) and C5 on the neutral line, everything between C5 and C6 on the elevated line, and so on. I experimented with this, but found it very awkward when the melody straddles on the boundary between two octaves.
And that’s how the jump rule was created. So please experiment with this system, see if you like it!
If you’re an avid reader like me, you might have experienced this frustration with bookmarks.
You open up your book to the bookmarked page, but you aren’t sure where on the page you left off. So you go to the beginning of the page and start reading. But soon you realize that you’ve already read this paragraph, and the next…
A minor annoyance, fair enough. But I’d like to share a trick that neatly solves this problem.
Take any bookmark. (This doesn’t work as well if the bookmark has lots of contrasting colors)
Draw a line through the bookmark at somewhere around the 2/3 or 3/4 mark. Do this only on one side.
We’re done.
Now every time you stop reading, orienting and aligning the bookmark stores enough information that you can start exactly where you left off the next time you start reading. Examples:
I’m not sure whether I’m the first to come up with this or if it’s common knowledge elsewhere, but this trick has saved me a great deal of time and frustration. Hopefully you will find it useful!
To all Digsby users (ignore this post if you don’t use Digsby):
If you use Digsby with Facebook, you might have noticed that things behave strangely — the program pops up a window looking like this when it tries to connect to Facebook:
Then after you give it your credentials, Digsby still thinks you’re not logged in, and so on.
If you found this page via a google search, there’s a simple hack / workaround you can use to patch up this problem. Basically, instead of using the Facebook protocol to connect, we let Digsby use the Jabber protocol as a ‘proxy’ to connect to Facebook:
At this point, you’re done: Digsby should give you no more problems about Facebook.
Warning: the following is unnecessary and experimental! It might screw up the entire Digsby installation, forcing you to reinstall!
However, you can replace the Jabber icon with the Facebook one (this is for purely cosmetic purposes):
There you have it — hack accomplished:
Back when I created this blog in February 2010, I chose WordPress to host the text of the blog, Imgur to host my images, and drop.io to host all my downloadable files — as a free user of WordPress my abilities to store media directly on WordPress servers are limited. Here’s a screenshot of drop.io in 2010:
So far, WordPress has not corrupted a single one of my posts, neither has Imgur lost any of my many hastily photoshopped images. But some time in December, readers started emailing me telling me that my download links were broken. WHAAT?
Sure enough, when I clicked one of my own download links, all I got was a blank page telling me that their service had shut down last week without notice, and all the files have been deleted. Fml. I thought I could count on you, drop.io!
Well — not exactly without notice. In October, a month before closing down, they announced their closing down in a blog post. If only I had known this before everything was deleted.
I can’t say I’ve ever anticipated that such a popular service suddenly closing down, so I never made backups or mirrors or anything. Fortunately I had most of the files stored on my computer, but at least one or two of the files are lost forever 😦
With drop.io gone, I need a new file host:
This post is inspired by a series of Facebook discussions.
In this blog post I shall assume importance, interest and notability to mean the same thing. I shall also assume that lists are always well-ordered — that is, of any two elements in the list, one must come before the other.
Claim 1. It is not possible to rank the world’s people by importance.
Proof. Suppose the contrary, that there is a list of all of the world’s people ranked by importance. Then there must be some person at the end of the list (ie, the least interesting person). But this person is at the end of a list, which must give him some notability. Hence this person is no longer the least important person in the world. By contradiction, the list cannot exist.
Claim 2. It is indeed possible to rank the world’s people according to importance.
Proof. We show this by counterexample. Suppose the world has one person. Then there is only one possible list.
Objection 1. Then the list is impossible if the world has more than one person.
Reply. This is untrue. Suppose the world has two people: one person of very high importance, and the other of far less importance. Now we put them in a list. Clearly it does not matter that the less important person is at the end of the list. The same can apply if the world contained 3 people: two people of high importance and one person of low importance: nobody cares that the person is at the end of the list: it is true but that does not remove him from being at the end of the list. This works for 4 people, 5 people, n people, n+1 people.
Objection 2. You have not defined what importance means.
Reply. Importance is usually defined as a combination of wealth, power, achievements, and such. But it does not matter how we define importance. The only requirement is that the definition of importance of a person is affected at least partially by his position on the list: otherwise there is no contradiction.
Objection 3. How is the list constructed, then, if to give a person a rank on the list, one has to already know his position on the list?
Reply. The list can be constructed sequentially – that is, constructed using all factors but the list factor (the position on the list affecting notability). Then the list is rearranged when the list factor comes in and affects the notability. This is repeated until no more conflicts occur.
Objection 4. This is wrong. Suppose that there are three people in the world: one of great importance and two equally boring people. Of the second and third people (the two boring people), one has to be at the end of the list and the other at the middle. Then by the fact that the third person is at the end of the list, he is more notable than the second person, thus going up a place in the list. Then the situation plays out in reverse, forever vibrating between the two states. The list cannot exist.
Reply. Then the list can be constructed declaratively instead of procedurally – like solving a system of equations. If you put the person of great importance in the middle and the boring people at the two ends, then the list no longer vibrates.
Objection 5. But the point is that one person has greater importance than the other two, thus it doesn’t make sense to put him in the middle of the list.
Reply. Then we redefine the definition of importance and notability to be affected only by a person’s position in the list. This way, the list is stable.
Concluding objection. What is the point of such a list then?
The Rubik’s cube is a pretty cool and amazing toy, one that I’ve been spending a considerable amount of time playing with recently.
Methods for solving the cube vary. Beginner methods are easy to learn, but the downside is that they’re inefficient, usually taking a hundred moves or more to solve the cube. On the other hand, speedcubing methods often enable the cube to be assembled in fifty or sixty moves, but requires memorization of up to hundreds of move sequences, or algorithms.
The most common speedcubing method, usually called the CFOP or Fridrich method, requires memorization of about 70 different algorithms. Naturally, I didn’t want to do so much memorizing.
I learned to solve the Rubik’s cube from this site, which I think is a very good beginner tutorial. For the rest of this article, I will assume that the reader already solves the cube using this method, and furthermore I will use their notation and conventions. That is, this article would be a sort of extension to the tutorial.
The method provided is basically as follows:
The site gives 7 algorithms to solve the last layer (5 algorithms plus 2 mirror ones). As a result, any of steps 2-5 may require two sub-steps to do.
Here I provide 9 additional algorithms, making it possible to solve each of steps 2-5 in a single step. This makes a 4-step last layer with a total of 16 algorithms.
I will not be listing the original 7 algorithms: they are already available on the linked site.
In this step we want to form a yellow cross, that is, all four yellow edges are oriented so that yellow is facing up.
In addition to the three cases already covered, here’s a special algorithm for the fourth case:
R U2 R2 F R F’ U2 R’ F R F’
Next we make it so the corners are in the right place (although not necessarily the right orientation). The usual method for this is switching two corner pieces. However, in one case both corner pieces have to be swapped.
You can apply the algorithm twice, or you can use this algorithm:
L U2 R’ U L’ U’ R L U2 L’
Now we want the corners to all be oriented, that is: have yellow facing up on all of them. The only algorithm here that’s really needed is the one that rotates groups of 3 pieces clockwise (or counterclockwise) 120 degrees all at once. Any case can be solved with at most a combination of two of these.
The first two cases are when exactly three of the corners are facing incorrectly. The two algorithms needed are already covered.
Next, there are two similar looking cases where all four pieces are facing incorrectly:
R U R’ U R U’ R’ U R U2 R’
The other case is similar, but a little bit different:
R U2 R2 U’ R2 U’ R2 U2 R U2
There is one case where two diagonal corners are oriented incorrectly:
L B’ D2 B L’ U2 L B’ D2 B L’ U2
Finally there are two cases where the two adjacent corners are oriented incorrectly. Here’s one:
R’ U’ R U’ R’ U2 R2 U R’ U R U2 R’
The other one, which is basically the reverse:
R U2 R’ U’ R U’ R2 U2 R U R’ U R
The final step now is permuting the edges. There are two algorithms already, to rotate a group of three edges clockwise (or counterclockwise). The other two cases can be done in a combination of two substeps.
The first one, where edges need to be swapped oppositely:
R2 L2 D R2 L2 U2 R2 L2 D R2 L2
Or the other case where edges need to be swapped adjacently:
R’ U’ R U’ R U R U’ R’ U R U R2 U’ R’ U2
And this is it. We’re done!
Lately I’ve been quite busy and I’ve been spending less time on blogging as I would have liked. Indeed I’ve found myself with little time for reading books (which I borrow from the library and intend to read but never do so), or even study math problems. As of now I have books on calculus, number theory, geometry, organic chemistry, game programming, as well as a few novels lying on my desk, pretty much collecting dust and soon to be collecting overdue fees.
As the year’s almost over, there’s a certain rush to complete the last few assignments (especially the Language arts portfolio assignments which are given an entire term but everyone procrastinates them until the last two days before the deadline). There’s also a lot of studying for exams, which again most people complain about but do not spend enough time on (this includes me).
Also there has been some controversy over my score in the Euclid contest earlier this year, which I dare not discuss publicly. I’ve got my first relationship which I’m really happy about; dating is fun (but very unproductive and somewhat addicting). Probably involved in too many extracurricular school clubs, so I’m quite busy.
Over the spring break, I had the idea to start a computer science club at my school. I did some planning work and found some teacher support, and held the first meeting on April 16. Six people came to the first meeting. Not really knowing what to do, I talked about a fairly easy computer science problem.
As the club progressed, it changed unpredictably. At certain times there would be a group of experienced programmers, in which we would discuss more difficult (IOI-level) computer science problems; at other times the group would consist more of people with no programming experience in which I would be forced to abandon the more difficult problems in favor of teaching some programming basics. At other times nobody would show up, forcing me to cancel the meeting. The last computer science club meeting was held on May 26.
The club was clearly not working as well as I would have hoped, although it wasn’t a complete failure. It was moderately successful, given the circumstances.
For next year, I’ve heard about a grant for the school of a pretty large sum of money to the robotics department, and my teacher suggested me to add robotics to the club.
There are several reasons I think that the computer science club didn’t do as well as I’d hoped. I’ve been involved in the anime club, debate club, and the environment club so I’ll compare the computer science club to other school clubs that I’m familiar with.
Or perhaps there is just not enough interest in computer science in my school, as just five people wrote the CCC in February, and a handful of people show up to write a math contest.
Since it’s been suggested that I incorporate robotics into the club in the future, I’d give my thoughts on that here as well.
The robotics club would build robots for competitions (WorldSkills and others which I don’t remember). Quite a lot of money is required for equipment, and this money is available (in comparison to computer science which can be done for free).
My biggest problem with robotics is that robotics has very little to do with computer science. Both involve some degree of programming, but that aside they are completely different. Thus, my knowledge and experience in computer science would be irrelevant for robotics, and there’s no reason I should lead a robotics club. Also because of this, the idea of combining computer science and robotics is absurd.
If there’s going to be a robotics club next year, it’s going to be very different from the computer science club. We’re predicting that a considerable amount of fundraising would be necessary to pay for the competitions. This has mixed outcomes. For one thing, there would be better dedication in members, and individuals would be more motivated to come since so much money is on the line. On the other hand, the entry barrier would be even higher: it would be very difficult if not downright impossible to join the club after it has started.
I still don’t know whether to re-attempt the computer science club next year, or attempt starting a different club, or not attempt to start anything at all.
Today I competed in an interesting event, the University of Calgary’s SET challenge (also known as the Amazing Race). This is a competition involving several areas of science, including mathematics, biology, chemistry, and computer science.
The nature of the contest was different from anything I’ve competed in before: students competed in teams, each team containing six people working together. The groups were to quickly complete several different activity stations, running around the university campus going from one station to the next to minimize their total time.
There were 25 teams competing in this event, 4 of them from my school. Two of them took first and third place respectively, together winning $1100 for the school. I was put into a team consisting of three grade 10’s, and three grade 11’s. There were no grade 12’s on my team. Unfortunately, our team was not one of the two that won the top three.
The competition involved mathematics and computer science, which I was able to contribute with; as well it contained biology, kinesiology, chemistry, and physics, much of which I knew nothing about. Having no grade 12’s, there were certain problems (especially with biology) which nobody in the group knew how to do.
At eight-thirty in the morning the event started with a presentation from an engineer working at NASA, who spoke about his work on aircraft. Near the end of the presentation there was a question period in which I asked him about how an average person could best support NASA and the aeronautics program. I don’t think he actually answered my question.
The race began at nine. The first activity was to produce the number 36 using a given set of cards in some way – a version of the game 24. For example, given the set [1,1,5,8,9,10] one could arrange the cards into ((8*9)/(10/5))*(1/1) giving 36. We were required to repeat this four times each for a set of six, five, and four cards, so twelve times in total.
Computer science was the next activity. Although the problems were referred to as computer science, no computers or programming was involved; we simply had to manually find the numerical answer to three problems with pencil and paper. Since the competition we had lost or thrown away the problem papers, or used them as scrap paper, I’m unable to reproduce them exactly here on my blog.
Problem one was a simple combinatorial problem supposedly involving dynamic programming. The problem was to enumerate (count) how many paths there were on a street map going from the start, in the bottom left corner, to the destination, in the top right corner (how many ways to travel from start to finish). You were only allowed to travel north and east (you cannot travel in a way that will take you further from your destination). The solution was to go bottom-up and write next to each vertex the number of paths to that vertex; the number for a new vertex was the sum of its adjacent vertices. The answer could be calculated after repeating this process about 50 times.
The next problem was the shortest path problem, for which a plain-english version of Dijkstra’s algorithm is given (although it would probably be easier just to do it by brute force than to try to follow their steps). The problem is actually described as finding the shortest path from your server to Google’s server. Being a relatively small graph manually applying the algorithm a few times gave the answer within a minute.
The final computer science problem was a bit trickier: given a string of characters encrypted using a Caesar substitution cipher (each letter shifted a constant number of times), decode it. For example “abcd” shifted by three would be “cdef”. Initially I thought there was no better way than brute force (trying with shifting by 1, by 2, and so on). However there was a word encoded as “xffu”, and since ‘f’ had to replace the same letter twice in the four letter word I guessed that ‘f’ was ‘o’, giving a shift of 17, and “xffu” would be decoded as “good”. Decoding the rest of the string was trivial.
After the computer science problems, the next activity was biology related. Biology being not my strongest area, I didn’t really understand most of it. My team struggled somewhat here, as no one really knew how to translate between DNA and RNA and proteins. We were eventually forced to leave as the time limit of twenty minutes passed (whether you solved any problems doesn’t really matter after then).
Next up was mathematics, which I’m a bit better at. The problems were not especially difficult: the first and second were simple coordinate geometry; the third was a system of three linear equations; the forth was an easy circle area problem; the fifth was about manipulating the equation of an ellipse; the sixth and last was the expansion of 
I actually had some trouble with the system of three linear equations. Another team member and I were working on it and we constantly made arithmetic errors in the somewhat long and tedious calculation. We alternated between elimination, substitution, matrices, etc, but eventually got it correctly.
Answers to the six problems were used to construct a mysterious sequence, which turned out to be the Fibonacci numbers (5,8,13,21,34,55). Probably as an attempt to avoid pattern-finding, the problems were given out two at a time and the answers not revealed in order (for example the answer to the first problem was the forth number in the sequence). This wasn’t very good since only two people were able to work on the problems at a time.
The final problem, given after finding the previous six problems, was really surprising for me. It simply asked to find ten prime numbers between 5100 and 5300 (there are 21). I’m pretty sure there’s no better way here than brute force (we only had two non-programmable calculators). Since we were almost out of time by then we did not attempt this problem, which is kind of dubious to find on a time-constrained math contest.
After that was an activity with kinesiology which I don’t really remember much about. I think it was just a multiple choice test. A one-hour lunch period followed.
In the second leg of the competition we began with a series of chemistry labs that for the most part I did not understand; I won’t try to describe them here.
The final activity we participated in before the time ran out was the construction of a boat out of toothpicks and aluminum foil. The team was given a large sheet of aluminum foil and twenty toothpicks, to build a boat out of, to hold as many pennies as possible before sinking. Our team settled on a triangular design reinforced with some toothpicks; although we constructed it carefully it was only able to hold about a hundred pennies (out of a possible 500 pennies for maximum points).
Apparently there were two more activities that we did not have time to complete.
One thing today that was unanimously agreed upon to have sucked was the waiting times for certain stations. As an activity could only support a limited number of teams at a time, many teams would begin to queue up behind the activity. This resulted in a waiting of (I’m guessing) around 20 minutes for the kinesiology activity, and an hour for the chemistry activity. The waiting also magnified the time differences between teams, as a team being ahead by seconds at the arrival of a lab could be ahead by twenty minutes by the end of the lab. This was not fun, considering that it was still a race. It was ironic seeing teams sprinting for the chemistry labs after the lunch break, only to find a massive line up behind it and waiting a good portion of the afternoon to get it over with.
Consequently the first teams did not have to suffer the waiting times and thus progressed further ahead of those who did.
I think that overall this was a fun event (even though I had to miss the qualification round of the Google Code Jam today). It also brings to my attention how unbalanced my skill sets are, in favor of math and computer science.
Lucky's Notes 
![blog post](http://i.imgur.com/P2dIV.png" alt="" title="Hosted by imgur.com" />){kind=link}