Cash Tracker is a tool I built to help answer these questions more quickly than pencil-and-paper ever could. Cash Tracker not a budgeting application per-se. Instead, it begins by answering the most basic of questions—how much money will I have in a month, 6 months, or a year—in the simplest way possible.

Cash Tracker Online is a first step at bringing the tool I made for myself to the general public. Getting started is easy! First, go to www.cashtrackeronline.com (a secure website that will keep your information safe and private) and click the button that says ‘Register Now’. The site will guide you through registering and “tracking” your first bank account.

Once you have your first account being “tracked”, you can start adding recurrences (these are usually either bills or pay checks). The site will automatically start predicting your financial future using projected data points (such as your projected high and low balances over the next year). As you add more income and expenses, your “Account Balance Over Time” graph will allow you to visualize your financial state over the next year.

In the next few weeks I will publish some more articles showing just how powerful Cash Tracker Online can be. In the meantime, head on over to www.cashtrackeronline.com to take your finances for a spin!

Over the next month or so I’ll be working on some new features and cosmetic changes to make the tool easier to use and understand. Stay tuned for the beta’s elevator pitch.

Most services that turn blogs into books either require you to use one of the big hosting sites (like yourblog.wordpress.com), and of those that will take a simple WordPress XML export, the only one I could find that could handle the enormous file was a site called FastPencil. A problem that was universal, though, was finding a service that would import the file AND retain some semblance of layout in regard to pictures and text, block-quotes, centering, etc.

Then I discovered a project called WPTEX. It is a collection of PHP scripts that asks a few questions and then converts (or, attempts to convert) a WordPress blog to LaTeX, which can in turn be converted to a PDF using PDFLaTeX. The only problem was WPTEX didn’t really do a graceful job with my wife’s blog, which is rich in pictures and special formatting.

By this time I had enough information to decide to forge out on my own. I started by writing some C# that would read a WordPress export file (quick and dirty-like) into some data structures. Then I went off looking for an HTML-to-LaTeX converter online. I discovered Pandoc. After installing the Haskell-based markup converter, I started using it to convert my wife’s post titles and content to LaTeX. It was a brilliant success. I then wrote some code to recognize when it needed to download an image to include in the book and to strip out the obvious hyperlinks. Now we’re in the process of manually doing a lot of the centering and layout changes that were so cumbersome using those online services. To my surprise, LaTeX has been very easy to work with. In part two I’ll cover some of the (did I say dirty?) code that made it all come together.

I don’t plan to advertise the project anywhere but here and perhaps on facebook to my friends, so chances are I’ll be the only user for quite some time while I work out the kinks in what I consider a limited but stable beta. And honestly, that is okay. I am producing the tool as a favor to myself alone, a selfish indulgence. If it becomes something people really want, then great. If not, my purposes are still served.

Anyway, here is the run-down (straight from my personal OneNote notebook!) of things that need to be done before launch:

• Get CTO up and running on www.cashtrackeronline.com via GoDaddy hosting and MS SQL database
  • Upgrade to Ultimate Hosting
    • Upgrade to 4GH to get SQL Server 08
      • Have to contact support (question sent in, awaiting a response)
  • Domain setup/assigned
  • SSL Certificate setup/assign
  • Project files uploaded
  • Database schema scripted w/ sample data
  • Third party binaries uploaded
  • Test and fix anything I missed
• Add a registration page (keeping it simple, just ask for username (e-mail), display name, and password for now)

Once that is all worked out, I’ll focus on new functionality. Stay tuned!

1. Logic for budget accuracy calculations (just a method right now, no actual implementation on the site yet)
2. CRUD for recurrences (and a slick interface to boot—I’m really enjoying working with these DevExpress controls)
3. Account balance projection chart

So, that leaves the following stragglers on my to-do list before the first release (likely to be labeled an alpha—not all features are there, not everything works):

• Actual implementation of the budget accuracy calculations (displayed as % error)
• Logic/implementation for budget adjustment suggestions
• CRUD for manual entry and adjustments
• GUI work
• Data export
• Wizardry for new users to introduce them to key elements of the app

