The End is Nigh?

emptypocketsI’m a family man.  When my work day ends I rush to my car as quickly as possible to start the hour plus drive home to spend a few hours in the evening with my wife and children.  I have to admit that during that drive home, I typically put on blinders and strictly focus on my goal of getting home safely.  That being the case, I often miss a lot of things as I drive down the highway or through the towns that I navigate through.  This has been my routine for the last 12 years or so spanning two jobs.  For some reason, last night was different.

One of the towns that I drive through on my way home at night happens to be the town that I grew up in.  The route that I take home goes through what used to be a fairly lengthy strip of shopping that included clothing and hardware stores, restaurants, an ice cream shop, and a slew of fast food places.  Don’t misunderstand me, it’s not a mecca for the rich and famous, but it’s a permanent fixture in my childhood full of a lot of very fond memories.

Over the years, the once prominent strip (in my mind anyway) has deteriorated like many towns all over this great country of ours.  You can speculate why that is, but I will leave that up to you.  Many of the stores have closed and never been replaced or have been replaced by establishments of less…quality.  This trend continues over the years, but I have recently noticed another scary trend.

Last night on my drive home, down this now rather dilapidated strip of foreclosed stores and dirty fast food restaurants, I noticed something that seemed very puzzling at the time and now just makes me very sad.  This strip of stores spans about 6 blocks and in a span of about 3 of those blocks I saw 4 fast food restaurants that had been closed and replaced with places that offer title loans.  When I say replaced, I don’t mean demolished and new stores built.  These places have actually just moved a few walls inside and converted what used to fairly big names in the fast food game into a sleazy short term loan store.loanshark

Why does this bother me?  Well, it concerns me for several reasons, but there is one reason that stands out most.  Why do people tend to use short term loans?  Typically because they have over extended themselves so much that they can no longer borrow money in the traditional sense from banks or even via credit cards.  Not to say that credit card borrowing is OK, but it is a more established vehicle and more regulated.  With title loans, you are trading your car title for cash.  Once your short term loan is repaid, you get your title back.  In my mind, this is just about way to plunge yourself deeper into debt.  What happens if you default on your loan?  They repossess your car to get the money back that you owe.  So now, you not only don’t have the money that you needed, but you also don’t have a car.  Sounds like a great idea.

Now before you go judging me for being misinformed and that these title loan places are giving poor people a chance, let me just say this.  According to an article written a couple of years ago, approximately 120 million people across this country use these types of loans annually.  Of those people, roughly 50% would more than likely classify themselves as “poor”.  Poverty is a horrible thing.  The numbers of around the poverty stricken in the most powerful country in the world are absolutely staggering.  In that case, I’m not saying these types of loans are OK, but I can at least understand why these people would try to use them.  But what about the other 50%?  These are the ones that really start to scare me.  Too many flat screen TVs, cars that you can’t afford, game systems, and other toys that you shouldn’t have bought in the first place?  Maybe.  It’s hard to tell.  It’s just a sad reality that we are facing today as a society.

These problems will probably never go away.  And I really don’t have a solution that will solve all of them.  What I do have though is children.  Children that I love very much.  So my plan is simple.  It’s the same plan that I try to use for every real life scenario that I run into as a parent.  A plan that I feel should be extremely simple and well know by every parent on the face of the earth.  Sadly, though, I feel that it is one of those that is so simple that it is often overlooked.  So if you have hung in this far, I will now bestow upon you some very valuable wisdom.  My plan, and hopefully yours too, is…communication.

Talk to your children.  Explain to them the real world.  When you open your eyes to the world around you, or even your drive home, you are given so many teaching opportunities.  parenting-talking-to-child1You don’t have to use all of them.  Maybe just one or two at a time.  Whoever said there is no manual for raising kids was blind.  Sure there is.  We were given the best manual in the world from day one.  The world.  It is a wonderfully beautiful and scary place.  Full of amazing things to teach our children about.  Good and bad, they are all there.  So pick one.  Talk to your children.  In the end they will make their own choices so the best we can do is give them information to help guide them.  They will make mistakes just like we have, but in the end, we hope to have given them enough of the tools that will turn them into thriving members of society.  They are never too young.  Get started today.

TheWire: Post 3 – Defining and Tracking Features

Where Are We Going?

This is a very important question that is revisited many times in the process of creating any application.  And to be completely honest, this post has less to do with the actual features of this application (although it will contain some), and more with how these features will be tracked.

