Monday, June 29, 2009

Grind Report 4

I was looking through the problems on Project Euler and saw this problem and ended up solving it.

Problem 5

2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest number that is evenly divisible by all of the numbers from 1 to 20?

*WARNING: This contains the solution!*

This was a very easy problem for me. Having just done that factoring problem the other day, my immediate thought was "What does this [2520] factor down to?"

1-10 Factor Solution: 2 * 2 * 2 * 3 * 3 * 5 * 7 or 2^3 * 3^2 * 5 * 7

Notice anything about this? Every number from 1 to 10 can be made from these numbers. Getting a little more in depth.

Given a range 1-k (this problem k=20) for every prime number, n, between that range include n^m in the solution. m is the nth root of k. floor m, because m is integral.

Trying that on the 1-10 factor.


k^1/2 = 3.1622
floor(3.1622) = 3
so include 2^3 in the solution.

k^1/3 = 2.1544
m = floor(2.1544) = 2
include 3^2

k^1/5 = 1.5848
m = floor(1.5848) = 1
include 5^1

Once we find a prime number that has m = 1, we can assume that for all remaining n up to k, m = 1.

n = 7
m = 1

So without any programming I put together the problem's solution.

2 * 2 * 2 * 2 * 3 * 3 * 5 * 7 * 11 * 13 * 17 * 19 =
2^4 * 3 ^2 * 5^1 * 7^1 * 11^1 * 13^1 * 17^1 * 19^1

Pretty cool huh!?

With this little theory I put together it would be pretty easy to program this to solve for any range 1-k. I may come back to do it but for now I have family plans :)

*saved game*

Sunday, June 28, 2009

Grind Report 3

More Project Euler.

Problem 3

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

*WARNING: This contains the solution!*

This problem required a little more thought than the previous two. I do not remember the last time I did factoring, it must have been years before this. Too much Calculus!

One thing about factoring is that the composite number can be factored down to just about any prime number. Consequently we just have to try all of the prime numbers until one works. So this brings up the question, "How do you calculate a prime number?" After a little research I found that doing just this has been attempted over the centuries by many great minds and a proven formula has yet to be found.

My thought is that we will iterate though all odd numbers (since 2 is the only even prime). For each number we check see if the composite number is evenly divisible by that number. If it is then we can lessen the composite number down to composite / number. In order to have this work correctly a number must be repeated until it is no longer a factor of the composite. This will insure that only prime numbers are found.

How do we know when we have found the answer? One approach to this question is (I believe) that fact that the factor can square root of the composite. This is included in the solution from Project Euler. This definitely works; however, I came up with my own approach. Because I was lessening the composite number eventually the composite number would actually become a prime number and not just any prime number. It would become the largest prime number (since we are moving up). So I simply kept track of the product of all of the prime factors found up to a given point and once the product * composite would equal the original composite number it would return the "composite" as the solution.

One problem I ran into here is that the original composite number is so large that it requires a long long type. I attempted to figure out how to do division with long long but could not come up with anything that worked. I found some stuff using lldiv() from stdlib.h but that must have been for something else because it did not work when I included stdlib.h. Because of this I had to do the division with a calculator everytime it found a prime factor. If anyone knows how to do long long division I am all ears. Here is the code.

#include <iostream>
#include <stdlib.h>

using namespace std;

long long NUMBER = 600851475143;

void FindLargestPrime(long long composite)
//the number
int number = 2;
long long product = 1;
while (true)
//check to see if the number evenly goes into the composite
if (composite % number == 0)
//if so then set this to the new composite
//this doesn't actually work but would if lldiv and lldiv_t were defined.
lldiv_t compt = lldiv(composite, number);
composite = compt.quot;
//update the product
product *= number;
else //is not a factor so increase the number
number += 2;
if (number <= 4) number -= 1; } //check to see if we have found the final prime factor if (product != 1 && product * composite == NUMBER) break; } cout << "Answer: " << composite << endl; } int main() { FindLargestPrime(NUMBER); return 0; }

*saved game*

Saturday, June 27, 2009

Grind Report 2

Going after the next Euler problem.

Problem 2

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

Find the sum of all the even-valued terms in the sequence which do not exceed four million.

*WARNING: This contains the solution!*

