All In A Day's Work

Geldzin2: Final Beta Released

2012-01-25T10:59:00.001-07:00

I've just deployed the final beta of my little financial web application (Geldzin). The beta's business goals were to put all core functionality in place while driving for a usable product that would demonstrate the trajectory I envision for personal finance management. The core functionality includes transaction log, tracking financial and debt accounts, categorization of transactions, distribution of income, a couple of spending reports, emergency fund, and charity&giving emphasis. Below is a view of the digest (main) page:

The digest/dashboard provides a snapshot of the overall financial picture. From top-left clockwise, it shows information about your bank and cash accounts (collectively called financial accounts), your credit cards and loans (collectively called debts), a trending chart of total expenses versus total deposits/income over the last 6 months, status of the emergency fund, the most active spending/budget items, and finally the most recent transactions logged. I have room for one more widget at bottom-left but haven't decided what it will be.

While the initial functionality is in place and a useful product is available to users (my wife and I have been using this webapp for over a year), I also had technical goals that this phase needed to meet:

I wanted a real project to hash out my knowledge of Hibernate 3.x. This is the technology I am using for persistence management and database connectivity. The database application itself is MySQL 5.x.
I wanted a real project to play with Spring MVC, which I use to receive all client requests and control access to data. The Spring configuration runs in an Apache Tomcat 6.x web container.
I wanted somewhere to explore Ext JS 3.x, which is what I use for the UI and client/server communication.
I've wanted to exercise the project build capabilities of Maven 3.x, which is what I use to compile and build this project and manage dependencies and releases. In tandem with Maven, I also use Subversion SVN for version control.
I also wanted to improve my development process to include automated testing (using TestNG and Selenium), automated/scheduled releases (weekly in a testbay) and automated data import from old databases to new schema. For some of these, Perl saved the day.
Finally, I wanted to understand the intricacies of hosting Java application on the web. I use eApps, which provides a VPS (virtual private server) with the database application, Tomcat and JVM, among other things, for about $250/year.
Figure out what it takes to obtain a patent for software like this.