Tracking is an important part of the software development process as it allows everyone that is part of the team to be able to see what is done, what is currently being worked on, and what still needs to be addressed.  Typically the parts of the application that fall into these buckets are grouped together and given some sort of name.  In our case these groupings will be referred to as Features.

More on Features

A Feature is going to represent some capability of our application from the user’s perspective.  So a simple example of that could be something like this:

Feature 1Users can manually add new feeds
A user should have the ability to manually add a new news feeds to the application by specifying the URL that points the specific feed.

As you can see here, the concept of a feature is rather simple.  It typically has some sort of identifier associated with it.  In this case, it is a number.  It has a title that gives the high level concept of the feature.  Then finally it has a description that gives it a little more information about it.

Now obviously you can image this can get extremely detailed and crazy.  Depending on the type of SDLC (Software Development Life Cycle) processes you follow (more on SDLC in a later post) there can be more or less information at the feature level.  In our “process” we will keep it rather simple.  We will be using the features more for grouping more specific concepts.

As you may tell by looking at the definition of this feature, it doesn’t serve much use to a developer and that is OK.  It really isn’t supposed to.  It is merely used to describe a concept at a high level and group technical concepts and work together underneath it.  These features will have more of a user based “businessy” feel for lack of a better word.  So where does the definition of the development work come into play?  That’s next.

Defining Development Work

Now that we have a concept of a Feature defined, let’s talk about actual work.  By work, I am referring to code that is written to accomplish a task that is associated with a feature.  I have chosen to use the word task to describe the work that is done, but you can replace that word with anything you like.  Once again, depending on the SDLC process you use, that word may mean different things.

Now we are beginning to build the concept of a hierarchy when it comes to work related to this project.  We create a high level Feature from a user’s perspective and then create a series of tasks that are technical in nature to describe the work that needs to be done to complete a particular feature.  That being the case, in theory, once all the tasks of a Feature are complete, that Feature should be considered complete.

Tracking This Project

So this is all great in theory, but how are we actually going to track the work we are doing on this particular project?  There are many tools and services across the internet that are built specifically for this purpose.  Some of them are pretty robust and provide a lot of features while some are quite simple and just “get the job done.”  This being a learning experience where the journey is more important than anything else, I’m going to opt for the cheap, yet rather flexible Github.  WHAT?!  But Github is for source code, right?  Well, yes, but there is so much more it can offer.

If you were to head over to TheWire repo on Github and poke around you will notice a number of tabs along the top right of the page.  It will default to the Code tab, but there are several others there.  One of these tabs is the Issues tab.  If you were to navigate over to this page, you will find that here you can manage four distinct pieces of data about your project:

  • Issues
  • Pull Requests (PRs)
  • Labels
  • Milestones

Each of these concepts is very distinct in nature and in learning about them they can be a little difficult to get used to.  I will do my best to break these concepts down as simply as possible.  More information on these topics can be found in Github documentation.

Issues

The word “issue” can often carry with it a negative connotation.  In the world of Github, that doesn’t necessarily have to be the case.  Within Github, issues can be used to track tasks, enhancements, as well as well as bugs.  So as you can see they are very multi-purpose and don’t have to be taken negatively.

Pull Requests (PRs)

Pull Requests are the way that you generally interact with repositories that you don’t own.  In the case of our project, you will typically start by cloning the repository.  You will make some changes and commit to your local copy.  Since you don’t (at least not now) have admin rights to the repository, you will submit a PR that will tell us that you are requesting your changes be committed to the central repository to become part of the working code.

Labels

Labels are a way to organize your issues into different categories.  Labels are completely customizable and allow a lot of flexibility.   Organization is very useful when creating custom views of your issues.  That way you can focus on a particular subset of issues instead of sifting through all of them in a large bucket.  Labels are also another way that we will be integrating with Up For Grabs.

Milestones

Finally, milestones are a way of hierarchically grouping issues together into a specific feature.  Milestones can have time frames assigned to them if you are tracking to a date, or can be left open without a date.  For our project we will more than likely be leaving these open and using them to track particular features.

Going Forward

With this basic knowledge in hand, you are ready to take a look at some of the outstanding defined Features (Milestones) and Tasks (Issues) within TheWire Github Issues to see what is currently defined.  I have only begun creating placeholders for work that needs to be done.  So please, read through what is there so far, work on some tasks, submit some PRs, and submit some Feature requests.  I’m looking forward to see what you come up with.  Until then I will continue to create some based on ideas that I have.

