It’s a simple game in all aspects, but I’m still happy with the result. The main goal for this game has been achieved – create a game, finish it, and make it available on the Play Store for all to enjoy!

Throughout the process, I have learnt many many things – some which I have started to blog about, others which are still blog posts yet to be written.

So, if you feel like playing a simple game on the first day of 2014, head over to the Play Store and give Mr. Tiddles a whirl

ps. this is a cross-post from: http://dx3.psychopyko.com/

From her talk, I decided to try two of the ‘Productivity Hacks’ that I felt was most applicable to me: Pomodoro and Inbox Zero.

Neither of these were new to me, though I had never sat down and gave either a serious attempt – mainly because I was unconvinced with at least one aspect of each. However, Kris was very convincing so this time I decided to give each a decent chance and see how it would go.

Pomodoro Technique

If you’re unfamiliar with the Pomodoro Technique, the concept is simple:

1. Decide on the task to be done
2. Set the pomodoro (timer) to 25 minutes
3. Work on the task until the timer rings; record with an x
4. Take a short break (3-5 minutes)
5. Every four “pomodori” take a longer break (15–30 minutes)

The idea behind the Pomodoro Technique is to increase your focus in the 25 minutes (get more stuff done) but also have breaks in between to prevent burning out.

What prevented me from trying it earlier?
As a developer, the best thing that can happen is to get into the flow; the worst is to be disrupted from this flow. My thought was: with a forced 5 minute break every 25 minutes, this would surely break my flow!

What did I find?
Suprisingly, I found the 5 minute breaks didn’t break my flow in the traditional sense. Yes, the alarm went off, stopping me from typing that extra line or two. However, because it was a planned break I was able to start where I left off almost immediately.

In fact, the feeling of “Just 5 more minutes and I can keep coding” helped greatly with concentrating and getting back into the flow easily.

Additionally, because 25 minutes of no distraction is a concrete goal, it was easy to stick to and made concentrating and focussing on the task at hand much easier.

A couple of tips (that helped me a lot, in no particular order)

