I’ve start a new challenge, completing one game a month for the next 12 months via One Game a Month! The challenge itself is pretty simple, create one game a month for the next 12 months. The idea is to create small games with interesting mechanics and to continually release something new every month. Each month a new them is given with a keynote and you can create any game that you want that somehow incorporates the keyword for that month. You can read more about the site and the rules over at their website.

The theme for this month was Childhood. I didn’t have a lot of time with clients and generally deciding to do this with about one week left in the month, so I decided to pick the simplest childhood game I could find and do a quick remake. The game of course with the simplest mechanics I could recreate was Pong!

I have decided that 3d is way to time intensive for the amount of free time that I have these days, so I started doing some research into 2d game engines. I could have continued using Unity for this, but I found their 2d engine to be a little bloated and buggy which I attribute to the fact that Unity was originally built for 3d. I want to find something that was 2d and also cross platform, bonus points if it was open source.

After a little digging, I came across a game engine called HaxeFlixel and a fell in love! This game engine is pretty simple to install, works great on Mac and Windows, and deploys to a large amount of different platforms including web and mobile. The only thing that it doesn’t support that I would love to play around with is console development. This is because most consoles require you to sign an NDA before giving access to their SDK’s, and this prevents any custom coding from being included in the open source code base. I’ll be doing at a future time about HaxeFlixel itself, and how to create a simple game using this amazingly simple game engine.

I built this game probably in less than 24 hours total worth of time. That includes getting HaxeFlixel installed, setting up the development environments, creating some simple art, and coding everything. I ended up dropping a bunch of features that I wanted to include due to landing a pretty large client right after deciding to take on the challenge. Hopefully I will be able to do something a little more involved next month, but not bad for the amount of time that I had to build it!

Give it a play and let me know what you think in the comments.

So recently Microsoft made it public news that they are not going to be creating another full version of Windows past Windows 10. They are instead going take a “progressive enhancement” approach where they will continually improve upon what the new OS adding new features and fixing bugs along the way. I actually think this is going to be a good move on Microsoft’s part and I look forward to seeing how they work this into their business as a whole.

Windows 10 will be the last version of the operating system to be numbered, says Microsoft executive.

This was my first SRM from an actual weekly competition! Checkout the problem statement.

So this problem asks us to take a list of positions, and a number that let’s us know how far we can jump. We have to figure out how many positions we can reach within the array based of of the number given. So, for instance, if we are given the positions array [1, 2, 3, 7, 9] and the number 1 for our max jump distance, we would be able to reach 1, 2, and 3 but not 7 and 9 as there are no numbers within 1 of these. So here was my first attempt which took around 40 minutes (This is the one that I submitted):

public static int countReachableIslands(int[] positions, int L) {
// first attempt
int islands = 0;
boolean[] canReach = new boolean[positions.length];
canReach[0] = true;
for (int i = 0; i < positions.length - 1; ++i)
for (int j = i + 1; j < positions.length; ++j)
if (Math.abs(positions[i] - positions[j]) <= L) {
canReach[i] = true;
canReach[j] = true;
}
for (boolean reachable : canReach ) {
if (reachable) ++islands;
}
return islands;
}

Here’s my second attempt, which took about 20 minutes:

// second attempt
public static int countReachableIslands(int[] positions, int L) {
int islands = 0;
boolean[] canReach = new boolean[positions.length];
canReach[0] = true;
for (int i = 0; i < positions.length - 1; ++i)
for (int j = i + 1; j < positions.length; ++j)
if (Math.abs(positions[i] - positions[j]) <= L) {
canReach[i] = true;
canReach[j] = true;
}
for (boolean reachable : canReach)
if (reachable)
++islands;
return islands;
}

And the last attempt, 2 minutes:

// third attempt
public static int countReachableIslands(int[] positions, int L) {
if (positions == null || positions.length == 0) return 0;
int islands = 0;
boolean[] canReach = new boolean[positions.length];
canReach[0] = true;
for (int i = 0; i < positions.length - 1; ++i)
for (int j = i + 1; j < positions.length; ++j)
if (Math.abs(positions[i] - positions[j]) <= L) {
canReach[i] = true;
canReach[j] = true;
}
for (boolean reachable : canReach)
if (reachable)
++islands;
return islands;
}