Happy Coding.

MGWX – Ships

As promised just a few days ago, I wanted to put together a tutorial on creating games using the Xamarin.iOS implementation of Sprite Kit. And here it is.  I chose a slightly different format for this tutorial and wrote it using markdown in the Github repo for the source code.

Head on over to the repo, check out the code, read the Xamarin.iOS translation of the original tutorial created by the folks over at MakeGamesWithUs.  They do amazing work and we will forever be grateful for the beacon of light they shine for us.

Going forward, let me know what you think about this format and whether or not you like it as part of the repo or if you would rather it be here in the actual post.

Happy Coding!

Create Games With Xamarin.iOS, Sprite Kit, and MakeGamesWithUs

I think as software developers we have probably all at one time or another wanted to create games.  Some of us are lucky enough to do it on a day to day basis.  Even if your career path has taken you away from it over the years, you may still think about it from time to time.  I know that I do.  That being the case, I have periodically wanted to revisit some of that interest lately and have wondered how to do that in the world of Xamarin.iOS.  Because, let’s face it, I don’t want to have to go back down the path of learning native iOS development again to focus on games.  Luckily due to the support of Sprite Kit in Xamarin.iOS, I don’t have to.

In the link provided above, Mike Bluestein takes you through a nice introductory tutorial on getting started with creating Sprite Kit games within Xamarin.iOS.  While this is very nice, I wanted to learn more.  In my quest for more knowledge on iOS technology in Xamarin, I was reminded of 2 ideas that I seem to run into time and time again:

  1. I am definitely not an expert in all things iOS
  2. There are tons more native iOS examples than Xamarin.iOS examples

You have probably run into these realizations several times before yourself.  That’s OK, believe it or not, it really isn’t that big of a hurdle to overcome.

If you have done any investigation into creating iOS games in the last year or two, you have no double come across the wonderful people over at MakeGamesWithUs.  If you haven’t, I definitely recommend you do so.  They have created not only a wonderful site full of great learning material, but they also off full online and in person courses on the process of creating iOS applications and getting them published to the App Store.  Very cool stuff.

One of the other things you will come across on their site are a number of free beginner courses and tutorials on creating games.  If you have a look at these, you will notice that they are all native iOS games written in objective-c.  This may be a dead end to some, but a wonderful opportunity to others.  Let’s take a trip down the “wonderful opportunity” path.

As a Xamarin.iOS devloper, I see this a perfect opportunity for me to learn the concepts of iOS game development by taking these tutorials and translating them into C#.  If the theory of Xamarin holds true, I should be able to take these native objective-c concepts, translate them into C# constructs, and run these games natively on my iOS simulator and device.  So I feel that it is time that I put this idea to the test.

Over the next several weeks (or possibly months) I am going to be spending some quality time with Xamarin.iOS and the tutorials found on MakeGamesWithUs.  I will be posting my findings and code snippets of my translations of the games into C#.  I encourage you to follow along with me and take this challenge as well and let me know what you think.  Should be a good experience, and who knows…it may just open a few more doors.

Happy Coding.

TheWire: Post 2 – Getting The Source

Joining in the Fun

If you read the previous post, you now have probably set up a successful development environment to work with cross platform mobile development in Xamarin.  Hopefully you have taken some time to investigate the IDE (Xamarin Studio or Visual Studio) and start to get at least a little familiar with it.  If not, that’s ok, there’s nothing wrong with the occasional trial by fire.  The next step is to get ahold of the source code.  All of the source code for this project can be found on Github.  But big deal.  What does that mean.  Well, it’s mean a lot of things so let’s touch on a couple.

The World of Github

For those unaware of just what the heck Github is, I am going to give a very poor effort of summing it up in a couple sentences.  Github is the social face of version control.  It takes the world of social networking and puts a developers spin on it.  It is a centralized hub of the Git distributed version control system.  But it is more than just source control.  It not only provides a way to manage source code, but also provides tools around managing projects by tracking features/issues along with the source code.  In addition to that, it makes this source code available via the web to let anyone with access to the repositories look at it, download it, and even propose changes to it.  In my opinion it is truly a wonderful teaching tool, which is exactly what I hope to use it for.  But before you can understand and use Github, you will need to understand (at least a little) it’s underlying technology, Git.

What is Git?