I’m really excited about where things are going with this project, to the point that I don’t think the Windows version of this project is going to be able to keep up with all the great features. I’ll tune in again next Thursday at the latest for another update on this (probably sooner). I should have some real web hosting by then, so I’m pushing hard to get a release out in the next two weeks.

1. Worked out web and data hosting (thanks boss). GoDaddy just doesn’t give me enough control over things to go that route with any real web applications (although they’re great at hosting this blog!)
2. Decided on some controls I’m licensed for through work. They aren’t free, but if you want to debug through any source code I make available you can install a trial. I decided quality was more important than making the code super easy to share in this case.
3. CRUD finished for accounts.
4. Some back-end work done on recurrences/transactions.
5. Balance calculations are working.

Immediately next on my list are:

• Logic for budget accuracy calculations (this one’s a new idea)
• Logic for budget adjustment suggestions (based on the accuracy calculations, also a new idea)
• CRUD for recurrences/manual entry/adjustments.
• Account balance projection chart
• More time spent on GUI design
• Data export functionality
• Process to drive new users to the most useful functionality right away so they see the real benefits over time (following the visualize, control, predict pattern):
• Set up an account with recurrences to visualize the current state of the account
• Use transactional adjustments to correct the budget with actual figures
• Modify budget (recurrences) based on suggestions (control)
• Using an established budget and calculations based on the average error margin, allow the website to predict the most accurate balance curve possible over the next year

I’m happy with the progress I have made so far. I have a lot of the groundwork laid, but it will still be a few weeks before the initial version is ready to be published. Here’s the summary…

Finished Work

1. Domain purchased
2. Database Schema tentatively complete
3. Website project created
4. Simple Logo produced
5. Default / login screen working
6. Error handling in place, notifications of problems being routed correctly
7. Maintenance mode working
8. Dashboard “shell” built
9. Accounts summary pane on dashboard finished

Needed Before Release

1. A place to host the website and database (being worked out, should have this soon)
2. Make a decision on whether to use some third party controls and which ones
3. CRUD (Create, Read, Update, & Delete) for:
   • Accounts
   • Recurrences
   • Manual Entry
   • Recurrence adjustments
4. Balance calculations
5. Account projections
6. Graphical visuals
7. Data export

I already have the database all laid out on paper, and I will make database diagrams and code samples available as I finish them. At some point I may be forced to stop posting source code for the sake of security, but until I start collecting sensitive data (right now the data I track can’t be tied to anyone or any actual accounts), I will continue to post code here.

• Improved interface:
  • Allows you to select the recording area from a list of pre-defined options
  • Allows you to move the window around to “frame” your recording area
  • The window containing the recording area stays on top, so you always know what you’re recording
• AVI files are now compressed using the WM3 video codec, resulting in far smaller file size
• Frame rate is now throttled at 25 frames-per-second, resulting in somewhat-smaller file size
• Ability to overwrite files when saving.
• Progress bar shows save progress while exporting the AVI file.

If you already have Screen Tracker, you should get the update the next time you use it. If you don’t have it yet, just click the Screen Tracker link under “Downloads” or go to the Screen Tracker page to install the latest release.

1. Progress bar when saving the .avi file (a piece of cake, but time-consuming to implement)
2. Use a compressed format (the current file-sizes are enormous!)
3. A resizable “recording area” instead of the X, Y, Height, and Width boxes.
4. A “quality” radio button that increases performance at the expense of frame-rate (and maybe even the image quality)

The Roadmap
I believe I am the only person who uses Cash Tracker on a consistent basis, but I’ve found the application so useful that I’m going to plow ahead until I’m satisfied. So, for the Cash Tracker 1.0 release I plan to unveil some big new features. Plus, I’ve determined to create an online version of the tool. Here are the steps needed to proceed to that point:

1. Add most or all of the features on the upcoming features list
2. Acquire a catchy web domain name and SSL certificate
3. Possibly re-brand Cash Tracker under a different name for the web (i.e. whatever catchy domain name I find)
4. Port the Windows project to a data-driven website project using ASP.NET and SQL Server technologies