As you can see, all the attempts were just about the same! I really thought I had found the optimal solution to the problem this time on the first go round, and it did indeed pass all the test cases that came with the problem. However this solution was challenged in the challenge phase and I lost all my points. I couldn’t find out how to view the challenge parameters either so I am stuck not knowing what the fail case was. I will update this post once the match editorial is released in the next few days. In any case, it was fun taking a stab at the SRM challenge and I am looking forward to the next one! I can’t wait to dig further into my Algorithms book as well so that I can start getting into the harder problems.

Unity 5.02 has just been released with an impressive amount of bug fixes!

The Unity 5.0.2 release brings you a new feature, several improvements, few changes and a large number of fixes. Read the release notes below for details. For more information about the previous main release, see the Unity 5.0 Release Notes.

I have solved another TopCoder problem. I am starting to get better at these as this one took a lot less time to understand. I ended up getting my first attempt wrong on some test cases and couldn’t figure out why at the time. I think it was because I did the first attempt in cpp and spent most of the time trying to remember how to use it. Think I will stick with Java for the rest of them as this will allow me to focus on coding the solution and keep me from tripping up on the language. Here’s the problem statement:

Dmitry likes TopCoder Single Round Matches. Once, he registered for an SRM and was waiting for the coding phase to begin. To entertain himself while waiting, he decided to play the following game.

He makes a pile of cards, and on each card, he writes the number of an SRM in which he has competed. No two cards contain the same number. He then takes turns until the pile is empty. Each turn consists of the following sequence of actions:
Dmitry chooses an arbitrary card from the pile. Let A be the number written on this card.
The card with number A is removed from the pile.
If the pile contains a card with number A-1, that card is removed from the pile.
If the pile contains a card with number A+1, that card is removed from the pile.
The game is finished when the pile becomes empty. It’s fun to play the game, so Dmitry wants to spend as much time as possible playing it.

You are given a int[] cards containing the numbers written on the cards in the pile before the start of the game. Return the largest possible number of turns in which Dmitry can finish the game.

Constraints
– cards will contain between 1 and 50 elements, inclusive.
– Each element of cards will be between 1 and 499, inclusive.
– All elements of cards will be distinct.

So basically we needed to play the game of removing a card and any other cards with a value within 1 of the value of the current card as long as possible. The best way to play the game longer is to limit the amount of cards that you remove each turn. The most you can remove is 3 and the least is 1, but if there are 3 cards that are within 1 of each other, say with values {1,2,3}, the least you can remove is 2 cards ( either 1 and 2, or 2 and 3 ). So it is best to always shoot for this case of removing either 1 or 2 cards. To do this, we can sort the array and always test the beginning as this will always be the least valued card in the deck. We would either just remove the first card, or the first and the second at most.

First attempt: 1h

#include <vector>
#include <algorithm>
using namespace std;
class SRMCards {
public:
int maxTurns(vector<int> cards) {
int turns = 0;
// sort the array
sort(cards.begin(), cards.end());
auto it = cards.begin();
// run through to see how long we can play
while (!cards.empty()) {
if ((it + 1) != cards.end() && *(it + 1) - *it == 1) {
cards.erase(it + 1);
}
++it;
++turns;
cards.erase(cards.begin());
}
return turns;
}
};

This was my initial approach. I spent the majority of the time fumbling over the c++ language. I forgot how long it’s been since I have actually done any coding in this language. This failed some of the test case and I couldn’t figure out why. I thought it was because I had misunderstood the problem statement so I looked at the editorial. Low and behold my understanding of the statement was correct, but I had overcomplicated the implementation. I think this is partially because I hadn’t really used vectors ever in c++ and I just kind of felt it out. Here’s my second attempt:

Second attempt: 20m

import java.util.Arrays;
public class SRMCards {
public static int maxTurns(int[] cards) {
int turns = 0;
Arrays.sort(cards);
for (int i = 0; i < cards.length; i++) {
if (i < cards.length - 1 && cards[i+1] - 1 == cards[i]) {
++turns;
++i;
}
else
++turns;
}
return turns;
}
}

I went back to java and knocked out a second attempt. This time instead of removing items from the array, I just incremented the counter to move an extra position. This made for much a more concise implementation.

Third attempt: 1m

import java.util.Arrays;
public class SRMCards {
public static int maxTurns(int[] cards) {
int turns = 0;
Arrays.sort(cards);
for (int i = 0; i < cards.length; ++i) {
if (i < cards.length - 1 && cards[i+1] - cards[i] == 1) {
++turns;
++i;
}
else
++turns;
}
return turns;
}
}