Git is the distributed version control system that is at the base of Github.  Now, I have no intention of trying to describe Git in all of it’s glory to two primary reason.  First, it is a very large topic that entire books have been devoted to.  Second, I am not the foremost expert on the subject.  Why do I tell you this?  Why not just come across as the expert to try to have you look up to me and have you hang on my every word?  Simple.  That is not, nor has it ever been, my goal.  When I said that I wanted to spearhead a learning opportunity, I meant it.  I meant it for all of us, myself included.  I understand the basics of Git, and consequently Github, but I am in no way an expert.  So I stand to learn something myself.  That being said, I am going to direct you towards a few resources that I am found in my journeys  that I believe to by useful.

Resources

  • Git – Definitely check out the site to learn about Git in general, but there are definitely some better places to learn how to use it.
  • Git – The Simple Guide - A no nonsense site that takes you through concepts of Git.
  • TryGit – A Github resources that takes you through an interactive tutorial on using Git brought to you by the folks at Code School

I think that these should be enough to get you started if this is your first journey into the world of Git and Github.  So go through those resources and learn more about the process of cloning a repository.  That will be your first step in this process. You will be cloning this repo on Github.  Once you have a local copy you will be able to take a look at the current status of the code.  From there you are one step closer to becoming a contributor.  And until next time…

Happy Coding.

TheWire: Post 1 – Setting Up Your Dev Environment

Getting Set Up

In thinking about where this series needs to start, I decided it’s probably best to just start with getting your development environment setup.  There are several blogs, articles, and tutorials out there that go into pretty good detail on the different hardware and software requirements and setup instructions to get you started.  That being the case, I’m mostly going to point you to those resources.  But before we get to that I have a couple of my opinions I would like to give you.

A Couple Extra Notes

Xamarin Android Player

At this year’s Evolve, Xamarin unveiled a wonderful gift to do the Xamarin community.  This gift is especially useful for those that will be creating, testing, and ultimately releasing Android apps.  The Xamarin Android Player is a much faster Android emulator that will drastically decrease wait times between debugging sessions.  I highly recommend you check it out.  It is in its infancy and you may encounter a couple issues, but I definitely think it will be the way to go in the future of Xamarin development.

OS X vs Windows

At the end of the day, it is completely up to you which platform you choose for development.  I spend most of my time on a Mac using Xamarin Studio these days simply because I feel the experience is…fun.  I don’t really know how else to put it.  There is obviously a trade off.  If you are using a Mac, you will not be able to create Windows Phone apps and if you are on Windows you will still need a Mac to run/debug iOS applications.

To continue following this series, you will be able to use either platform.  A simple workaround depending on the platform you are developing on is this.  If you are on a Mac, you can simply “unload” the Windows Phone project so it isn’t included in the build.  If you are on a Windows machine, you can simply unload the iOS project if you don’t have access to a Mac.  I don’t envision this being a huge issue since the plan is to utilize Xamarin.Forms so quite a lot of the code will be in the shared project(s).

Of course you could get the best of both worlds by running natively on a Mac, and then run Windows in a VM, which is detailed in the first resource below.  Once again that is completely up to you.

Resources

  1. Xamarin – Who better to explain the process or setup and installation than those that created the software.
  2. MvvmCross – Yes, this is a library that allows you to easily write cross platform mobile applications utilizing the Model-View-ViewModel pattern, but they also have a very detailed wiki page on getting a development environment up and running.
  3. My Stuff – My apologies for the shameless plug.  I’ve written a couple articles on getting started with Xamarin.  The beginning of each of the 3 take you through some of the basic requirements and setup.

That should be enough to get you setup.  If you have any questions, please feel free to let me know and I will give you a hand.

OpenProject codename TheWire

Hello everyone!  Well, it’s that time.  In a previous post I threatened everyone that I wanted to spearhead a community driven Xamarin development effort with the goal of creating a fun, yet challenging learning experience that would allow all of us to work together to build something from scratch that would ultimately find its way into the app stores.  After getting a few things off my plate (and consequently adding a few things on) the time has come to embark on this journey.  I have started to put together some thoughts on this project and the following is what I have come up with so far.  But, the entire point of this is to solicit ideas and feedback from all of you to take this idea and tweak or change it as much as you would like.  I am merely playing the role of facilitator (and contributor) to get (and hopefully keep) this moving in a positive direction.

So, without further ado, here is the starting point.