• Use a timer, don’t just look at the clock. There are lots of free online timers (eg. http://tomato-timer.com)
• Work so you can’t see the countdown, an alarm will go off when time’s up
• Close the usual things that you know will distract you, for me it is email. Other possible distracitons: twitter, instant messaging, facebook etc
• Know what your ideal environment for getting stuff done and get into it! eg. I find playing music helps prevent my mind from wandering
• Instead of checking email/facebook in the 5 minute break, go and stretch your legs, grab some water, walk away from your computer!
• Before you start your first Pomodoro for the day, take time to do all the usual things that distract you (facebook, email etc). Once you start your Pomodoro, that’s it, no more!
• Stick to it. Really try and conciously avoid distractions. There should be no reason that you need to check email or facebook in these 25 minutes. Don’t open them at all.

Inbox Zero

It’s about how to reclaim your email, your attention, and your life. … It’s not how many messages are in your inbox – it’s how much of your own brain is in that inbox. Especially when you don’t want it to be. That’s it.
~Merlin Mann. Inventor of the ‘Inbox Zero‘ concept

What prevented me from trying it earlier?
My original email inbox workflow would be to read messages as they come in, and leave them in the inbox marked as read. For the ones that needed attention, I’d star them or leave them unread. In my mind, as long as I had an unread count of zero I had, in my own way, achieved Inbox Zero.

However, even though I had already read and processed the emails, to some degree they were still on my mind. Each time I opened my email, I would see a full inbox (of read emails) and have to think a bit to find the one I needed.

What did I find?
After a few times of failing to find important emails, Inbox Zero seemed like it deserved a try. It was a big leap. I had 9000+ emails in my inbox, but I bit the bullet and went ahead. I selected everything in the inbox, labelled them “DMZ” and then archived them. The next 20 min or so was spent cleaning up old filters, creating some new labels to help with organisation and finally I was at Inbox Zero!

Since then, I’ve had on average 3-5 emails in my inbox (so not quite Inbox Zero) but it has definitely made a huge difference. Although I never realised it, simply having old emails sitting in my inbox was adding to my mental load. Now, for emails to remain in my inbox there needs to be a good reason, otherwise they are archived or get moved to a different label.

It was such a huge difference (one that was not anticipated) that I dreaded opening my work email (which still had the thousands of old/read emails sitting in the inbox). Thus, I found some time and also archived all the emails. Now it longer gives me a headache opening either of my inboxes

Couple of tips (these are from Gmail, but should be somewhat applicable to other clients):

• Don’t be afraid to archive – chances are you’ll forget about that email in a couple of days time anyway. No point leaving it in your inbox, all it will do is clutter your inbox
• Remeber, when you archive, your email is not lost! You can still get to it (via ‘All Mail’). If you keep this in mind, it makes it so much easier (and less scary) to archive your email
• Have some labels (or folders) to help organise your emails so you don’t have to keep them in your inbox
• “Out of sight, out of mind” really applies here – if it needed your attention, you should’ve already addressed it

If you are to take anything away from this post, it would be the following. Firstly, work in such a way that you can focus; distractions, multitasking and context switching will only hinder your productiveness. Secondly, actually give those productivity hacks you’ve read about a good shot; don’t dismiss them without making a serious attempt.

To productivity and getting all the things done!

Meteor is a JavaScript framework that smartly bundles other JavaScript packages to allow you to create web apps super fast. What usually takes quite a bit of effort (setting up database, getting templates to work etc) is there, out of the box when you create a Meteor project.

Won’t go into the details of how it works (to be honest, I don’t know myself), instead I shall share some tips that I have come across whilst playing around with Meteor.

1. Read the docs, they’re good

Although you may feel like jumping straight in after watching a video or two about Meteor, I highly recommend reading (or at least skimming) through the Meteor Documentation, they are very well written. Go to them as your first point of reference when you’re confused or stuck. One tip when reading the docs, take careful note of the Server/Client availability, not only will it help with using it properly, it also helps with understanding it.

2. Unofficial Meteor FAQ

If the official docs don’t answer all your questions,  another goto place is the Unofficial Meteor FAQ. It has a pretty good list of questions, answers, misc tips and is fairly well maintained. There is always Google; but often there is too much information and you don’t always know good from bad. Reading through this FAQ could potentially save hours sifting through random answers/results from Google.

3. MongoDB

Out of the box, Meteor uses MongoDB for persistence which allows you to use JSON as the one data format across your entire app. This is great, except if you are very new to Mongo or never used it before. Meteor collections and Mongo syntax are pretty much the same (with some very minor differences), so if you know Mongo you’ll be fine. If you don’t, here are two quick tips that will hopefully save a lot of pain.

1. fetch() - eg. Posts.find().fetch()
   Running Posts.find() will return a cursor, but calling fetch() returns the JSON object. This is extremely useful when debugging via the browser console. The cursor has other usages, but when debugging to find out what data is available to use, you probably just want to see the JSON.
2. {multi: true} - eg. Posts.update({}, {$set: {graduated : true}, {multi: true}})
   This maybe basic knowledge to those familiar with Mongo, but not so for those who are not. By default, Mongo’s update() method only updates one document. In order to update several documents, you need to use the multi option.

4. Default packages: autopublish and insecure

By default Meteor comes with two packages: autopublish and insecure. These are great for debugging and prototyping, but not so much for production, since they will definitely be a security concern if left in.

• autopublish – publishes all the collections automatically (ie. all collections will be available on the client)
• insecure – gives the client full read/write access to the database

As you can imagine, you would only want the client to know about collections (and fields) that you have specified, and definitely only want the client to make certain database calls.

To remove these packages simply run ‘meteor remove autopublish‘ and ‘meteor remove insecure‘ from the command line. On the Server side of things, you will now need to specifically publish collections you want to expose to the client and define the access permissions the client has to the database.

5. Publishing/Subscribing + ready()

In general, Meteor apps are blazingly fast…with the exception of the initial load when the server is pushing the database documents to the client. There can often be a few seconds before the collection is ready for the client to use (especially true when not running on localhost). In general you will want to do something while waiting for the collection to be ready before accessing the collection. Checking if the collection is ready is quite simple. Below are code snippets form the client/server that demonstrate how this can be achieved.

// Server
Meteor.Publish('posts', function(){
   return Posts.find({}); // publish the posts collection
});

// Client
postsSubscription = Meteor.Subscribe('posts');

if (postsSubscription.ready()) {
   // Posts collection is now ready!
}

6. Single page app

From my understanding of Meteor, it is ideally used for single page apps. However, if you want multi page apps that is also possible, you just need to add a router to handle this. Meteor doesn’t come with a router package, however there are many available in Atmosphere. To install packages from Atmosphere, you will first need to get Meteorite.

You will notice that many tutorials will refer to “meteor-router”, however development on that project has now shifted to “iron-router”. Iron Router is a bit more complicated, but it is also a lot more powerful. It is well worth the effort in reading up and learning Iron Router if you want to have mult-page apps. If you want a quick overview/introduction to Iron Router, here is a good introduction video by the guys who made Iron Router.

The concept is very similar to VBA and Excel, however I think it is even more powerful because it has several convenient methods that allows you to easily leverage other Google apps. For example, to send an email as the currently logged in user all you need to do is: MailApp.sendEmail(email, emailSubject, emailBody);

As you can probably imagine, to get a mail merge working would require a fair bit of learning the spreadsheets API. However, luckily for me, Google has an excellent Simple Mail Merge tutorial

The tutorial takes you through the basics and explains the code quite clearly. However, my friend had a few extra requirements, so I needed to make few changes. I will go through a couple of the more interesting changes.

Firstly, sending a test email before sending out all the emails was high on the ‘nice to have’ list. This led me to discover Browser.inputBox which is like the JavaScript window.prompt.

So a new method came to light:

function sendTestEmail() {
	var testEmail = Browser.inputBox("Send test email", 
									 "Enter email address to send test email to", 
									 Browser.Buttons.OK_CANCEL);
	
	if (testEmail != 'cancel') { //inputBox returns 'cancel' if Cancel was clicked
		//...
		// Code that grabs the relevant information from spreadsheet
		//...
		MailApp.sendEmail(testEmail, emailSubject, emailText, extraOptions);
	}
}	

If you’ve had a look at the tutorial, you’ll notice they had a hard-coded email subject. To make things flexible I also made that template-able – essentially an extra cell in the spreadsheet that was dedicated for the subject (same pattern as the email body).

The more interesting addition would probably be extraOptions. This was added for two reasons: sender name and attachments.

1) Sender name
Apparently MailApp.sendEmail() is supposed to use the user’s name by default, but in my testing, it defaulted to my email address. Could’ve been that my account wasn’t set up properly, but regardless, added the functionality to allow for a custom sender name.