Ah yes, the good ol' Fibonacci sequence. Back during my senior year in high school a good friend and myself decided one day to memorize the 100th term in the Fibonacci sequence (63 digits). Later we had a race to see who could write it faster on the whiteboard of our Calculus class. Good times~

If the 100th term is 63 digits long then I know that the solution will not even get close to the 100th term. This is good if I were to apply a brute force method to this. There is something called Binet's Formula which can be used to calculate a term. This is really cool but there are two problems with applying this to the actual problem.
  1. We need to find the sum of the terms. Meaning we would still need to calculate most of the terms. Since a given term is the sum of the previous 2 terms, we would be able to skip every 2 terms and add the term twice. 1 + 5 (2) + 21 (2) + 89 (2)
  2. As we can see (if you look at it) this formula is somewhat complicated in terms of calculations. Using this formula instead of a brute force method may actually be slower in code.
  3. Adding another problem, which conflicts with the second half of #1. I nearly forgot that we are only adding even terms.
I believe it is pretty obvious that for this problem we want to use simple brute force considering all of these extra costs that are included in calculating a term using Binet's formula. I am going to use recursion.

#include <iostream>
using namespace std;

int const FIBCAP = 4000000;

int const FIB1 = 0;
int const FIB2 = 1;

int sumFibonacci(int previous1, int previous2)
//calculate the next term
int next = previous1 + previous2;
//stops the recursion once the cap is met
if (next > FIBCAP)
return 0;
//check to see if this term is even
else if (next % 2 == 0)
return sumFibonacci(previous2, next) + next;
return sumFibonacci(previous2, next);

int main()
int answer = sumFibonacci(FIB1, FIB2);
cout << "Answer: " << answer << endl;
return 0;

This returned the correct solution the first time I ran it. However, once I got it right I was able to view the .pdf solution Project Euler provides and I see I failed to see that we can know when an even number occurs in the sequence. It is every 3rd number. This is a minor improvement but an improvement nonetheless. I was very close to catching this and would have if I had taken the time to write things down instead of doing everything in my head. Lesson learned.

*saved game*

Grind Report 1

As I said I was going to, I began the grinding today. The first problem was pretty easy and fairly straightforward.

Problem 1

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

*WARNING: This contains the solution!*

The obvious way to solve this problem is to use brute force. Doing so will result in an easy answer; however, I knew there was a better way. I cannot remember the name of the mathematician who came up with this, but I remembered that the sum of a number sequence is product of the number of terms in the sequence and the sum of the first and last terms all divided by 2.

3 + 6 + 9 + 12 = (4 * (3 + 12)) / 2 = 30

Using this all that needed to be done was find the sum of the 2 number sequences, 3 and 5 (A number sequence would be 3 + 6 + 9 + ... + 996 + 999). Also one thing to keep in mind is that with this method, unlike the brute force, you will repeat every 15th number, this is because the lowest common multiple of 3 and 5 is 15. So we must subtract the number sequence of 15.

Here is my C++ solution.

#include <iostream>
using namespace std;

const int MAX = 999;

int sumOfMultiple(int multiple)
int n = (MAX / multiple);
int last = n * multiple;
return (n * (multiple + last)) / 2;

//using some number theory, O(1)
//3 + 6 + 9 + ... + 999 = (333 * (3 + 999)) / 2
void fastforce()
//get the sum of the 2 multiples (2 and 5) and remove their least common multiple (15) to remove repeats
int sum = sumOfMultiple(3) + sumOfMultiple(5) - sumOfMultiple(15);
cout << "Fast Force: " << sum << endl;

//just plow right through O(n), n = 999
void bruteforce()
int sum = 0;
for (int i = 0; i <= MAX; ++i)
if (i % 3 == 0 || i % 5 == 0)
sum += i;
cout << "Brute Force: " << sum << endl;

int main()

return 0;

C++ Grinding Plans