What are we building?

The idea of this app is going to be an open source news aggregation app that is socially connected and allows users to see and share their favorite news feeds and articles with friends.   This app will also allow users to see what is popular and currently trending across different social networks as well as be updated when there is news about their favorite people/topics.

What are the technical features?

This is going to be an evolving part of the application that is sure to change over time.  In the beginning, I am visualizing the following:

  • Targeting iOS, Android, and Windows Phone
  • Xamarin.Forms (including Messaging and Customized UI)
  • MVVM
  • Microsoft Azure Mobile Services
  • Microsoft Azure WebJobs

Can I help?

Of course.  I don’t care if you have 30 years experience or just started yesterday.  The idea is for all of us to work together in a collaborative learning environment in which we are all students and teachers.

Once we start to nail down some of the MVP (Minimum Viable Product) aspects of this app, we will be utilizing Up For Grabs to call out to anyone interested in helping out with features and/or bugs.

How do I help?

Easy, head over to our Github repo, clone it locally and poke around.

What’s the current status?

Well, right now I am just trying to get the concept to materialize a bit.  As we go and ideas are thrown around and changes are made, I will be blogging right here with any sort of updates or findings that will be helpful to anyone interested.  I hope for these entries to be anywhere from weekly to biweekly, but I will have to see how it goes in the beginning as things are ramping up.

What sort of topics will I learn?

Good question.  The short answer is lots.  I hope for this to be more than just a “learning to program” or “learning Xamarin” exercise.  I want this to be a “learning to be a positive developer community member” exercise.  So skills covered in this effort and blog entries will include technical topics around C#, .NET, and Xamarin.  But we will also be covering other topics such as Git, SDLC (Software Development Life Cyle), blogging, Meetups, and a slew of other topics.  Basically anything that comes up during this adventure.

Well, that is all I have for now.  So please, go ahead and checkout the Github repo and start thinking about features as we start to dive into creating a definition for the MVP of this application and break out some features for all of us to work on.  Until then, please spread the word about this project as I believe it will be a positive experience for everyone involved.

Happy Coding!

Fixing Type Registrar Issues When Upgrading Xamarin.iOS

This may be a bit dated and I’m sure several have run into this and figured out the solution before reading this post, but this is more to help me as well as anyone else that is running into this issue a little later in the game.

I was recently working with a client in upgrading a Xamarin.iOS application and ran into an interesting issue.  I noticed that the application was running on a rather dated version (7.0 I believe) so I thought I would do him and myself a favor and upgrade it to the latest version.  I was able to successfully build the app in Xamarin Studio, but when I tried to run it, the app crashed and the Application Output window showed a slew of errors that looked something this this:

MonoTouch.RuntimeException: The registrar found a signature mismatch in the method ‘blah blah’ – the selector ‘blah’ indicates the method takes 0 parameters, while the managed method has 1 parameters.

Now I know that most of you are probably like me and always read the release notes, but in case you don’t let me save you some digging.  In release 7.2.1 of Xamarin.iOS the Type Registrars that were introduced in release 6.2.6 became enabled by default.  What does the mean?  Well, it means a few things, but in my case it meant that anywhere in my code that I was using the ExportAttribute on a method, now needed to include the colon on the end of the name of the exported method. So instead of:

[Export("MethodName")
public void MethodName(string someParameter) {
    // Some code here.
}

I will need to explicitly specify it this way:

[Export("MethodName:")
public void MethodName(string someParameter) {
    // Some code here.
}

It’s a rather small difference, but going forward from Xamarin.iOS 7.2.1 it will be a very important difference.

This is probably the more appropriate way to eliminate this problem. The other way to get around the problem is to force mtouch to behave the way it did before Xamarin.iOS 7.2.1 and not enable the new registers by default.

To make mtouch function as before, you will need to go into your Xamarin.iOS project options. In the Options Dialog, you will want to select iOS Build under the Build section on the left hand side. All the way down at the bottom of the view, you will see a text box labeled as “Additional mtouch arguments”. In that text box, you will want to add the following:

–registrar:legacy

For the more visual types, like me, here is a screnshot of what I am talking about.

mTouch_arguments

As mentioned before, this little baby will hide the problems you ran into with the upgrade of Xamarin.iOS to a version newer than 7.2.1. In the end, the choice of how you get passed these errors is completely up to you.  I would say that you should fix the problems as opposed to hiding them, but then again sometimes you gotta do what you gotta do.

Happy Coding

We’ve Never Met, But I’d Like to Help You

Well, it has been an embarrassing long time since my last post.  I’m typically not one for excuses, but I have been busy.  I’ve been spending a lot of the evenings in vampire mode trying to better myself for the sake of those that I’ve never met.  I’ve been creating lots of content for Envato’s site tuts+ in the way of online video course material as well as written tutorials.  I’m also about two-thirds of the way through writing a book?!  Are you kidding me?  Writing a book?  I know, it’s crazy, difficult, fun, frustrating, exhausting, rewarding, and infuriating all at the same time.  Hey, sounds like I just described having children…  Interesting.

Anyway, I got to thinking about the instructional content I have been creating and the book I’ve been writing.  The primary topic of all these things is a very cool technology that allows developers to create cross platform mobile applications that will run on iOS, Android, and Windows Phone from a single codebase written in C#.  If you haven’t heard of this, you either aren’t a nerd like me, or you have been living under a rock.  If either of those are the case, you should go and read about this technology called Xamarin.  It’s extremely cool stuff.  After you’ve checked out their site, go read and watch some of my instruction content.  After you come out of that you should have a fairly good understanding of not only the technology, but how to use it as well.  And by the way, if you have any other questions or ideas about things you would like to learn don’t hesitate to ask.  I’d be happy to create more content targeted to you.

After all this work over the last couple of months, I realized that while this instructional material is very helpful, most of the examples are snort snippets or tiny applications that may not always have the most relevant content that you may be looking for.  So… I’ve decided to start a project.  With YOUR help.

Over the coming weeks, months, years, or however long it takes, we will be creating a fully functional cross platform mobile application that will be completely open source and will end up in app stores for download (free of charge) for iOS, Android, and Windows Phone.  This app will be written in C# using Xamarin and will use as many cool features as we can pack into it.  I will be blogging about our progress as well as posting all source code on Github and accepting Pull Requests from those of you out there that wish to participate.

This should be a fun learning experience for everyone involved from the most novice of C# and Xamarin developers to the most experienced.  Everyone is welcome and encourage to contribute and participate in anyway they feel comfortable.

Be on the lookout for future posts that will help to frame the project more and attempt to solicit feedback.  I look forward to working with you.

The Graceful Art of Failure

Hello everyone.  My name is Derek, and I’m a failure.  Just today I failed at being considered for a possible job opportunity that I thought looked really cool.  Was I fully qualified for the position?  No.  Did I possess the skills that would have made me stand out from the rest?  Probably not.  And because of these things, I failed.  Does that mean that knowing what I know now about the position and myself, would I have avoided the self-inflicted pain it might have caused to be rejected?  Definitely not.

In my mind, failure is a wonderful thing.  It teaches us things.  It helps us to affirm who we are and what we are capable of.  It definitely isn’t an enjoyable experience.  It hurts to open yourself up and become vulnerable to the stinging pain of rejection.  That’s the difficult part of any sort of relationship.  But that doesn’t mean that we should run from the possibility of failure.  We need to embrace it.

Failure helps to define who you are.  Sure, you could stay in your little comfort zone and be the best developer, player, manager, etc. on your team.  But how do you know how good you really are?  If you don’t every push the limits of your ability, how do you know where your weaknesses are and heaven forbid how could you ever find out how to get better?  No matter how good you are at something, there is always someone better.  No matter how much you think you know, there is always someone that knows more.  When you open yourself up to these people and they point out your weaknesses, you should feel blessed.  You have just identified an area primed for improvement.

I like to think of this constant rejection like a kickboxer.  Over the course of years of training, a kickboxer will sustain hundreds and thousands of micro fractures in their legs.  I equate each one of them as some sort of weakness.  Over time, these fractures not only heal, but get stronger.  As human beings, we have this same opportunity.  Each time we fail in something, we are faced with a decision.  We could either crawl into a hole and have a nice little pity party, or we could mend and strengthen that part of our skills.

So the little moral of this story is…fail.  Put yourself out there.  Try to do something out of your comfort zone.  Stretch the limits of what you think you are capable of.  Yes, failure will sting, but it will go away and provide you with a tremendous opportunity to improve.

At this point, you may be wondering what I did in the face of failure.  Well, I’m not going to lie, it definitely stung because I was very interested and thought it would be a great opportunity for me.  After the initial pain…I asked for more.  :-)