2) Attachments
This was surprisingly easy. From the docs for MailApp, you can source the attachment from Google Drive, or an external URL. I opted for the latter. My friend only needed one or two attachments, so I took the lazy path and did not accommodate for more. However it should be just a bit more work to make it take an arbitrary number of attachments.

The code for the extraOptions object is as follows:

var extraOptions = {};
var senderName = templateSheet.getRange("D1").getValue();
extraOptions.name = senderName;

var resp;
var attachmentUrl1 = templateSheet.getRange("D3").getValue();
var attachmentUrl2 = templateSheet.getRange("D4").getValue();

if (attachmentUrl1 || attachmentUrl2) {
	extraOptions.attachments = [];

	if (attachmentUrl1) {
		resp = UrlFetchApp.fetch(attachmentUrl1); 
		if (resp.getResponseCode() == 200){
			extraOptions.attachments.push(resp);
		}
	}

	if (attachmentUrl2) {
		resp = UrlFetchApp.fetch(attachmentUrl2); 
		if (resp.getResponseCode() == 200){
			extraOptions.attachments.push(resp);
		}
	}
}

Finally, although it was relatively simple to run the desired script via “Tools -> Script Manager” I felt it would be nice to have dedicated buttons or menu to make it even simpler. This was made almost trivial with the ability to add a custom menu to the spreadsheet ui.

A few lines of code…

function onOpen() {
	var ss = SpreadsheetApp.getActiveSpreadsheet();
	var menuEntries = [ {name: "Send test email", functionName: "sendTestEmail"},
                        {name: "Send email to ALL", functionName: "sendEmails"}];
  	ss.addMenu("Send Mails", menuEntries);
}

…resulted in a relatively user-friendly menu:

Overall, the experience was quite positive. From not even knowing about Google App Scripts, to having a working mail merge working in a few hours was very satisfying. However, as always there are a few not so nice parts.

The main one would be speed. From the user side, the scripts seemed rather sluggish. It wasn’t as responsive as I had hoped. From the development side, the built-in script editor was a bit slow and not that nice to use, especially the debugger. During development, the editor/debugger even crashed my Chrome.