Contributions
If you’d like to contribute to the project, just drop me an email; I’ll be happy to set up a source control server. The project doesn’t really need funding beyond a web domain and SSL certificate purchase, but an extra pair of coding hands would definitely accelerate the release timeline.

So what goodies do you have for us?
The tool I will post (most likely tonight or tomorrow, under the name Screen Tracker) will do the following:

1. Record frames from the screen or a portion of the screen to a working directory.
2. Compile the frames into an AVI formatted video file.

And my upcoming feature wish-list:

1. Audio recording (either through the computer itself or via a microphone, maybe both)
2. The ability to add an .mp3 or .wav audio track

Audio/video is not a world I am well-versed in, so don’t hold your breath on the wish-list Just hope my great idea motivates me to make useful tools for you.

Cash Tracker going Beta
I’ve been using my latest version of Cash Tracker for a while, now, and it’s been working beautifully for me. I will probably post the most recent code and installer tonight or tomorrow as well. It’s ready for beta status, so I’ll update that designation as well (and maybe someone else will actually start using it!).

Timeout expired. The timeout period elapsed prior to obtaining a connection from the pool. This may have occurred because all pooled connections were in use and max pool size was reached.

My Research
On the website in question, I use LINQ-to-SQL heavily to perform data operations. Naturally, I suspected that I wasn’t disposing of my DataContext objects correctly, causing me to exceed the number of connections available in the pool. After doing a little research on the subject, I read in several articles (some by folks who are much more knowledgeable than myself) that I shouldn’t have to dispose of them. They all said the following code is just fine:

CORDataContext mcon = new CORDataContext();
COR_Employee emp = mcon.COR_Employees.FirstOrDefault();

In fact, I should be able to put that into an infinite loop and never get the exception I was encountering. According to the experts, LINQ is not only smart enough to automatically open and close the connection for me, but also smart enough to dispose of the object when I’m done. No need for a “using” around my code or even a Connection.Close().

An Exception to the Rule

I noticed, though, that my code was slightly different. In my specific setup, I have a central database and a LOT of other databases I might want to connect to. So, to take advantage of connection pooling more, I always connect to the central database first and change to whatever catalog I need to access. In doing so, it is necessary to manually open the connection, like the following:

CORDataContext mcon = new CORDataContext();mcon.Connection.Open(); mcon.Connection.ChangeDatabase("OtherDB");
COR_Employee emp = mcon.COR_Employees.FirstOrDefault();

My Testing

I began to theorize that manually opening the connection in this way keeps the connection alive after I’ve run my query. I confirmed the belief by trying to run the following code:

for (int i = 0; i < 1000; i++) {

    CORDataContext mcon = new CORDataContext();
    COR_Employee emp = mcon.COR_Employees.FirstOrDefault();
    mcon.Connection.Open();
    mcon.Connection.ChangeDatabase("OtherDB");

    Console.WriteLine("" + (i + 1) + " / 1000");
}

I got the exception after 230 or so connections. By default there are 100 connections available in the pool, but the garbage collector kicked in and helped give me a buffer before I ran out. So, from that I can conclude that manually opened DataContext connections will stay open until the connection is closed or the DataContext is disposed.

The Solution

Once I fully understood the problem, the fix was common sense:

for (int i = 0; i < 1000; i++) {

    using (CORDataContext mcon = new CORDataContext()) {
        COR_Employee emp = mcon.COR_Employees.FirstOrDefault();
        mcon.Connection.Open();
        mcon.Connection.ChangeDatabase("OtherDB");

        Console.WriteLine("" + (i + 1) + " / 1000");
    }
}

Adding a “using” to automatically dispose of my DataContext did the trick, and this loop now finishes in about 3 seconds (even with the overhead of writing to the console). I hope this helps someone else, because it’s been plaguing me for weeks!

Me: “How does the car go?”

Mom: “I press the gas pedal and it goes.”

Me: “What does the gas pedal do that makes the car go?”

Mom: “I don’t know, ask your father.”

I probably had 5-10 conversations like that per day from the age of 3 until the age of 12. I was (and always have been) thinking about the details.