Having fully understood the problem and implementation, the third attempt only took me 1 minute to code! Not a bad improvement, I am looking forward to the next practice problem. Actually today I am hoping to get my chance to participate in my first live SRM!

GitHub has started the early phases of rolling out a solution for git repositories that contain large files. It looks pretty interesting and takes git one step closer to being a more attractive solution for companies that track huge files or even binaries that can’t be diff’d. This would be especially useful for game assets. I look forward to keeping track of the progress!

Git Large File Storage (LFS) replaces large files such as audio samples, videos, datasets, and graphics with text pointers inside Git, while storing the file contents on a remote server like GitHub.com or GitHub Enterprise.

I completed my first practice problem not too long ago. I chose this problem at random in the topcoder arena after reading through Planning an Approach to a Topcoder Problem: Part 1. In the write up, the author gives the first task of picking any problem in the practice rooms, and solving it 3 times. The first time you solve it represents the time it takes you to solve the problem with no information about it, the second time is the time it takes minus the time it took you to understand the problem, and the third time represents your potential. So with that in mind, here is the problem statement:

Problem Statement

You have a certain amount of money to give out as a bonus to employees. The trouble is, who do you pick to receive what bonus? You decide to assign a number of points to each employee, which corresponds to how much they helped the company in the last year. You are given an points, where each element contains the points earned by the corresponding employee (i.e. points[0] is the number of points awarded to employee 0). Using this, you are to calculate the bonuses as follows:

– First, add up all the points, this is the pool of total points awarded.
– Each employee gets a percentage of the bonus money, equal to the percentage of the point pool that the employee got.
– Employees can only receive whole percentage amounts, so if an employee’s cut of the bonus has a fractional percentage, truncate it.
– There may be some percentage of bonus left over (because of the fractional truncation). If n% of the bonus is left over, give the top n employees 1% of the bonus. There will be no more bonus left after this. If two or more employees with the same number of points qualify for this “extra” bonus, but not enough bonus is left to give them all an extra 1%, give it to the employees that come first in points.

The return value should be a , one element per employee in the order they were passed in. Each element should be the percent of the bonus that the employee gets.

After reading through this multiple times, I understood what I needed to do. Basically you get an array of int values. Using these values you have to determine out of 100 how much bonus percentage each employee gets. There are no partial percentages ( i. e. integers not floats ), so the remainders should be stripped away and redistributed at the end. This is done by taking the remainder and giving it to the highest rated employees. If there are multiple employees with the same rating at this point, we should give the bonuses to the employees that came first in the array with the highest value (so if there are 4 with the same rating and 2 points left over, give the first two employees one extra point). So with the understanding in mind, here is the first attempt:

// first attempt, 3 hours
public class Bonuses {
private Boolean inArray(int[] array, int value) {
for(int i = 0; i < array.length; ++i) {
if (array[i] == value) return true;
}
return false;
}
public int[] getDivision(int[] points) {
int[] divisions = new int[points.length];
int tally = 0;
int total = 0;
for(int i = 0; i < points.length; ++i) {
total += points[i];
}
for(int j = 0; j < points.length; ++j) {
divisions[j] = (int)(Float.valueOf(points[j]) / total * 100);
tally += divisions[j];
}
tally = 100 - tally;
int[] bonusEmployees = new int[Math.min(tally, points.length)];
for (int i = 0; i < bonusEmployees.length; ++i) {
bonusEmployees[i] = -1;
}
for (int i = 0; i < bonusEmployees.length; ++i) {
int currentMax = 0;
for (int j = 0; j < points.length; ++j) {
if (!inArray(bonusEmployees, j) && currentMax < points[j]) {
currentMax = points[j];
bonusEmployees[i] = j;
}
}
}
while (tally > 0) {
for (int x = 0; x < bonusEmployees.length && tally > 0; ++x) {
divisions[bonusEmployees[x]] = divisions[bonusEmployees[x]] + 1;
--tally;
}
}
return divisions;
}
}

So my first attempt took an embarrassingly long amount of time . I got caught up on redistributing the the remainder. I first needed to get the total from the points array which indicates the employee and the percentage of the bonus they should receive. I then setup another array to keep track of the employees have received a portion of the remainder. I then run through the divisions array again and pull out the employees that need to receive the bonus and store them in the bonusEmployees array. And finally I used bonusEmployees array to go back and add to the division array. This passed all the test cases given but I was sure there was a more efficient approach. At this point I read the editorial for the match and attempted the problem again.