The authorisation process (it asks for permission to send emails as you), though required was a bit confusing and didn’t feel very smooth. When I first shared the document with my friend, the custom menu didn’t appear. It was only after a refresh did the authorisation prompts appear and *then* the menu showed up after several seconds.

Although I can’t think of any other application for these scripts at the moment, hopefully you have found it useful. I know that next time I need to automate something related to Google’s apps, I will definitely have a look into these scripts to see what can be done.

One final comment. In the sendEmails() function, the tutorial makes use of dataSheet.getMaxRows(), however I don’t see a reason why it shouldn’t use dataSheet.getLastRow() instead – anyone have any ideas?

The book in question is “Thinking, fast and slow” by Daniel Kahneman, and the reason it’s only sort of a book review is I haven’t finished reading it! In fact, probably only about a fifth of the way. Nevertheless, it is a very interesting book and I would like to share a few of the things I’ve read so far and have found interesting.

The book explains how our mind consists of two very different systems that determines the way we think and make decisions. Kahneman has named these systems: System 1 and System 2.

• System 1: intuitive, fast and emotional. It’s automatic so you can’t really stop it from doing it’s thing. For example you when you see 1 + 1 your System 1 has already calculated the answer.
• System 2: deliberate, slow and logical. It’s controlled (and somewhat lazy) so you need to actually focus and work for System 2 to perform it’s magic. For example when you see 42 x 38 you know you can calculate that in your head (or maybe on paper) but that’ll require some effort.

Generally speaking, System 1 is always running in the background and making sense of the world around us. This means that it is common for System 1 to jump to a conclusion and System 2 (being lazy) assumes that the conclusion System 1 has provided is correct and makes decisions based on it.

Of course our minds work this way for a good reason. If we didn’t have something that very quickly and automatically made sense of the world around us we would probably be in a lot of trouble. The assumptions that System 1 makes are often correct or good enough. For example, picture this: “A large mouse crawled over a small elephant’s trunk”, chances are that in your mind’s eye the mouse was still small when compared to the elephant.

However, there are flaws. When asked: “How many animals of each kind did Moses take onto the ark?”, many fail to see the error in the question. Moses didn’t take any animals onto the ark, Noah did. The fact that Moses is also a biblical character is enough to trick System 1 to not raise any flags and jump to a plausible answer.

There are several other weak points where System 1 can often make mistakes, leading us to provide an incorrect answer or choice. What makes this disparity between System 1 and System 2 interesting (and somewhat scary) is that often System 2 believes it is in control and making the correct decisions!

The important thing to make a mental note of is that this happens to everyone, including you! We have no conscious access or control to what System 1 is gives to System 2, and since System 2 believes that it is the one that came up with the conclusion, it is often hard (maybe sometimes even impossible) to notice what has happened. Though the knowledge that System 1 can at times fail us is a good start to turn on System 2 bit more frequently, take a second look and question one’s immediate reaction to a particular situation.

So next time you make a decision, maybe take an extra moment to think it over. Have you made any assumptions that could be incorrect? If so, will that change your original decision?

You’re probably familiar with the bread and butter of the toolbar – inspect element, css tweaking, setting breakpoints in the JavaScript etc. So instead of going through those, I’m going to list a five tips here that you may not yet know and will hopefully make your debugging experience slightly less painful.

1. Super search: Cmd + Opt + F (Mac) / Ctrl + Shift + F (Win)

This shortcut is super useful for the times when you just do a massive “search all” to find a keyword across all your files. It will search through all your source files – html, css, js Once you’ve found what you were looking for, click on the search results to jump to the corresponding file.

Cmd + Opt + F (Mac) or Ctrl + Shift + F (Win) to search all your sources

2. Dock the toolbar on the right/bottom – the easy way

By default, the dev toolbar docks at the bottom and opens in a new window if you need more screen real estate for debugging. I personally don’t like opening the toolbar in a new window – more than one debug session and it’s easy to get lost between the windows. Depending on the page layout, what you’re debugging etc you may want more vertical space than horizontal… introducing docking the toolbar to the right!

The easiest way is to long-press the bottom left button and select the ‘dock to right’ icon. You’ll notice when the toolbar is docked to right, the icon will change to ‘dock to bottom’. You can now easily toggle between dock on bottom and right by clicking on that icon. If you do ever want to open the toolbar in a new window, just long press on the icon and choose the ‘new window’ icon.