I define seeing the details as being able to look at something and dissect it into its smallest parts. This is a valuable skill for any programmer, and, I believe is what separates people who should learn to code from those who might be better off avoiding it. I had far too many classmates who were in it for the money, but had no passion or thirst for understanding. That drive is a key determining factor about someone’s future in software development. Seeing the details in my job means being able to mentally translate an assignment into code, including all the edge-conditions, so I can accurately estimate how long a project will need for completion. Seeing the details means being able to predict potential problems in January while the team is planning instead of getting caught off guard in June while we’re coding. It even means not writing the bugs other developers might. Yes, seeing the details is a valuable skill in software development, and I don’t see that changing anytime soon.

I never was a big picture kind of person growing up. I made passable grades on my papers in school because I could make really wonderful points, but I had trouble making everything from the first sentence to the last cohesive. Instead, my papers ended up often containing a few somewhat related ideas with an underwhelming effort to tie them together. As it turns out, while seeing the details is an important skill in software development, the converse is equally true; being able to let go of fine details and see the big picture is necessary for anyone who is more than just a code-monkey.

I define seeing the big picture as being able to look at something and understand not just how it can or does work, but how it could and should work. Seeing the big picture also means being able to look at something and understand how it should coexist and cooperate with other things. This is a valuable skill for anyone who wants to be more than a programmer. It separates people who should get a coding job and just take their annual pay increase from those who should attempt to scale the ladder.

I really believe that to be a truly successful leader in software development both of these skills are a must. One or the other just won’t do. Those who can only see the big picture can be great managers of small or open-ended projects, but without being able to see the details a project manager must rely on his developers to understand what a project will cost. Alternatively, those who can’t see past the details are wonderful programmers, but without seeing the big picture a developer must rely on his manager for direction. In my opinion, someone who has both skills can be a great leader and an invaluable asset, adding efficiency to an entire department.

With .Net 3.5, Microsoft released the DataContractSerializer. It has a variety of uses, but at the very least it’s an improvement over the XmlSerializer. In Cash Tracker we started out by using the XmlSerializer to save files, but quickly found it inadequate, the reason being XmlSerializer does not play well with mixed access properties.

For an example, let’s look again at our Person class:

public class Person {
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Initials { get; private set; }

    private Person() {
    }
    public Person(string first, string last) {
        this.FirstName = first;
        this.LastName = last;

        this.Initials = String.Format("{0}.{1}.", FirstName[0], LastName[0]);
    }
}

Notice I’ve added a new property with a private mutator. Also, I added a constructor to take advantage of the new property and made my default constructor private. Now when we try to serialize using the XmlSerializer we get an error:

Unable to generate a temporary class (result=1).

error CS0200: Property or indexer ‘Person.Initials’ cannot be assigned to — it is read only

What to do?

In .Net 3.5, to get around this problem, Microsoft suggests using the DataContractSerializer, so we will investigate switching to the new technology here. First, we need a reference to System.Runtime.Serialization:

Once that’s done it’s actually pretty simply converting our old code. The new code looks like this:

static void XmlSerializePerson(Person myPerson, string fileName) {
    DataContractSerializer xs = new DataContractSerializer(typeof(Person));

    using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write)) {
        xs.WriteObject(fs, myPerson);
    }
}

static Person XmlDeserializePerson(string fileName) {
    DataContractSerializer xs = new DataContractSerializer(typeof(Person));

    using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) {
        return (Person)xs.ReadObject(fs);
    }
}

Notice we simply re-used the old methods, changing the object and methods used to serialize our Person. Our code will now execute as expected:

Download the Solution

You can download a zip file of the solution by clicking the link below.

DataContractSerializerDemo.zip

Class: Person

Below is a simple class Person. My person has a name and an age:

public class Person {
    public string FirstName { get; set; }
    public string LastName { get; set; }

    public Person() {
    }
}

The XmlSerializer requires that I leave an empty constructor in my class. I can make the constructor private if I don’t want it used for other things. Now, let’s create an instance of a Person.