// second attempt 20 minutes
public class Bonuses {
private Boolean inArray(int[]arr, int value) {
for (int n = 0; n < arr.length; ++n) {
if (arr[n] == value) return true;
}
return false;
}
public int[] getDivision(int[] points) {
int [] divisions = new int[points.length];
int remainder = 100;
int total = 0;
for (int point : points) {
total += point;
}
for (int i = 0; i < points.length; ++i) {
divisions[i] = (int)(Float.valueOf(points[i]) / total * 100);
remainder -= divisions[i];
}
int nextUpdateIndex = 0;
int[] updates = new int[remainder];
for (int x = 0; x < updates.length; ++x) updates[x] = -1;
while (remainder > 0) {
int max = 0;
int index = -1;
for (int j = 0; j < divisions.length && remainder > 0; ++j) {
if (max < divisions[j] && !inArray(updates, j)) {
index = j;
max = divisions[j];
}
}
divisions[index]++;
remainder--;
updates[nextUpdateIndex] = index;
nextUpdateIndex++;
}
return divisions;
}
}

A wrote the solution much faster this time. After reading the editorial, I realized that the remainder would always be smaller than the input array so I was able to eliminate a loop. Everything else ended up staying relatively the same. The code got a little cleaner this time, but I was still hung up on how to keep track of the employees that needed to receive the remainder. I then checked out some of the other solutions to the problem and saw the obvious solution. See my last attempt:

// final attempt, 3 minutes
public class Bonuses {
public int[] getDivision(int[] points) {
int [] divisions = new int [points.length];
int total = 0, remainder = 100;
for (int p : points) {
total += p;
}
for (int i = 0; i < points.length; ++i) {
divisions[i] = points[i] / total * 100;
remainder -= divisions[i];
}
while (remainder > 0) {
int index = 0, max = 0;
for (int x = 0; x < points.length; ++x) {
if (points[x] > max) {
max = points[x];
index = x;
}
}
remainder--;
divisions[index]++;
points[index] = 0;
}
return divisions;
}
}

Just lower the point value of the employee that already received the remainder in the points array! That way, the next time through the final loop no longer needs any extra checks to keep track of which employee received the bonus as the max will keep track of this for us. Since we will only go through the points array once ( as remember the remainder will always be less than the number of employees ) setting the last employee to receive the remainder’s point value to 0 effectively ensures that they won’t receive a bump more than once. By the time I had come to this solution, my time to implement dropped to 3 minutes, way down from 3 hours the first time!

I am very happy with the results of this approach and I look forward to replicating these improvements on some other problems. This was one of the easy ones that didn’t require any fancy algorithms, but the plan is to work my way up to the hard questions as I learn more about the algorithms and even start participating in some of the weekly competitions to start ranking.

For those that don’t know me, I never actually finished school. I was fortunate enough to be able to land a real programming job at the fresh young age of 20 after a 6 month internship where I learned just about everything about programming that I could. This job was at an animation studio and the tasks were so varied that I was introduced to many aspects of programming from server side scripting, to networking computers, to special effects.

Now that I am a professional developer, I am learning that there are some fundamentals that I skipped along the way that are pretty important. The main thing being some of the fundamental algorithms. I am now on a quest to expand my programming ability by learning some of the things that I missed. In my search for how to approach this large topic, I found a website called topcoder where they offer a few interesting things. One is that they actually pay people to come on and complete various challenges to win real money! The thing that interests me is that they have a section where you can go on and do challenge questions that test your ability to code and come up with algorithms. These challenges are presented as word problem with various constraints. Basically you have to take the problem, create a certain class with a certain function that is detailed in the problem, and give the correct output based of the input that is given. ( I may do a post in the future about how to get started doing this as I was a little confused myself on how to navigate around the site and find the challenges )

I am now in the process of working through some of the challenges and I will be posting my progress here for my reference and hopefully I can help out some other people along the way. They also have a section of tutorials that you can learn from here that I am working my way through. I think that a hands on approach is the best way to learn, as well as taking the time to analyze my approach and detailing why I made certain decisions. I think in doing this I will be able to pick up the algorithms I am missing in no time!