3. Clear console: Cmd + K (Mac) / Ctrl + L (Mac/Win)

This shortcut clears the contents of your console – useful when you’ve got a lot of debug stuff in your console and want to clear it out so there is less stuff to get in the way. You can also type “clear” as a command, but two keystrokes is much better than six.

4. Open/close the console: Esc (Mac/Win)

The console is very useful, but sometimes you want to hide it. Alternatively you might be inspecting an element when you want to open the console for a bit of sanity checking. If your hands are already on the keyboard, just hit the “Esc” key when you’ve got focus on the developer toolbar and it will open/close the console.

5. console.log(“foo” + bar) vs console.log(“foo”, bar)

Using console.log(“foo ” + bar) is primitive, but definitely useful. This works if you’re after the value of the variable; but being told that bar is an Object – [object Object] isn’t all that helpful when debugging.

However, if you use a comma instead of a plus, Chrome Dev Tools will very kindly print the object and let you inspect the object instead

6. Make minified code suck less (ie. slightly more readable)

Unfortunately there comes a time when you’ll be debugging and you’ll step into some minified code which is pretty much completely uncomprehensible. Luckily, you can make the minified code slightly prettier by adding some formatting at the click of a button! The magic button to click is the one that looks like a pair of parenthesis: { }

The variable and function names may still make your head hurt, but at least you can now set breakpoints and make educated guesses as to what is going on.

Cube – created by CSS!

You are now reading the first of my “Sandbox” posts

The idea of this “Sandbox” is that there are so many cool things on the web that I keep seeing and wanting to learn/try out. I’m very much a hands-on learning person, so the sandbox is going to be a collection of my random explorations of things that have caught my attention. Hopefully I’ll be able to regularly update the sandbox!

The first thing to go into my sandbox is an exploration of CSS transforms and animations. On Thursday, I went to “What do you know?” (it’s awesome!) and listened to Patrick talked about “Moving to a 3D web with CSS”, in which he showed us how easy it was to make a cube using CSS.

Been meaning to look into CSS transforms for a long time, so this was a sign! Thus I spent most of my Saturday hacking at CSS For the impatient, here’s the source code (under 2012-08-18).

Here are two tutorials that I found extremely helpful when poking around with the CSS:

• Keyframe Animation Syntax
• The Guide To CSS Animation: Principles and Examples (used this as a tutorial for the bounce example)

The above two links will give you a good start on your CSS animation journey, so instead of writing a tutorial, I’m going to highlight some “gotchas” that I hit yesterday.

Animation is cool – but you have to define it!

When you see something like this:

-webkit-animation: spin 8s infinite linear;

Don’t be tricked! The “spin” is actually not a built-in animation, you have to define it yourself. At first, it might seem like more work, but it’s quite simple and it also means you can specify how the animation works. For example, here is my ‘spin’ definition:

@-webkit-keyframes spin {
   from { -webkit-transform: rotateY(0) rotateX(0); }
   to { -webkit-transform: rotateY(360deg) rotateX(360deg); }
}

I’ve decided to rotate on both the X and Y axis to make the rotation more interesting. The syntax is fairly simple (but powerful) once you get the hang of it. For a detailed explanation of the syntax have a look at: Keyframe Animation Syntax

Required properties

Now I could be wrong here (please correct me if I’m wrong!), but at least from my experience so far it appears that you need these two properties for things to work:

1. position: absolute;
   Seems to be needed for both 2D and 3D animations, otherwise the transforms don’t seem to have something to ‘anchor’ to.
2. -webkit-transform-style: preserve-3d;
   Needed for 3D animations if you want your shape to keep it’s 3D-ness when it’s being transformed/animated

The axes rotate with the element when you transform it

By default, if you are looking at a webpage, the x-axis is the horizontal axis, the y-axis is the vertical axis and the z-axis the one coming out of the screen. The origin is the ‘-webkit-transform-origin‘ of the element, and like the cartesian plane, right is positive x, up is positive y, and out of the screen towards you is positive z.

Now, when you transform your element, the axes for that element rotates with it – that is, each element has it’s own set of axes. So, if you rotate an element 90deg by the x-axis ‘-webkit-transform: rotateX(90deg)’, the positive y-axis is now pointing out behind the screen (away from you) and the z-axis is now what the y-axis used to be.

Each element can only have one transform property

A transform property for an element, looks something like this:

-webkit-transform: rotateX(90deg) translateZ(100px);

Now, if you apply another transform to this element (maybe via animation) that new transform property will override the initial property. It is quite annoying that you can’t stack the transform properties, but the ‘transform’ property is actually a single property (and not shorthand) so you can’t specify to change just one type of transform.

This means, if you want a more complicated animation, you will need to wrap the element in a div and animate both the inner and outer div. This can cause your HTML to become quite ugly, but can’t see a way around this.

Upgrade your browsers!

I did all my development using Chrome, and after everything was working, added the ‘-moz‘ versions to the CSS, opened it in Firefox and the cube didn’t rotate! After spending some 15min of debugging, realised I was using an old-ish version of Firefox (version 8). Upgraded to version 12 and the cube magically rotates

That’s all I’ve got for now, hopefully it has been helpful and/or made you want to go and try some CSS for yourself. If you missed it, you can see the code here (under 2012-08-18).

Don’t ignore your dreams; don’t work too much; say what you think; cultivate friendships; be happy.
~The Top of My Todo List by Paul Graham

Believe it or not, we are almost halfway through 2012 – just one more month to go!

The passing of time still often gets to me – I find it hard to believe that 5 months have already passed since I last posted, but at the same time, reflecting on the past couple of months, I find it hard to believe so much has happend in 5 months. So somehow, time is both short and long at the same time!

One thing that I know for certain, there never seems to be enough time. There just seems to be so many things that one needs to/wants to/should do – yet only 24 hours in a day. Not only does my ‘todo list’ seem to be forever growing, but life seems to be very adept at providing a constant stream of distractions. Thus, plans to work through the list are often futile; resulting in the feeling of being overwhelmed by the sheer amount of tasks and things happening everywhere.

What I try to keep in mind though, is that the ‘constant stream of distractions’ is really just an excuse – life will not stop for you, you have to stand strong and find a way to manage/control the constantly flowing stream. However, having said that, there are times that you can stop, relax and let everything around you flow by. As recently shared by a friend, in the words of Billy Joel:

So whilst we shouldn’t make excuses for not always being able to get things done, we should also take some time off, relax and enjoy life!

ps. It is quite interesting reading my previous post (from last year!) as it is somehow still very relevant. Unfortunately, I have been very slack with regards to the challenge I set myself – must admit I haven’t really been taking time to reflect at all.

… we rarely take the time to pause, breathe, and think about what’s working and what’s not. There’s just too much to do and no time to reflect.
~The best way to use the last five minutes of your day

Firstly… Merry Christmas and Happy New Year to everyone! Believe it or not, we are near the end of 2011. As the year draws to a close, it seems to be the time when we reflect on what has happened throughout the year – or at least I do.

A lot has happened in the past year for me – in some ways you can say it’s been like a roller coaster ride. Some of the observations below are in some ways obvious, but I would still like to write them down here to share and to serve as a reminder for myself.

• Things can change at a moment’s notice – adapt to change when the unexpected happens
• Appreciate what you have – don’t take anything for granted
• Friends are awesome – talk often, look after and care for each other
• Take things as they come, don’t worry too much – if it’s happened, you can’t change it; if it hasn’t happened yet, it might not happen. Worrying won’t do you any good.
• “This is your life. Do what you love, and do it often” – Holstee Manifesto
• Smile, be happy. Relax, enjoy yourself – not everything in life is all that serious, take time to have some fun

I feel it is quite beneficial to reflect on what you have learnt from things that have happened. The act of learning and reflecting on what you have learnt are two very different things. In my opinion, reflecting enables you to better understand what you have done right or wrong and allow you to improve.

Unfortuantely, I believe we rarely reflect enough – I tend to reflect sporadically, especially after major events. However, we learn and do so much on a daily basis, it seems like we should really reflect at the end of each day. By not pausing and taking time to reflect, it means we are more likely to repeat the same mistakes, or fail to repeat something we did right.

I am going to challenge myself to take 5 minutes each day to reflect over what has happened; what I have done during the day; anything I could/should have done differently etc, I challenge you too do the same.

Once again, Merry Christmas and Happy New Year to all Hope you will have all an awesome and memorable holiday with family and friends!

…if piecing together 1500 pieces wasn’t enough, I was crazy enough to make a stop motion video. After approximately 5 hours, 270 photos later, some iMovie magic and awesome music knowledge from awesome friends…