class Program {
    static void Main(string[] args) {
        Person myPerson = new Person();
        myPerson.FirstName = "John";
        myPerson.LastName = "Smith";
    }
}

How to serialize our class

I will add a couple methods now to handle serializating and deserializing myPerson.

static void XmlSerializePerson(Person myPerson, string fileName) {
    XmlSerializer xs = new XmlSerializer(typeof(Person));

    using (FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write)) {
        xs.Serialize(fs, myPerson);
    }
}

static Person XmlDeserializePerson(string fileName) {
    XmlSerializer xs = new XmlSerializer(typeof(Person));

    using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) {
        return (Person)xs.Deserialize(fs);
    }
}

Code in action

Now, saving myPerson is simple:

static void Main(string[] args) {
    Person myPerson = new Person();
    myPerson.FirstName = "John";
    myPerson.LastName = "Smith";

    XmlSerializePerson(myPerson, @"C:\MyPerson.xml");
}

Let’s take a look at the resulting XML:

<?xml version="1.0"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <FirstName>John</FirstName>
  <LastName>Smith</LastName>
</Person>

Now, let’s deserialize our person and display its data:

static void Main(string[] args) {
    Person myPerson = XmlDeserializePerson(@"C:\MyPerson.xml");

    Console.WriteLine("Name: " + myPerson.LastName + ", " + myPerson.FirstName);
    Console.ReadLine();
}

The result:

As you can see, the XmlSerializer did its job.

Download the Solution

You can download a zip file of the solution by clicking the link below.

XmlSerializerDemo.zip

It’s really rough; I’m giving it a version of 0.7. I don’t have any error handling in place, so if you put the wrong values into the tracker it will probably scream at you and then die. If you’re not a geek you probably want to wait at least until version 0.9 gets released. Until then, I’m probably not going to settle on a reliable file type, so .tfx files saved before 0.9 probably won’t be compatible with later versions.

For a current list of features, check the Cash Tracker’s main page.

The idea for Cash Tracker came to me when I was trying to find an easy way track my own finances. I wanted something I could put my income and bills into and get a simple projection of my account balance throughout the year. Then, if I didn’t mind making adjustments later to reconcile (thus improving the projections as time goes by), I wanted to be able to enter a manual transaction here and there, too. But my main focus was keeping it simple. So, I wrote a very simple program that reads in a set of recurrences (bills, income) and transactions (non-recurring expenses or adjustments to bills/income). Then, it displays a set of numbers that are designed to help give me peace of mind about the future, like my project low and high balances for the year. To help me reconcile with my balance at the bank as the year goes on, I had the program output a running total I could open in Excel and compare with the bank.

Right now, that’s pretty much all the Cash Tracker does. It’s ugly, but it works as well as I need it to and keeps me from worrying about my finances. The project I’m undertaking is to bring Cash Tracker from “personal helper” to “helper to a lot of people” by making it easier for people to use who can’t write code or format a flat file correctly; people who don’t know what a CSV file is or what XML looks like. And, of course, I want to bring the Cash Tracker to other people like me who just don’t want to waste time on a “big” personal finance application, but still want to feel secure financially and have some numbers to support themselves with. I’m doing this solely because my Cash Tracker has helped me organize my own finances so much over the past 3 months.

I think Cash Tracker will appeal to many people because it makes maintaining finances so painless. Now that I have all my income and expenses into the program, it takes me just a few minutes every week or two to make the current projected balance line up with my actual balance. That includes the time I spend editing ugly, tab-delimited files. I am sure I can speed up the process even more.

So, the goal right now is to get the Cash Tracker into a form that other people can actually use. Eventually, I’d like to get it to “auto-magical” status, which would look something like this:

1. Select your financial institution
2. Enter your login credentials
3. Hit “Track It!”
4. <magic>
5. View a list of your regular expenses and income, your projected high and low balances this year, your projected balance for any date in the future, etc.

We’re talking zero maintenance. I believe we can get there, but we’re going to take baby steps.

In your class definition you need to implement the interface System.Web.SessionState.IRequiresSessionState. Once you’ve done that you’ll find yourself magically able to use session once more.