All these goals were met during this phase (except #7 which is still in the works). The next phase will focus on how to create better UIs (user interfaces), webapp themes (look and feel), producing technical documents (quick start and user guides, source API), mobile sites (using a framework like jQuery Mobile), how to estimate project development costs better (financial and time), and a few other business features in the release candidate (RC1). It is a learning process.

Geldzin2: Emergency Fund

2011-12-15T10:49:00.002-07:00

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

2011-12-12T13:37:00.000-07:00

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

2011-12-09T10:14:00.001-07:00

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

2011-12-07T15:01:00.001-07:00

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

2011-11-21T13:56:00.001-07:00

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

2011-11-13T15:27:00.001-07:00

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

2011-11-09T11:57:00.000-07:00

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

2011-10-31T18:17:00.001-06:00

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

2011-10-16T22:08:00.000-06:00

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

2011-10-06T12:29:00.001-06:00

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

2011-10-03T06:54:00.001-06:00

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

2011-10-01T06:51:00.000-06:00

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

2011-09-20T11:58:00.001-06:00

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:

Download the package from http://maven.apache.org/download.html.
Unzip the contents to a location that will be Maven's home directory.
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.
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:

In Eclipse, create an update site for m2eclipse [Help > Install New Software. Add m2eclipse=http://download.eclipse.org/technology/m2e/releases.
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

2011-09-07T11:18:00.000-06:00

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:

Open menu Help > Install new software ...
Add the Tigris Subclipse update site http://subclipse.tigris.org/update_1.6.x
Select the Core SVNKit library, JNA library, and Subclipse.
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

2011-09-06T11:01:00.002-06:00

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:

Be able to revert to a previous version of an application, either because my current working copy is corrupted or full of unanticipated bugs.
Sharing the project with other developers for collaboration or contribution.
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

2011-09-02T10:17:00.004-06:00

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.

Download Eclipse (http://www.eclipse.org/downloads/). Because I mostly develop web applications, I use the "Eclipse IDE for Java EE Developers" flavor.
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.
Extract the downloaded .zip to a location that will be Eclipse's installation directory.
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.
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

2011-09-01T12:07:00.000-06:00

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:

Download the latest J2SE from http://www.oracle.com/technetwork/java/javase/downloads/index.html and run its installer.
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.
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

2011-08-30T11:41:00.000-06:00

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:

Know development paradigms and the software development models. Practice good software development methodologies.
Know the tools of the trade, including IDEs, frameworks, plugins, and other utilities that will make development easier and automated.
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.
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.
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.
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.
Network with other software developers and programmers. This is how you will learn undocumented techniques and perhaps land contracts.
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.
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.
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).
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.
[Minor]: know how to setup the JVM, including the various options required for it to perform optimally.

Finally, Returning To Blogging

2011-08-29T06:48:00.003-06:00

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.

Hibernate3 Tip#7: find(), merge(), getReference()

2010-01-15T13:28:00.001-07:00

find() is for retrieving objects from the database - always generates SQL and loads into memory an object initialized according to the active fetch strategy. If you have newly created objects in a persistent context but have not called flush() or committed the transaction, find() will not find them and will return NULL (even if you have called persist()).

merge() is for retrieving a persistent version of a detached or transient object. If not found in the persistent context caches, an SQL statement is issued to retrieve the object from the database, and dirty checking is done to merge the objects. Because it uses non-NULL properties of the detached or transient object to overwrite the retrieved object, you want to be careful about how you use attribute defaults. So watch out when working with transient objects.

getReference() returns a proxy with only the identifier initialized, and does not hit the database. If you are not working directly on an object (such as when it is used only as a reference in queries or other objects), you want to use this strategy. Rule of thumb: if you have entity references in an object, this is likely how you refer to them. Note that the proxy has all other properties set to NULL. To fully initialize the proxies, you'd need to find() or merge().

Hibernate3 Tip#6: QL Parameters Are Objects

2010-01-06T23:13:00.003-07:00

Consider an entity User that has a many-to-one reference to a Role entity. Each of these entities has an identifier field used to uniquely identify objects. The database schema would be such that the Users table has a column (usually of a numeric data type) with a foreign key constraint to a Role. Supposing you wanted to get all users with a specific role, plain SQL allows querying with a "where user.roleid=?" and providing a numeric type that matches the role's identifier type.

In Hibernate, however, this strategy fails with a "org.hibernate.PropertyAccessViolation: could not get a field value by reflection" exception. Hibernate expects you to provide actual objects as parameters. Thus the QL for the above scenario would require you to find the persistent Role object first, then pass it (or its proxy given by getReference()) as a parameter. Alternatively, you may choose to use native SQL queries. You may consider this a side effect of using an object-oriented persistent layer and query language. It is particularly useful in resolving object identity issues where perhaps more than one property is used to define the object's primary key.

Hibernate3 Tip#5: Initializing Entity Objects

2010-01-04T11:27:00.005-07:00

When you create entity classes, it is NOT a good idea to initialize entity references with defaults. Only initialize class attributes that are not references to other entities, and leave references NULLed, except the collections. A new identifier is assigned when a transient object is persisted, overriding whatever default you might have assigned. Having defaults may cause dirty checking to consider them changes that should be propagated to the database when merging or reattaching objects. For newly created objects, the dynamic update feature (if enabled) prevents sql statements that consist of null values (see this tip), and the database uses whatever the default is. (It is better for defaults to be defined in the @Column annotation).

When modifying objects, you only need change what needs to be changed, and if you have dirty checking enabled, only those changes will be propagated to the database. Also note that if you want to use a specific identifier for an object, you should call merge() to obtain a persistent version with that identifier almost immediately after initializing it. Otherwise you'll get a "detached object passed to persist ..." exception sometime when you attempt to commit the transaction. This is one pesky annoyance you discover only with experience.

Hibernate3 Tip#4: One EntityManagerFactory Per Persistence Unit

2010-01-01T11:29:00.006-07:00

If you use Hibernate3 for web applications, you must define a persistence unit (database connection and entity metadata from annotated classes or XML mappings). These are essentially the settings that describe how to connect to the database and describe the schema i.e. how tables are laid out and various relationships/constraints between the tables physically.

At runtime, you make persistence unit configuration available to the web application through an entity manager factory. Its main job is to instantiate entity managers for you that provide the persistence context in which you manipulate the database. Although you can create multiple factories based on a single persistence unit, it is not recommended. Instead, you ought to instantiate one statically-scoped entity manager factory and provide a thread-safe accessor that employs the singleton pattern to ensure there's always only one. That accessor initializes a new EMF if none exists and return EntityManager objects.

An example that uses a persistence unit called "puGeldzin":

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public final class DBUtil {
private static EntityManagerFactory emf;

public static synchronized EntityManager entityManager() {
    if(emf == null) {
        emf = Persistence
            .createEntityManagerFactory("puGeldzin");
    }
    return emf.createEntityManager();
}
}

Hibernate3 Tip#3: Methods You Should Override

2009-12-30T20:02:00.002-07:00

Just some general best practices that have saved me considerable development time as I've worked with Hibernate3:

Always override equals(). Objects that are equal as plain Java objects are often not equal in Hibernate3 because of the identity problem. Hibernate considers the object's persistent state, database identity, and other factors to determine if two objects are equal. By overriding equals(), you set a standard of equality both Hibernate and Java can use.
It is a bad idea to override equals() in subclasses. Hibernate does not behave well.
Always override hashCode() and provide your own implementation based on the class's attributes that are expected to change rarely. I use the class identifier commonly. Actually, overriding equals() almost always requires overriding hashCode().
When you implement equals() and hashCode(), always use property accessors - getXX()/setXX(), POJO style. Hibernate allows the use of proxy classes or references that may no contain actual data if you call their properties directly. Believe me, this is a pain to debug!
Always make classes Comparable in case objects of the class end up in collections that require this feature (such as SortedSet or other collections that use a class-dependent Comparator). This gives you the flexibility to switch collection types whenever (e.g. from List to Set) without further base code changes.
I also always override toString() because I hate seeing memory addresses as representations of objects. I use it for debug information that I can print out and understand, and that uniquely identifies the object for me.

Pretty much every OOP project I've worked on, these are some of the first tasks that get done. If developers would just get in the habit of these best practices, I wouldn't dread inheriting their projects so much.