Geldzin2: Emergency Fund

In version 1.9 (build#77), I implement the concept of an emergency fund. The emergency fund is money that has been saved specifically for emergencies. An emergency is "something unexpected that has major impact on your family". Things that can be saved for or that can wait are not emergencies. The emergency fund "turns crises into inconveniences" (quoting Dave Ramsey both times).

Geldzin2 allows users to specify what their emergencies are. Anything you can think of that you want to have money available for when it suddenly happens should be considered an emergency. The sum estimate is the emergency fund goal. The minimum amount should be held in cash (ready to spend on a moment's notice), and the rest held in a bank account that you do not use for everyday expenses (separate from your main checking account).

During distribution, emergencies are prioritized higher if the minimum amount has not been achieved. Otherwise, they are considered after debts are taken care of. (See image below).

The app considers various factors to determine whether current income should be distributed towards emergencies, including the fund goal, minimum, available cash and emergency account balance, and anything that might have been distributed before but not yet transferred to the account.

To access the emergency fund feature, log into the app and navigate to {Emergency Fund}.

Geldzin2: Public Beta Availability

The latest version of the app (version 1.8) is considered a bonified public beta, ready for release to the masses in January 2012. At this point, users can perform basic financial tasks such as create a budget and categories, track financial accounts and debts, log daily transactions (deposit, expense, income), and distribute income among competing obligations. It also incorporates the idea of charity.

Over the next few weeks, progress towards a milestone version (M1) will involve implementation of other key features, a theme, and reports (including the dashboard). The second release milestone (M2) will bring under-the-hood optimizations and a complete user guide. The third release milestone (M3) will add a mobile website and an Android/iOS app. I project that the final release (version 2.0) will drop around June 2012.

It takes me longer to complete each milestone now because I am a one-man operation with a wife, day job, and hobbies that needs my time. Soon, programming marathons will no longer be possible too, but I will keep pushing to complete this project sooner than June 2012.

Geldzin2: Transactions

In version 1.7 (build#64), I introduce the expected feature of transaction management. Every financial management app provides a means for users to log their expenses, deposits, and transfers. In Geldzin, this feature integrates with categories, debts and financial accounts (and behind the scenes, it affects distributions).

As you can see in the screenshot above, transactions are displayed with the latest on top. Amounts are color-coded (red for outgoing money, blue for incoming money), and linked categories and financial accounts are shown. Expenses can have splits (more than one category assignment). The current version allows entry of income (via Income Distribution), deposits, and expenses. Whenever you use a category that is budgeted, its distributions are affected. For example: an expenditure using a budgeted category will deduct the transaction amount from that month's distribution for the category.
Using the menu immediately above the transaction display, you can also choose to view transactions (1) in a given date range, or (2) for a particular financial account. A future version will provide more comprehensive reports so you can analyze transactions and see your financial trends.

The lifestyle principle is that you should know where your money is coming from or where it is going. With data like this, all kinds of analysis and trending can be done to help make good financial decisions and identify opportunities for efficiency. This data can, for example, be used to refine your budget.

To see this feature in action, access the webapp at http://jubilee.homeip.net:84/geldzin2/ and login. [Demo account is username guest and password geldzin]. Navigate to {Transactions}. Select an option in the {Create New Transaction} dropdown to create an expense, deposit, or distribute income.

Geldzin2: Income Distribution

In version 1.6 (build#56), I introduce the concept of income distribution. This is the second unique feature in my personal finance management system that no one else out there has. Simply put, "income distribution" is the practice of earmarking (or distributing) your income towards budget categories, debt, and other savings goals systematically. It ensures that your immediate budget needs are covered, debt paid off as quickly as possible, and other savings goals catered to. All you have to do is punch in your paycheck whenever it arrives, and the system will tell you how to use it.

As you can see in the screenshot above, you simply plug in an income amount and distribution tells you what should be applied towards charity & giving, current and next month budget needs, and debts or loans. When you save the distributions, it counts as a deposit as well. If there is any leftover money, you have a choice to save it for a future distribution, or spread it out among all your budget areas.

The lifestyle principle is that you should only spend from what you have earned/distributed rather that what you have planned/budgeted. In other words, just because there is a budget doesn't mean the money is there. The budget is only the beginning: income distribution is a necessary second (and ongoing) step.

To see this feature in action, access the webapp at http://jubilee.homeip.net:84/geldzin2/ and login. [Demo account is username guest and password geldzin]. Navigate to {Distributions | Income Distributions}.

Geldzin2: Charity & Giving

In version 1.6 (build#56), I introduce the concept of charitable giving as part of the financial lifestyle. This is the first unique feature in my app that no other personal financial management system has. The idea is simple: you ought to give away a portion of your earnings to charitable causes and helping others; it will make you happier! There is all manner of research and experience that support the connection between happiness and generosity. You are never truly wealthy until you can give away some of your treasures.

In Geldzin, you provide a percentage that will be earmarked for charitable giving during income distribution (called the charity rate). You also provide the name of the category with which charitable giving can be tracked in your transactions.

Apart from the happiness you might derive from generosity, the category is there to help you track charitable giving for tax purposes as well. The charity category is not included in the budget, as the practice is to deduct charity money and applying the rest to budget priorities. This enables people to consider charity and giving no matter what their income is, and to always be generous as long as there is an income.

Check out the feature at http://jubilee.homeip.net:84/geldzin2/ and login with username "guest" and password "geldzin". Select menu {Guest > Profile}, access the "Charity" tab.

Geldzin2: Debts

In version 1.5 (build #39), I add the ability to begin tracking debts. Only basic information about loans and credit cards (how much is owed, when the next payment is due and for how much) is tracked, needed to devise a debt payment strategy (coming in a later version). On this page, you can also see how many payments are left if you were to pay minimums only.

When making a budget, you also need to account for minimum debt payments per month. If there are debts to pay, Geldzin will show debts in categories/budget under a special category highlighting payments that will need to be done throughout the year, as shown in the screenshot below. This gives you a better picture of what your expense budget should be.

You can preview this feature at http://jubilee.homeip.net:84/geldzin2/ (login as guest with password geldzin, select menu Navigate > Credit Cards & Loans). Note that the guest/demo account is reset each night, so any changes you make will be lost overnight). This application is still in beta.

Geldzin2: Financial Accounts

In version 1.4, I add the ability to begin tracking bank accounts and cash. After you figure out how much you will be spending (see Geldzin2: Categories & Budget), you need to know how much money you currently have and where it is held. Aside from that, you should also know how you use the financial accounts, such as if there are any debit cards associated with them. I attempt to meet these goals in the latest implementation of Geldzin2, as shown in the screenshot below.

In the future, I'll provide a means to connect to banks and download balances and transactions, as well as additional account analysis and reports. I'll also provide reminders for when debit cards expire, and notices for when accounts may run out of money based on historical expenditure trends.

You can preview this feature at http://jubilee.homeip.net:84/geldzin2/ (login as guest with password geldzin, select menu [Navigate > Financial Accounts]). Note that the guest/demo account is reset each night, so any changes you make will be lost overnight). This application is still in beta.

Geldzin2: Categories & Budget

In version 1.3, I add features required to manage categories and a simple budget. All this can be done from a single page, as shown in the screenshot below (with randomly generated data).

At top/left section is where you manage categories. All financial transactions must be itemized (or categorized). In the context of categories, you then can create a budget (as seen at top/right section). A category can have any number of budget items, each specifying budget amounts for each month of the year. Annual and monthly totals are displayed at bottom for convenience and quick reference.

My philosophy on personal budgeting is that a budget should initially be designed around expenses only (as opposed to incorporating income). I take this approach for two reasons: (1) everyone has expenses regardless of income, and (2) knowing expenses first helps shape an informed strategy for obtaining income to cover the expenses. A budget is simply rules on how you plan to use money (and doesn't necessarily mean you have that money). Income should later be considered when balancing the budget (in light of actual financial activity) and for forecasting. Once you know how much you must spend, the question then becomes: "how shall I get all this money?". An expense-only budget also helps bring to the forefront your lifestyle and priorities.

Geldzin2: Accounts

In Geldzin2, accounts are the hub of user activity, used to coordinate the various features the user experiences when using the application. The following are planned features for version 1.2 (developer build available Sun Oct-23, 2011):

• Accounts are created when a user activates their profile.
• An account can be linked to multiple users (up to 2), primarily so that each user can have their own login.
• One of the account users can be designated the primary user (the first user assigned to an account is by default the primary). This user is the only one allowed to schedule the account for deletion.
• Accounts can be free or paid. This implementation will support only free accounts.
• Accounts can be personal or business. This implementation will support features appropriate for personal financial management only.
• When a user is removed from an account, the user is scheduled for deletion. The user can no longer log into the the account thereafter.
• When an account is disabled, its users are also disabled, meaning that they cannot log in thereafter.
• When an account is deleted, its users are disabled and removed when the account is removed.

As usual, a developer build of the previous version can be previewed at http://jubilee.homeip.net:84/geldzin2/. To test-drive the application, login as guest/geldzin (for username/password).

NOTE: The guest account is reset every night, so do not expect changes to persist day-to-day. Although the developer drop allows users to register new accounts, this information is lost when a new build is deployed.

Recipe#9: Setup Repository On VisualSVN

Overview: At the start of a software project, you need somewhere to store and version your source code, from where it can also be shared with others on your team. I use VisualSVN Server as my SCM server.

Use case: I am starting the redesign of my financial webapp (Geldzin) and need a new source repository for the project where I will check in source files and other resources, and launch builds + automated tests from.

How-To:
* Open VisualSVN Server. Right-click: Repositories > Create New Repository.
* Provide name {geldzin2} and check "create default structure". [OK].
* If you don't already have users configured, use the "Users" node to create a few.
* If you don't already have user groups configured, use the "Groups" node to create some. Add users to groups so that permissions be set on group rather than individual users.
* Setup security for the repository. Right-click newly created repository, select Properties | Security tab. Set Everyone -> No Access. [Add]. Select group or user [OK]. Give this group Read/Write permissions. [OK].

Recipe#8: Setting Up Parent Maven Project In Eclipse

Whenever you create Maven projects, a best practice is to start with a parent project from which child modules will inherit. The parent POM defines global settings and doesn't itself produce a deliverable. Child modules would include the deliverables, project documentation (user guides and API docs), libraries (if this is a dependency for other projects), etc. It eases maintenance and extensibility tremendously.

This recipe assumes you have Java (see recipe#2), Maven2 (see recipe#6),  and Eclipse (see recipe#3) configured.

In Eclipse:
* File > New > Other. Select Maven | Maven Project [Next]. Use default workspace location [Next]. Select "maven-archetype-quickstart" [Next]. Provide archetype parameters [Finish].
* Update the POM, providing #properties, #description, #licenses, #organization and #developers information, and plugin information for the compiler and surefire (test) plugins. Notice that #packaging ought to be pom.

<?xml version="1.0" encoding="UTF-8"?>
<project ...>
    <modelVersion>4.0.0</modelVersion>
   
    <groupId>com.strive</groupId>
    <artifactId>geldzin2</artifactId>
    <packaging>pom</packaging>
    <version>0.1-SNAPSHOT</version>
   
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <jdk.version>1.6</jdk.version>
    </properties>
   
    <name>Geldzin2</name>
    <description>
        An online personal financial management application.
    </description>
   
    <licenses>
         <license>
              <name>The Apache Software License, Version 2.0</name>
              <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
              <distribution>repo</distribution>
        </license>
    </licenses>
   
    <organization>
        <name>Strive Consulting, LLC</name>
        <url>http://www.strive-ltd.com</url>
      </organization>

    <developers>
          <developer>
            <id>prideafrica</id>
            <name>Jubz Madagascar</name>
            <organization>Strive Consulting, LLC</organization>
            <organizationUrl>http://www.strive-ltd.com</organizationUrl>
            <roles>
                <role>Architect</role>
                <role>Developer</role>
            </roles>
          </developer>
    </developers>
   
    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>${jdk.version}</source>
                        <target>${jdk.version}</target>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.9</version>
                </plugin>           
            </plugins>
        </pluginManagement>
    </build>
</project>

Recipe#7: Simple Maven Webapp in Eclipse

How to create a webapp using Maven, and run it on Jetty in Eclipse. This recipe creates an initial webapp that I want to use as playground for ExtJS 4.x. Requires that you already have Eclipse and Maven configured. Everything is done in the Eclipse IDE.

* Menu File > New > Other.
* Select a wizard: Maven > Maven Project [Next].
* Select project name and location: use default workspace location. [Next].
* Select an archetype: maven-archetype-webapp. [Next].
* Specify archetype parameters: Group Id {com.strive}, Artifact Id {extjs4-projects}, Version {0.1-SNAPSHOT}, Package {com.strive.extjs4projects}. [Finish].
* Create the Java sources directory (src/main/java) and set it as a source folder (right-click: Build Path > Use as Source Folder).
* Open the POM and update #name:{ExtJS4 Sample Projects}, remove #dependencies, #build/finalName:{extjs4}.
* Specify properties and plugins (compiler, surefire, war, and jetty) in the POM:

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <jdk.version>1.6</jdk.version>
  </properties>
  <build>
    <finalName>extjs4</finalName>    
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>2.3.2</version>
        <configuration>
          <source>${jdk.version}</source>
          <target>${jdk.version}</target>
        </configuration>
      </plugin>
      <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.9</version>
      </plugin>
      <plugin>
          <groupId>org.mortbay.jetty</groupId>
          <artifactId>maven-jetty-plugin</artifactId>
          <version>6.1.26</version>
          <configuration>
            <contextPath>/${project.build.finalName}</contextPath>
          </configuration>
        </plugin>
        <plugin>
          <groupId>org.apache.maven.plugins</groupId>
          <artifactId>maven-war-plugin</artifactId>
          <version>2.1.1</version>
      </plugin>
    </plugins>    
  </build>

* Create a Jetty launch configuration to run the webapp in Eclipse: Run > Run configurations. Maven Build | New. Name {JettyRun}, browse workspace and select current project, Goals {jetty:run}. [Apply] then [Run].

Recipe#6: Configure Maven2

When I started programming 8 years ago, ANT was the build tool of choice for Java programs. These days, you are better off using Apache Maven, which adds dependency management, build profiles, and automation for common tasks (like documentation and site generation, distribution, and test).

To install Maven:

1. Download the package from http://maven.apache.org/download.html.
2. Unzip the contents to a location that will be Maven's home directory.
3. Set the "M2_HOME" environment variable to point to the home directory. Some plugins still require it, although it is no longer necessary for Maven itself.
4. Add %M2_HOME%\bin to environment PATH so that you may run the mvn command from anywhere.

By default, Maven creates a local repository under %user_profile%\.m2. To control where artifacts and dependencies are stored, specify an %M2_REPO% environment variable that points to a directory where you want the local repository.

Because I develop in the Eclipse IDE, it is configured it with the m2eclipse Maven plugin, which allows me to void a DOS console when I build projects and do everything in Eclipse:

1. In Eclipse, create an update site for m2eclipse [Help > Install New Software. Add m2eclipse=http://download.eclipse.org/technology/m2e/releases.
2. Select "Maven Integration for Eclipse", click [Next]. Agree to license terms and [Install]. You will need to restart Eclipse.

Before you start using m2eclipse, it pays to look over the configuration. Among the things I changed: having the plugin use the Maven installation from earlier because the plugin references non-release or snapshot version of Maven. If you have other programs or scripts that use Maven outside Eclipse, this action promotes build consistency. Also consider the settings file, which you can now edit in Eclipse.

Some recommended reads on Maven2 can be found at http://maven.apache.org/articles.html. I like "Maven 2: Effective Implementation" because it also touches on Apache Archiva and Continuum. Otherwise "Apache Maven 3 Cookbook" will get you up-to-date on the latest usage of Maven.

Recipe#5: Configure Eclipse for SVN

With access to an SVN server, you need to configure your IDE to connect to available SVN repositories. In Eclipse, you'd need to install and configure the Subclipse SVN plugin:

1. Open menu Help > Install new software ...
2. Add the Tigris Subclipse update site http://subclipse.tigris.org/update_1.6.x
3. Select the Core SVNKit library, JNA library, and Subclipse.
4. After installation, you can further configure the plugin at Window > Preferences > Team > SVN.

To check in a project:  right-click project in Eclipse, select Team > Share Project.
To checkout a project: select menu File > Import, select SVN > Checkout Projects from SVN.
Thereafter, all version control operations (update, commit, add, etc) are available from the Team menu.

Recipe#4: Install an SVN Server

Even if you are the sole programmer on any project, it is imperative that you use version control for your source code and documentation. I use Apache Subversion (SVN) for, among other things:

1. Be able to revert to a previous version of an application, either because my current working copy is corrupted or full of unanticipated bugs.
2. Sharing the project with other developers for collaboration or contribution.
3. Maintaining multiple branches or tagging code at specific milestones.

To use SVN in development, you need an SVN server and SVN client. I use Visual SVN for the server component, installed on a separate machine than what I use for development. VisualSVN is easy to manage and configure, but I mostly like its ability to authenticate via Windows users or your own creations, and access to the checked-in artifacts over HTTP(s) (browser and clients).

On why you have no excuse for not using source versioning:
http://betterexplained.com/articles/a-visual-guide-to-version-control/
http://www.relisoft.com/co_op/whyvcs.html
http://www.mactech.com/articles/mactech/Vol.14/14.06/VersionControlAndTheDeveloper/index.html
http://jamesmckay.net/2009/06/why-would-anyone-not-use-source-control/
http://www.soundsoftware.ac.uk/why-version-control

Recipe#3: Install the Eclipse IDE

No serious Java developer I know writes code in a text editor; you need an Integrated Development Environment (IDE). The benefits of using an IDE can't be emphasized enough, and with many free options out there, you have no excuse. (See a comparison of the major Java IDEs). My IDE of choice is Eclipse.

1. Download Eclipse (http://www.eclipse.org/downloads/). Because I mostly develop web applications, I use the "Eclipse IDE for Java EE Developers" flavor.
2. The platform version you get depends on what JVM you have installed. If the JVM is 32-bit, get the 32-bit version of the IDE.
3. Extract the downloaded .zip to a location that will be Eclipse's installation directory.
4. Run %install_dir%\eclipse.exe. Should open the IDE and prompt you to configure workspaces. My practice is to specify a workspace for each major project I work on, most of which will have many related Eclipse projects.
5. Since Eclipse is not installed like other Windows applications, create a shortcut on your desktop to the Eclipse executable.

You'll get more use out of the IDE if you learn to use it properly. Invest in a book on this topic or Google for tutorials (check out http://www.vogella.de/articles/Eclipse/article.html for a start).

Recipe#2: To Start Developing In Java

To start any Java project, you need to install a Java Development Kit (JDK) on your computer. The kit contains the virtual machine (JVM), the language spec, and a number of other utilities. Only three things need be done to properly install a JDK:

1. Download the latest J2SE from http://www.oracle.com/technetwork/java/javase/downloads/index.html and run its installer.
2. Configure the environment variables so that your installation is available on the system classpath. In either PATH or CLASSPATH, add %install_directory%\bin. At the commandline, you should be able to run java -version and see version information.
3. Create a JAVA_HOME system environment variable and point it to the directory where the JDK is installed. Plenty of Java tools, plugins, applications, and utilities expect this variable to exist.

At this point, you can start developing Java code (using any text editor and the shell/commandline). A word of caution: although Java SE7 has some great new features, some have observed a few drawbacks. Ref: "Java SE 7 'Buggy,' Causing Crashes Says Apache Lucene".

Recipe #1: 12 Commandments of a Java Developer

There are only two requirements to become a Java programmer: (1) know the Java programming language, and (2) have an environment in which to program. The first requirement can be achieved through the many tutorials, books, and college courses that exist today. The environment is as simple as a computer with the JDK installed.

To become a well-rounded developer, however, requires much more than programming. Here are my 12 commandments of software development:

1. Know development paradigms and the software development models. Practice good software development methodologies.
2. Know the tools of the trade, including IDEs, frameworks, plugins, and other utilities that will make development easier and automated.
3. Do not reinvent the wheel: there are developers that have likely solved the problems you will face. Use that body of work, build on it. (And contribute). Specifically, there are tons of libraries out there for all kinds of things.
4. Have project management skills to carry a project from statement/requirements to deployment/maintenance. You have to know everything that affects what you will produce.
5. Have an industry certification such as the Java certification from Oracle. You should also have evidence of training in other products you are training on.
6. Diversify your skills. Be able to develop for various platforms (desktop, web, mobile), use related technologies (networking, databases, integration solutions such as ESB), and know best practices.
7. Network with other software developers and programmers. This is how you will learn undocumented techniques and perhaps land contracts.
8. Contribute to the knowledge base through blogging and reviews of others' work. If you invent a wheel, consider open-sourcing it. Find a few good forums and respond helpfully to topics there. Be an expert in your craft and share the wealth.
9. Stay in the know: technology news, research, and software development publications will keep you abreast with what's going on in the world -- and believe me, it affects your craft.
10. Practice and keep learning: there is always new ways to do things, or new products that could simplify your work. Learn their implications for you. You stand a better chance of landing that job if you can also demonstrate your skills (by perhaps showing something you have developed).
11. Write efficient and highly optimized code, with good documentation. Test your stuff before you release it. This means that you can write good algorithms and have in place a way to test all your code paths.
12. [Minor]: know how to setup the JVM, including the various options required for it to perform optimally.

Finally, Returning To Blogging

Yes, it's been ages since I blogged here. Over the next few weeks, I'll be cleaning up this blog (removing personal posts and focusing the blog on technical content, including software development and running a business). Personal posts will be moved to another blog.
The intent of this blog will be to share my experiences and challenges (and solutions, of course) from the world of software development, which is my current occupation.