So I have chosen my first project, an Asteroids game! Asteroids is an old-time favorite and one of the most successful arcade games of it’s time. I chose this style of game because for one it’s mechanics are simple to wraps ones head around as a developer, and because it’s so simple that it offers a bunch of opportunity for extending with new ideas. This is going to be a mobile game released on iOS and Android, and I am hoping to create an HD look for it. However the style of the game could change as the project matures. I do have some idea of where I would like to take this game, maybe I will include the game design document in a future update.

Progress Report

So I have already been working on this over the past week, here is a little video demo’ing my progress:

As you can see it’s not too much to look at visually, but it’s a start. The main hurdle was figuring out a system for replicating the asteroids style screen wrap effect for the ship. To do this I created a block in unity and scaled it to encapsulate the viewable area. I then disabled it’s mesh renderer so that it’s hidden in scene. I used a default cube for this and not a box collider for debugging purposes, so that I could re-enable the mesh to see if the bounds were where I wanted them.

Also the background moves slightly in the opposite direction of the ship. This is based off of the velocity of the ship scaled by a speed multiplier. The background itself is a generated sphere so all I had to do was rotate it as the ship moves.

Major Problems Solved

Using the WorldBounds object as a trigger, I am able to fire OnTriggerExit when the ship leaves the predefined space. I’m pretty sure I did this in an overcomplicated way, but I took it as a challenge to write a function that would work in any situation. Basically the function repeats a value in a range, so let say we have a lower bound of 2 and an upper bound of 12. If you pass in 15 the return value would be 5 and if you passed in -3 the return value would be 7. The function is ran on the X,Y,Z of the ships objects transform using the WorldBounds as the min and max values, and then wraps the ship in the axes that need it. See the implementation below:

void OnTriggerExit(Collider other) {
var otherPos = other.gameObject.transform.position;
otherPos.x = repeatValue (minBounds.x, maxBounds.x, otherPos.x);
otherPos.y = repeatValue (minBounds.y, maxBounds.y, otherPos.y);
otherPos.z = repeatValue (minBounds.z, maxBounds.z, otherPos.z);
other.gameObject.transform.position = otherPos;
}
/// <summary>
/// Wraps a value within bounds
/// </summary>
/// <param name="min">Minimum bound</param>
/// <param name="max">Maximux bound</param>
/// <param name="value">Value to repeat within min and max</param>
/// <returns>The value repeated within the bounds</returns>
private float repeatValue(float min, float max, float value) {
// make sure min and max are correct
float _min = Mathf.Min(min, max);
float _max = Mathf.Max(min, max);
// if we are within the bounds, no need to repeat
if (value >= _min && value <= _max)
return value;
// else store the sign
float minSign = min > 0 ? 1 : -1;
float maxSign = max > 0 ? 1 : -1;
float newValue;
if (minSign == -1 && maxSign == 1)
{
// set all values to positive space
float newMin = Mathf.Abs(_min);
float newMax = Mathf.Abs(_max);
newValue = Mathf.Abs(value);
float newRange = newMin + newMax;
// find the repeated value and set back to regular space
newValue = mod(value + newMin, newRange) - newMin;
}
else if (minSign == 1 && maxSign == 1)
{
if (value > min)
newValue = mod(value, _max) + _min;
else
newValue = _max - mod(_min, value);
}
else // both negative
{
if (value < min)
newValue = mod(value, _max) + _max;
else
newValue = _min - mod(_max, value);
}
return newValue;
}
/// <summary>
/// Custom mod used to mirror python mod functionality
/// </summary>
/// <param name="k"></param>
/// <param name="n"></param>
/// <returns></returns>
float mod(float k, float n) { return ((k %= n) < 0) ? k + n : k; }

As you can see, I have written a custom modulus function. This is because I wrote the initial function in python for quick testing. Once I got this working with all the test cases, I re-wrote the function in C# for Unity, only to find out that the return values from the function were different. Turns out the Python and C# treat the mod ( % ) operator differently, but luckily I found a solution on Stack Overflow for replicating the python functionality in c#.

Update
Here is the original python code if you are interested with the test cases:

def repeatValue(minBound, maxBound, value):
# make sure that our values are correct min and max
_min = min(minBound, maxBound)
_max = max(minBound, maxBound)
# if value are in bounds, return the value
if _min <= value <= _max:
print ('default version')
return value
# if not lets find the correct value
minSign = 1 if minBound > 0 else -1
maxSign = 1 if maxBound > 0 else -1
newValue = None
if (minSign == -1 and maxSign == 1):
print ('first version')
# move into positive number space
newMin = abs(_min)
newMax = abs(_max)
newValue = abs(value)
newRange = newMin + newMax
newValue = ((value + newMin) % newRange) - newMin
elif minSign == 1 and maxSign == 1:
print ('second version')
if value > _min:
newValue = value % _max + _min
else:
newValue = _max - (_min % value)
else: # both negative
print ('third version')
if value < _min:
newValue = value % _max + _max
else:
newValue = _min - _max % value
return newValue
###
# here are the test cases
###
print(repeatValue (-10, 10, 15)) # should be -5
print(repeatValue(-10, 10, -17)) # should be 3
print(repeatValue (10, -10, 16)) # should be -4
print(repeatValue (10, -10, 5)) # should be 5
print(repeatValue (10, -10, -3)) # should be -3
print(repeatValue (10, 20, 23)) # should be 13
print(repeatValue (10, 20, 7)) # should be 17
print(repeatValue (-10, -20, -23)) # should be -13
print(repeatValue (-10, -20, -7)) # should be -17
print(repeatValue (-13.4, 14.4, 15.4)) # should be -12.4
print(repeatValue (-13.4, 14.4, -14.4)) # should be 13.4

Assets Used

The assets I have in there now are all from the Unity asset store. There was a sale over the past few days called the Tomorrow Sale which pretty much was exactly what I needed. Everything on sale had something to do with space. I was able to purchase packages for asteroids, the space background, ships, and even special effects. I spent less than $100 total for everything, here are the assets that I purchased:

As you can see, not a bad deal for this many assets! I got pretty much everything I need to get the player ships, asteroids, weapon visual effects, and backdrops built. I still may need to pick up some assets for the enemies and sound effects later.

Next Steps

Next on the agenda I will continue working on the prototype. I think that the thing that will keep this interesting for me will be actually having new playable progress every week. I took a game design class in San Francisco about a year ago, and the most important take away for me was that successful games are made fun first. They figure out what it is that is fun about the game, and then extend upon it from there visually. I think for now I will focus on the controls and fine tuning the movement of the ship and the firing mechanics. I also want to start getting some builds onto mobile to start doing some actual on device testing. At that point I will reach upon you guys to see if anyone out there would be interested in being part of the ‘alpha’ builds!

Here’s a list of what I would like to accomplish for next week:

Add thrusters to ship

Add shooting fx

Add asteroids to destroy

Add asteroids destruction effect

Add link to game design document

Any thought’s, questions, or feedback? Let me know in the comments!

Welcome to my tech blog, where I will ramble on about countless software development projects, tech innovations, and general news that interests me. Still here? Well read on to find out a little more about me and my site.

My name is Deus Duke and I am a software developer from Tennessee. I recently moved to the Bay Area in November ‘13 which to me was a dream come true being a software developer. It’s amazing to go from living in a slower place, to being in the middle of where all the new and innovative technologies are dreamed up and created. Seams like every day there is a new company being bought, or some sort of new app being created and the majority are coming right out of San Francisco. I have worked in a few different industries include computer animation, hospitality, and fashion. I have been a software developer for the last 7 years. I started off in desktop applications mixed with tool and pipeline development and server scripting, and have landed in my current specialization of mobile tech. Currently I am heading up a mobile web team at a fashion / beauty company ( Check out my LinkedIn to see which one, maybe send me a connection request as well ). On the side I also dabble in native mobile development for iOS and Android, and also game development. I find game development to be challenging and exciting, and it also give me a chance to brush up on my 3D skills I picked up at the animation studio I worked at.

So why a blog you ask? Well there are a couple reasons. I needed to have a place to store my projects and build up my tech portfolio. I fall into the category of starting projects that I never finish. My hope is that with this blog, I can set some weekly goals and hopefully start to see some of my personal projects through to completion. Hopefully it will give me more of a sense of dedication when I know that the internet world is tracking my progress, and at the very least I will have to make enough progress on my projects to post about once a week.

My goal for this blog is to be a tech / software development portal. I am mostly interested in tinkering with mobile and mobile game development. I’ll be posting about my first project which has already started in my next post so stay tuned! I will also be posting helpful tips here and there that I pick up, as well as general news that excites me on random topics, like GitHub’s recent announcement about supporting LFS.

Thanks for suffering through my first post with me. There will be many more to come, and I am sure my writing skills will improve with time so please bear with me. Any thoughts or questions? Post suggestions? Feel free to let me know in the comments below!