Unfortunately, through the many years of programming, I have for the most part completely avoided unmanaged code (C++) and stuck with managed code (C# and Java). This is unfortunate for several reasons, but the main reason is that a LARGE number programming jobs want you to know C++. Why? Because it has amazing power and is much more versatile than managed code.

The two reasons I never really learned C++ is because...
  1. San Jose State University Computer Science department offers 1 (one) course on C++ and that is an intro to programming course which wasn't even added until after I was in my upper division.
  2. The way I have learned to program is by completely emerging myself in a project, but my personal projects usually lead me away from C++ for one reason or another. I usually work in C#.
One thing I should say before going on any further is that when I say "never really learned C++" I mean that I never learned the correct way to program in C++. If you count pounding on the keyboard until some sensible character sequence occurred then I suppose I did learn C++. For the last year I have taken a course on Computer Graphics using OpenGL and C++ for it, but the professor assumed that the students knew C++ and consequently we were left on our own. In a hackish manner, I taught myself how to get by - unfortunately neglecting correctness. Towards the end of the semester I decided that was going to change.

My solution began with reading C++ FAQ Lite,which has been extremely educational. In fact so much so that I went ahead and purchased the book... about 2 minutes before beginning this post. I have decided to take things to the next level. I am moving deeper into the dungeon and preparing for some high level monsters - unmanaged monsters might I add!

This is part due to the fact that I have a desire to learn C++ because I know that I cannot make it even close to level 99 programmer without knowing C++. The other reason, and much more pressing one, is that I have a phone interview (and hopefully a follow up in-person interview) with a start-up company that, if they do decide to hire me, will need me to know what I am doing. Crunch time!

As I mentioned, I have been reading lots about C++ and correctness, which is great, but I have not been getting any real XP. This is mainly due to working on other projects using C# (as always). However, I plan to change this. Starting today I am going to begin grinding through C++ and getting as much experience in it as possible (while still maintaining upkeep and efforts in my other projects).

After thinking about this for a few minutes I realized I would need something to focus on besides just C++. I need some type of project or this would never work for me. Fortunately I came up with a solution fairly quick. I am going to start working on Project Euler problems and solving them with C++. These are mathematical based questions and consequently I may do more thinking than programming. Although, I think that the qualifications of a good programmer go beyond being able to being able to simply write code and extend deep into having "Incredibly Tough" logic and problem solving skills. This is exactly what Project Euler problems will be training me in. Wish me luck! I know I'll need it - I looked ahead and some of these problems get complex!

Oh! One last thing to mention. I am going to blog about each problem I do (a way to make sure I get my thoughts completely out). So return for updates, I'm sure they'll be interesting!

A note to C++ programmers: If you see something that I can be doing better please say so. I greatly welcome any type of constructive criticism.

*saved game*

Tuesday, June 23, 2009

Quest Log: "Elephants are minor details"

I have kind of left out some minor details. If you have been following this quest you should know by now what the different item types are (Question Banks, Subjects, Levels, Questions, Annotations, Templates and Quiz Items). I believe there has been some neglect in the second half of this list. So I would like to go over those now.

These are rich text elements that allow the user to add notes, descriptions, narratives, ect. on the quiz. Pretty basic and straight forward.

Very similar to questions. When editing a template it is indiscernible from editing a question. The purpose behind templates is that when making a new question the user picks a template to base the new question off of. Basically it allows the user to enter in any common detail and keep DRY (Don't Repeat Yourself).

An example of this would be making the basic True/False setup of a question in the template and avoid typing it out every time they decide to add a T/F question. The user can also enter other details about the author, keywords, ...ect.

Quiz Items
In my last post I went over this item type in detail except for skipping out on the Lock/Unlock concept. This concept was in the works for a long time but was only recently implemented completely. When an item is added to the quiz it is "Locked" to the original item in the Question Bank. They are one and the same - "Our minds are one." Consequently editing one reference will be reflected on the other. This keeps the data centralized.

With locked items a quiz will only store the question reference. Because of this, quiz files are usually very small. Also this makes updating a single question in several quizzes very easy. Keeping DRY once again!

Unlocking an item breaks the mind meld, and the quiz item becomes its own. This is useful for when a small edit specific to a quiz is needed. Once a question is unlocked that lock cannot be restored. So take care when unlocking an item (don't worry though, there is a prompt window).

Besides the unlocking/locking business I think that the items are fairly straightforward and really easy to grasp. At the same time the user is empowered with versatility and is able to easily and quickly create quizzes (and question banks too!).

*saved game*

Note: "Elephants are minor details" is from the song Elephants As Big As Whales by PlayRadioPlay!

Sunday, June 21, 2009

Quest Log: Item Dissection

Nearly everything is a process and designing the items (ListBoxItems) in the Quiz Generator is no exception. These items are the pivot to the user interaction and overall experience with the application. Consequently they are vital to the overall success of the application and must be good!

This item represents what question banks, subjects, levels, annotations, and templates. As you can see there are several components that make up a single item. There are 3 buttons on all items. The large + button adds the item to the current quiz. The hammer button next to it is the Edit Button that allows the user to edit the item. The third button is the delete button which deletes the item permanently (there is a prompt window to avoid accidental deletions). There is one additional button on Question Banks when they or any items within have been edited since saved last (not shown). This button is directly to the right of the Edit Button.

Everything else is fairly self-explanatory. Moving from left to right, there is a icon and some text representing the item type. Next is the title, "Aerial Sample", and subtitle "test" of the item. Last there are 2-3 items giving details on the item; author, total question, and just question banks have the third item is Last Revised.

Editing an item is very straightforward and fast. This is what an item looks like in edit mode. It simple changes to text entry fields. Originally I had a window pop up to edit the item but that was inconvenient for such simple changes. Questions on the other hand have a separate window for editing. I will go over this on a later date.

Questions are a little different from all of the other items, but not too much. Instead of displaying information about the question, it only displays what the user going to care 95% of the time - the actual question. Because of this, going through a question bank and selecting appropriate items for a quiz is both easy and fast!

Last of all are the items in the quiz. Similar to the other items, they have buttons and vital text. You are already familiar with two of the buttons (edit and delete buttons). The third button, the most left button, is the Unlock button. The function of this button will be described in detail on my next post. Besides these buttons are two pieces of text; the question number on the top and then the actual question in full directly below it. This is RichText and is displayed exactly as it will on the printed quiz (WYSIWYG).

Overall the items are fairly basic. They only display the essential information to keep things clean and elegant. I am very pleased with how they turned out.

*saved game*

Tuesday, June 16, 2009

Quest Log: Skinning the Beast

As you read this post keep in mind that I am a perfectionist. Because of this, I have so often found myself restarting a project or a portion of a project over and over again - always trying to improve what I have. This has been a major cause for why I have so few completed projects. Fortunately, I have been able to tame this in some respect but for the most part I have learned to work around it. One example of this taming/work around is the visual aspect of the Quiz Generator.

Throughout the course of the project I have been tempted several times to scheme up a "skin" for the application. However, each time I would take a deep breath, suppress the temptation and pressed onward with development. Because I knew that it is hard to please me when it comes to a GUI and I would redo it several times if I allowed myself. So it was until I had finished the major functionality of the Quiz Generator (slayed the beast) that I decided it would be a good time to finally do the skinning.

I found myself chanting a mantra throughout this process, "Simple Simple Simple". Keeping the user interface and experience as simple as possible was key. At the same time I was constantly pushing for a rich user interface and experience, which is one of the major improvements I wanted to make from the predecessor. Fortunately, simple and a rich UI/UX are strongly correlated and I was able to accomplish this after much Consideration, Implementation, and Alteration (CIA... yeah, I'm not going to lie. I made this up...).

Moving along, I would like to first show off the face of the application. Prepare yourself!

  1. This is the Browser section of the application. The user searches through the question banks here.
  2. A beautiful breadcrumb navigation strip that functions very similar to the Vista breadcrumb navigation. With this navigating the browser is easy and the user always knows exactly where they are at.
  3. This is basically a toolbar. It provides the user with quick access to the browser's features. This includes basic navigation, searching and adding a new item.
  4. Contains the question banks (navigational), Annotations and Templates (will be discussed in a future post).
  5. This can be many things depending upon what tab is selected in #4 as well as where the user is located inside of a question bank - Question Bank, Subject, Level, Question, Annotation, Template.
  6. This is the Quiz section of the application. The user is able to manage their quizzes in this.
  7. This is an item inside of a quiz. Quiz items are either a question or annotation (simply text).
In case you are wondering at this point. I did everything except for the little question icon (and other items icons), which my wonderful wife made. Everything besides the item icons were made using Microsoft Expression Blend. This is a very powerful tool that I have come to love as a developer.

Blend is a GUI development tool, which basically allows developers to work on the visual aspect of an application without getting their hands dirty with code. The user is able to arrange and modify the elements and XAML code is generated. This can be extremely useful; however, I find that since I worked with writing XAML code by hand for so long before using Blend that while I use Blend I am writing and editing the XAML code by hand more than using the code generation. Blend is undoubtedly useful nontheless.

In my next few posts I will go into more detail on the ListBox Items (Browser and Quiz Items) as well as go over the different elements of the Quiz Generator and much much more!

*saved game*

Thursday, June 11, 2009

Quest Log: Question Bank I/O

Occasionally, the topic of a post requires detail and precision and consequently I feel it is necessary to take a serious tone. Such as the topic of this post was a major learning process for me and I feel I would be doing it injustice to obfuscate it in any way.

The saving and loading of question banks seemed easy enough at first but like many thing was much more complex than I had originally anticipated. A question bank consists of subjects and each subject consists of levels and each level consists of questions. Everything except for the questions are basically folders and therefor only contain a title, subtitle and author (type string). The meat of a question bank are the questions. Each question consists of several fields all of which are string or int type except for the query (the actual question) and the answer. These both need to contain richtext and at first were being held in System.Windows.Documents.TextRange.

The TextRange class has a Load and Save method that allows to read/write from a stream in a specific format with one being RTF. These methods were my keys to being able to save/load a Question Bank or so I thought. The first problem I quickly came up against was that TextRange.Load() will read from a stream but reads from the current position to the end of the stream. This was was a problem because each question bank file contains many RTF sections not to mention all of the other data.

With my experience in Streams being extremely limited, I was stumped on how solve this issue. Fortunately at my favorite programming site, StackOverflow I was able to get some help. The solution is pretty straight forward. I simply had to take each RTF section of the file (the query and answer of each question) and put that into its own MemoryStream. Now when using TextRange.Load() it could read to the end of the MemoryStream and everyone would be happy. Problem solved! ... right?

I continued on with development under the assumption that the I/O had been completely taken care of. As I was completing the implementation of the Question Bank Importer I attempted to import a real FITS Question Bank that has 1703 questions in it. It took about a minute or two to import but that would soon be improved upon so at least it worked! I was excited... but my excitement was short lived. Soon afterward, I found myself going to test something else. I ran the debugger and waited for the application to run...and waited...and waited some more and then finally it opened up. It took about a total of 3 minutes!

Remeber that all Question Banks are loaded at startup. Up until this point of development I had been testing everything with two test Question Banks and each of these had about 5-10 questions in them. Everything worked great with these small Question Banks; however, the reality is that FITS writes Question Banks that can have over 2000 questions in them. This is 200 times more than my question bank. In other words, I had a real problem.

The first thing that came to mind was that I needed to get my hands on a profiler. I had actually never used a profiler before and only had heard about them. After doing a little research I found RedGate's ANTS Profiler. I love this piece of software. After running the profiler I quickly found the culprit. TextRange.Load() was taking an absurd amount of the CPU time, about 83%, with another 10% was being devoted to getting the RTF from the FileStream into the MemoryStream (I was parsing it...).

I quickly realized that there was no way to change the speed of TextRange.Load() and that I needed to find another way to do the I/O for the RTF sections of the file. I once again looked to StackOverflow for some guidance. A few suggestions were made, but ultimately I decided to change the type of Query and Answer from TextRange to simply byte[]. This is a MUCH better approach. In retrospect I can see that TextRange was a horrible design decision. It is designed to be used for selecting a section of a FlowDocument and not for storing data. With the byte[] it simply hold what would go into the MemoryStream and then whenever the text of a query or answer need to be displayed this byte[] is loaded with TextRange.Load().

With this alteration the two major sections of the load time were completely cut out and loading went from 2-3 minutes to an unnoticeable load time (1~ second). Needless to say this was a victory for me. It was quite an issue but with it being solved I was glad to have gone through it. It was afterall a great learning experience.

Code samples can be found in the links to the StackOverflow questions.

Because this was such a huge learning process for me I think I deserve a...

Level Up!
Jasson grows to Level 9 Programmer.
Jasson's HP increases by 20.
Jasson's INT increases by 4.
Jasson learns skill "Profiler".

That's more like it!

*saved game*

Tuesday, June 9, 2009

Quest Log: Redesign

If there was ever an incarnation of WPF it would probably be a beautiful and graceful ballerina. ...ironically this ballerina would have absolutely no clue what WPF is actually. Also like a ballerina, WPF is very flexible. Because of this flexibility, I decided I would do some tweaking to enhance the UIX (User Interface and experience. I made this up) of my application. (You can refer to the basic design in this post.)

First of all I thought it would be cool to have a Breadcrumb navigation for the Browser section of the application. This would make navigating much easier. If you don't know how breadcrumbs work, then you can read about them here. Here is what it looked like.

One of the desired features for this application was to have basic text editing for the questions. So I designed a window that would be used for editing questions - this includes the actual question, the answer to the question and the "details". Here is a screenshot of what I had come up with.

One of the major issues with the original design of this application as well as the predecessor is that you could not see the content of a question without selecting it. Using WPFs powerful Data Templates and Control Templates, I redesigned the items in both the browser and quiz to solve this issue. They take up a little more room, but contain much more information. Here is an early prototype of what a question bank would look like.

A question itself would have a preview of the actual question - Ingenious! So this solved the issue and has a much cleaner feel to it. In both the browser and quiz the items are stacked vertically. The user is able to scroll through the items by double clicking to explore the content of question banks, subjects and levels (all of these are folder type items) and double clicking on a question opens up the question editing window.

Soon after the above screenshot was taken I decided to add buttons onto the individual items for saving, editing and deleting the item. In a few posts I will show a screenshot.

I was finally beginning to be pleased with how things were turning out. It was starting to look nice and it was even working!

*saved game*

Friday, June 5, 2009

Quest Log: Power Overwhelming

The moment I took WPF up in hand, I was hit with a surge of power. Once I gained some control I realized there was much much more to WPF than I had initially thought. Not to mention that I also moved to .NET 3.5 SP1 which had a number of new things as well.

I had never used Routed Commands. Never heard of Dependency Properties. Had no concept of Data Templates, Control Templates, and Styles! Bindings? I will admit it was fairly difficult to completely grasp everything and I am actually still learning.

I definitely would have not been able to do it without the help of fellow bloggers, miscellaneous forum posts and one of my new favorite sites, StackOverflow. Unfortunately I do not have everything bookmarked, but here are some of the sites that were very useful.


This has been the most helpful site for me. It is basically a website were users can post questions and answer questions. That's it!

Dr. WPF - Items Control Series

A blog series by Dr. WPF. It was what really helped me start to learn how WPF actually works and was the inspiration for some of the UI.

Bea Stollnitz Blog
This blog wasn't as helpful to me as some other blogs because of what I was doing, but it definitely has HQ Content (High Quality).

Official Microsoft WinForms and WPF Website
Very useful. I watched many of the videos on the site and plan to watch some more.

Some Site
I don't remember how much I used of this site, but I had it bookmarked and it looks pretty good...

The weekend I made the switch to WPF I did some major grinding. I would say that I was at it for almost 40 hours in the three days. (I had Fridays off... yes, heroes get days off.) Once I returned to the town "SJSU", I couldn't help but to walk up to all of the NPCs and tell them about WPF. But still they all repeated the same thing they always say. I suppose that should have been expected.

Needless to say, I gained a lot of XP from this...

Level Up!
Jasson grows to Level 8 Programmer.
Jasson's HP increases by 1...
Jasson's STR increases by -5... >.>;
Jasson learns skill "Basic WPF"

*saved game*

Tuesday, June 2, 2009

Quest Log: Weapon of Choice

I was pleased with the UX for the most part but not the UI. One thing about me is that I expect only the best from myself and wont settle for anything less. Such as when I am developing software, I constantly strive for a professional level regardless if it is an application or game.

As I began to push WinForms in attempt to create a rich UI/UX, I realized that maybe WinForms did not have the stats I needed for this project. Thus I began to consider alternatives. The two alternatives I considered were...
  1. Qt
  2. Windows Presentation Foundation (WPF)
I had heard of Qt through some job searching and had researched it some. So one day I set out to test the strength of Qt. I started off with some easy low level monsters - probably slimes. Before I had gather much XP (experience points) with Qt, I remembered hearing of something called 'WPF'.

I had heard of WPF a few times before while talking to NPCs but had never seen what it could do. After a little researching, I saw that WPF has some amazing power and versatility when it comes to creating a good UI/UX. Here are a few screenshots of WPF applications that I found on the web.

Screenshot 1

Screenshot 2

With WPF I would be able to continue development with C#, Visual Studio, and of course the .NET Framework, but I would have a more flexible UI. This was exactly what I was looking for! Needless to say, I quickly cast aside WinForms and decided to take up this new found power. Now all I had to do was learn how to wield it...

*saved game*