Geebis Blog

Online or Offline

2007-08-14T15:19:00.000-07:00

Today I read a Newsblog by Elsa Wenzel at CNET titled Intuit building Quicken Online.

Intuit is planning to release a Web-based edition of its leading personal finance application this winter, possibly early in 2008. Quicken Online marks a key transition for a company that has made its bones selling new versions of its boxed software each year.

Quickbooks Online edition has been available for some time, and I’ve yet to hear much about it. Intuit offers a 30 day free trial of the product – and then 40% off the first thee months subscription rate. I was curious what that rate is, but the product requires IE6 or IE7 with ActiveX to work, and that’s just too annoying. Wenzel reports the new Quicken Online will be similarly burdened with Explorer.

I found another Quickbooks webpage where they claimed 75% savings and offered two products – one at $20 per month and the other at $40 per month. Both cover three seats. I’m too annoyed to try to figure out what the difference between the products is – but it’s interesting to see the company making differently priced offerings at different places on their official website. It must be very confusing.

What I can see of Quickbooks Online is that it appears to function just like their ancient box software. Of course this familiarity is important when migrating customers from the old model to a new model. But, what is really new about the new model?

The two elements that I can see that would really stand out are the global access and the automatic backups. And of course, the annuity income is new for Quickbooks. Low monthly billing that adds up to more than the old.

Will QB users migrate to the more expensive online edition?

From Wenzel’s article:

A few years ago, folks at Intuit told me they saw virtually no demand for online tools. Last week, the company said it's taken so long to cook up Quicken Online due to the lack of consumer trust. While it may be common for those within the technobubbles of Silicon Valley and San Francisco to opt for paperless billing, many millions more see managing their money via the Internet as about as safe as dropping a wallet in a mall.

I have to agree. Every small business I’ve encountered is absolutely terrified of the internet. Last week, I couldn’t get a small company to even consider using google mail for their domain (free vs fee) because they were somehow sure Google would reveal some deeply secure restaurant secret to the Feds.

And recently, I’ve found it nearly impossible to get anyone over 30 to sign up on FaceBook. I’ve even been told that FaceBook is a secret CIA database to gather information about everyone in the world.

The fears may be unfounded (I hope), but they are quite real. I can talk and talk and talk, but the fear is too great.

Somehow, I expect these fears dissipate inversely with age. If you’re young and grew up with the web, you’re likely to better understand the realistic dangers and rewards of online applications. There certainly are reasons why you might choose to keep financial data local – and well secured.

I can’t predict the rise of online accounting for this very reason. Is it inevitable? Maybe not. Most of the business people I know are hesitant to allow even a pro into their books. This is probably because most of them are cheating Uncle Sam to some degree or another (and not doing a good job of hiding it). Will these people be persuaded to put the data up at Intuit where the Feds will have centralized access for data mining? (Which is now legal without a warrant)

Now I’m sounding like a conspiracy nut.

Only time will tell.

In the meantime, we’re designing Geebis to be browser and platform independent. You won’t have to use Windows. You won’t have to use IE. We’re also designing the software to be online or offline. Let the customer choose.

Bell bottomed pants, pet rocks, and hula hoops

2007-07-24T15:26:00.000-07:00

How do you tell the difference between a fad and a trend?

I still meet people today (though noticeably fewer) who tell me that computers are a fad that will pass away. They tend to be older people, often men who never learned to type.

I remember when typing was considered "unmanly". I had a short period in my early adulthood where I was teaching other adults to type. The guys were always resistant.

People who claimed computers would pass away like the next fad were taken seriously in the '70s and '80s. A crop of "the internet is insignificant" arose in the '90s. Often, I meet people who do not use computers or only use them for email (and can't figure out how to do those crazy attachments). They tend to be public school teachers. No kidding.

So, despite public school teachers being one of the most resistant groups to technology, technology is embedding itself deeply in the next generation. I am frightened what might happen when education decides it must teach technology. At that point, will we see massive failure? Perhaps it's best to leave the kids alone. They seem to learn a great deal more that way.

From the New York Times today:

While young people embrace the Web with real or virtual friends and their cell phone is never far away, relatively few like technology and those that do tend to be in Brazil, India and China, according to a survey.

Only a handful think of technology as a concept, and just 16 percent use terms like "social networking," said two combined surveys covering 8- to 24-year-olds published on Tuesday by Microsoft and Viacom units MTV Networks and Nickelodeon.

"Young people don't see "tech" as a separate entity - it's an organic part of their lives," said Andrew Davidson, vice president of MTV's VBS International Insight unit.

"Talking to them about the role of technology in their lifestyle would be like talking to kids in the 1980s about the role the park swing or the telephone played in their social lives -- it's invisible."

What we older folks think of as "technology" has embedded itself so deeply in the younger generation that it cannot be thought of as separate.

Toto, we're not in Kansas anymore.

QuickBooks EasyStep Interview

2007-07-23T19:34:00.000-07:00

Imagine being an average Joe trying to get a business up and running.

The slideshow below documents the 28 screens of information that have to be addressed to setup QuickBooks. To add insult to injury, the process is called "Easysteps".

taxonomies and hierarchical file structures - and meaning

2007-07-19T11:04:00.000-07:00

Howard Reingold on David Weinberger's book, Everything is Miscellaneous:

It’s not just a new story and a big picture, it’s a new picture and a big story. I think he’s right that most knowledge has been structured and so many institutions has been arranged according to taxonomies and hierarchical file structures simply because we have been arranging knowledge for thousands of years, but we only got search engines recently. Search engines are not just search engines in Weinberger’s new picture, and tagging is not just tagging.

From Weinberger's book:

That humans play a role in categorizing the world is not news. There is a difference now, though. For the first time, we have an infrastructure that allows us to hop over and around established categorizations with ease. We can make connections and relationships at a pace never before imagined. We are doing so together. We are doing so in public. Every hyperlink and every playlist enriches our shared miscellany, creating potential connections that we can’t often anticipate. Each connection tell us something about the connected things, about the person who made the connection, about the culture in which a person could make such a connection, about the sorts of people who find that connection worth noticing. This is how meaning grows. Whether we’re doing it on purpose or simply by leaving tracks behind us, the public construction of meaning is the most important project of the next hundred years.

Wow. Control of information creates "meaning".

Nobody loves control more than the accountants do. From QuickBooks to Great Plains (what is Microsoft calling it this week?) to PeopleSoft, the accountants rule with an iron hand.

Although business software is a great deal more than accounting, accounting remains at the core center of the design. Everything bows down to the chart of accounts. It is a perfect example of "taxonomies and hierarchical file structures".

When I talk to QuickBooks users, one of the most common praises they have is for the main menu. It's a graphic diagram of modules telling the user what must be done and in what order. This is a structured "you must do" list.

If you don't do what you're supposed to do, and do it in the right order, there'll be hell to pay.

These controls assure that the accountant's rules will be followed.

But in the real world, successful small businesses break the rules. To be successful, they have to break the rules. They don't have time to be accountants. So, they eventually learn which pieces of QB are necessary, and which aren't. They abandon whole systems.

And, ultimately, the taxes get done - usually derived from income and expenses on a monthly basis from the checkbook. I'm not sure, but I doubt QB can create this simple report easily - even though 90% or more of their clients do their taxes this way.

So, what we have is a sham.

We have software designed by accountants in accord with priestly 18th Century rules. And everyone is cheating. The accountants too.

---

Reingold and Weinberger are talking about the decline of hierarchy. The information age is resculpting our world much in the same way the printing press ended the iron-fisted control of the Holy Roman Church.

All of our institutions - Finance, Government, Education, Commerce - are increasingly irrelevant (they have less and less "meaning") Tomorrow's world will be unrecognizable compared to today's.

The authoritarian model we see repeated thoughout our culture is fundamentally incompatible with the free flow of information. With information in the hands of users rather than overlords, so is "meaning".

QuickBooks, Great Plains and PeopleSoft are business softwares written by accountants for accountants. Or, more abstractly speaking, software written to protect and enforce the authoritarian paradigm.

With Geebis, we are abandoning this dying model in favor of user freedom. Geebis is search, data, and simple tools to manipulate the data. The user is free to do what they want to do. The user creates their own "meaning".

The past shapes the future

2007-07-18T11:43:00.000-07:00

Here is a fantastic lecture given by Van Jacobson at Google TechTalks. Van Jacobson explains how telephony defined networking as we know it today.

It's 80 minutes long, but well worth the time.

Technology has changed dramatically, and now the structures we have created in the past are no longer helpful, but rather a barrier toward moving forward.

ABSTRACT Today's research community congratulates itself for the success of the internet and passionately argues whether circuits or datagrams are the One True Way. Meanwhile the list of unsolved problems grows.

Security, mobility, ubiquitous computing, wireless, autonomous sensors, content distribution, digital divide, third world infrastructure, etc., are all poorly served by what's available from either the research community or the marketplace. I'll use various strained analogies and contrived examples to argue that network research is moribund because the only thing it knows how to do is fill in the details of a conversation between two applications. Today as in the 60s problems go unsolved due to our tunnel vision and not because of their intrinsic difficulty. And now, like then, simply changing our point of view may make many hard things easy.

I am reminded of a discussion I had with a friend over lunch about the engineering of cell phone communication between the receiver and the tower. Most people envision a line of signal between their phone, and the tower. But, this is false. The tower creates a mist, and all data is everywhere in the mist. Your cell phone hears your call because it has the ability to identify the data in the mist which is yours.

---

I wonder how these ideas might be applicable to software design.

Jacobson talks about the failure of telephone to telephone communication. You don't really want to ring a phone on the other side of the continent. What you really want to do is talk to someone. You don't really care where they are. Just let me talk to them.

So, isn't this the same as forcing someone to go to a hierarchical structure, and navigate to a module where the task they want to be performed can be facilitated. If you want to create a new customer, you must go to the customer module.

All the user wants to do is create a new customer.

So, can we create a system that will strip out the unnecessary "controls" that get in the way of allowing users the freedom to do what they want to do?

Our original concepts for Geebis were radical in that we recognized the importance of search as a (perhaps "the") central element in new friendly design.

All the content in the world is pretty useless if you can't find it.

Now, we are moving further away from traditional thought as we consider the elimination or minimization of module structures. Let the user say what he wants to do (search), give him relevant feedback (search results), and let him do directly what he wants to do.

No need for a structured new customer tab, with fixed functions.

So, the user types "new cust" or some variation into the search box. Up comes the search results. They click on make new customer, and voila, they are at a screen to make new customers.

I'm a bit nervous about entirely abandoning hierarchy structure. I'm still thinking of an iGoogle kind of home page where users can define searches for things or places in buttons. Thus, a user could create and maintain a hierarchy to their own liking.

---

Interfaces That Feel Good

2007-04-12T22:18:00.000-07:00

There's an interesting piece on Daring Fireball about interfaces that feel good. It is relivant to Geebis Books because these are the types of guidelines we are already following.

Basically what John Gruber concludes is that an interface's annoyingness is not necessarily measured in keystrokes.

The primary focus of Geebis is to make finding your objects easy. To do that, we're working on a searching interface that is similar to gmail's. We've created a parser with JavaCC that reads complex search strings and gives you what you would expect like:

name:"John Smith" company:"Linux Group of Rochester" -label:deadbeat

If you executed this in the customer module, it would give you a list of all customers whose name is "John Smith" who work for "Linux Group of Rochester" and who are not labeled "deadbeat". This will provide advanced users the ability to quickly find their data.

This example is fairly verbose, but we plan on offering aliases for the field names that we provide, like:

n:"john smith" c:"linux group of rochester" -l:deadbeat

and since this query is probably overly specific, you could probably find what you're looking for with:

n:john c:linux -l:deadbeat

And of course, you don't have to specify a field name for a criteria, you could simply search for:

john linux -deadbeat

This is nothing new in the realm of search engines, but outside of that domain it is rare.

The exact grammars haven't been determined yet, but we plan on providing lots cool shortcuts to users.

New Web Site & Content

2007-04-12T20:55:00.000-07:00

We've had a new website up for a while now, but there was no content on it. Now there are links that point to various pages containing information about Geebis Books.

Check out the new page: http://www.geebis.org. There are screenshots and you can follow the blog from the front page.

GWT & db4o

2007-04-12T18:14:00.000-07:00

Recent work on Geebis has focused on re-evaluating some of our technology choices. Wicket has undergone some changes, abandoning 2.0 (the version we are targeting) and focusing on updating the stable branch (1.2) to incorporate the features of 2.0 in 1.3. The changes to our project are fairly minor, but Wicket has a number of issues dealing with Ajax and Javascript keeping the backend in sync with the client. It is just plain hard to do some of the user interface tricks we want to do in Geebis. This is where Google Web Toolkit comes in. http://code.google.com/webtoolkit/ GWT is an open source Java Toolkit that compiles directly into Javascript and runs on Apache without Tomcat. GWT will allow us to do all the cool things we want to on the client side without having to worry about syncing with the server. It is open source and runs on Linux, Windows, and Mac OS X.

The other major technological change is db40. Check it out at http://www.db4o.com/. db40 is an object database, which means that it requires you to perform none of the extra steps that come with using a relational database, just store the objects exactly as they are! Hibernate has too many dependencies for a small project like ours. Using an object database allows us to get rid of the ORM layer and with it a whole swath of dependencies and annotations. The code is simpler and easier to read.

LinuxGroup

2007-03-08T15:46:00.000-08:00

Work on Geebis has been proceding at a slow pace lately because we have been focusing on LinuxGroup of Rochester, a new venture which hopes to provide IT support, web design, and data services for Rochester and Monroe County.

http://www.linuxgroupofrochester.com/

After several months of work we are very proud and are finally ready to unveil the new site. Rest assured that our commitment to Geebis is just as strong as ever. We are committed to providing small business accounting software and are excited to continue developing innovative software features. LinuxGroup will help us to extend our network of clients and help to broaden awareness of our software design expertise. Besides, it will be fun.

Screenshots

2007-01-09T14:09:00.000-08:00

These mockups of screens reflect the new color scheme:

A Look at Some of the Competition

2006-12-11T09:14:00.000-08:00

Here are some of the competition that is out there for small business financial software:

Microsoft Small Business Financials:
http://www.microsoft.com/businesssolutions/.../default.mspx

Sage BusinessVision:
http://www.sagebusinessvision.com/products/bv32/index.html

Netledger NetSuite:
http://www.netsuite.com/portal/home.shtml

You get one point if you can figure out the price of the product, two points if you can get a demo without filling out a questionnaire or talking to a representative and then waiting for 2-3 weeks, and another point for each screen shot of the product you can find. My guess is you won't get a lot of points.

Microsoft seems to be the best out of the three listed above; at least they let you see grainy low-quality videos of their product and you can find the price if you dig deep enough. However, in the days of downloadable demos and buying software right off the Internet, there is just no excuse for the poor presentation these companies give. It is impossible to figure out if their software will fit your needs just by looking at the website and that is not acceptable. And these are three of Intuit's biggest competitors, not just some random picks off the Internet. This market is desperate for an easy to use, easy to buy financial software.

Open source small business financial software is even worse. Much of it requires you to setup PostgreSQL or Oracle on a Linux server just to use it. That is just conceptually out of reach to most people.

It is one of Geebis's goals to be easy to install and presented clearly. The only external requirement Geebis has right now is a JVM and we are working on automating that step as well.
The website isn't much right now, but once we have something more to show we will present the software's capabilities clearly. We intend to provide free downloads and perhaps an online demo. We understand that screen shots are necessary to show off the software. We will never require you to fill out a questionnaire and wait for a CD in the mail or make you talk to a representative. Basically we want Geebis to be customer friendly, forget all the secrecy and smoke and mirrors. I think that would be a welcome change.

Small to Medium Businesses

2006-12-03T07:25:00.000-08:00

You hear the phrase "Small to Medium Businesses" used a lot when people are talking about software and services in this field. It is used to describe businesses that do not fall into the category of "large businesses", businesses that have there own IT departments and budgets and all the bureaucracy that goes with it. However, the phrase "small to medium businesses" really downplays the great variety of businesses that are under the umbrella that moniker covers. The gamut runs from single man shops to multi-million dollar companies with hundreds of employees.

In the financial management software world anything above personal finance software fits into the category of small to medium business software. The reining king in this space is Quickbooks. On their website they proclaim themselves to be the #1 Small Business Financial Software and they really are. You see Quickbooks everywhere. But at a certain point Quickbooks falls down. I think the point where Quickbooks really doesn't work anymore is when you start needing to access your financial software from multiple computers across the network by multiple individuals. Quickbooks really only works when there is one primary person running all of the finances in a company.

When you get to the level of multiuser, multi-computer financial management software you start to see some truly awful software packages. Text-based and menu-based software running on Novell or Linux is very common in this arena. And not only is the interface horrible, it often requires the user to jump through hoops to accomplish what should be a simple task. For some reason software in this realm is allowed to remain in the dark ages as far as advancements in computer science go. Not only that, the price point jumps dramatically from say $3,000 to upwards of $50,000.

A lot of that is driven by specialized needs. People put up with the crappiness because they need certain features that just aren't widely available. Also network software is hard, it requires integrating a lot of different pieces of software and hardware together. Regardless, this is the void that Geebis hopes to fill. One of the biggest strengths of Geebis is that it can easily be extended over the network and be used multiple people simultaneously. At the same time it can be used by a single person easily. The decision to make Geebis web-based was so critical in reaching this goal. No special client software is needed other than a web browser and that makes all the difference.

The Importance of Searching

2006-11-16T03:53:00.000-08:00

When someone does a task that takes fourteen steps and you find a way to do the same task in one step that is an exciting feature. That is the kind of feature that differentiates one product from all the rest. In Geebis we have a lot of great feature ideas but the breakout feature is searching.

The searching capabilities in Geebis are the difference between people using our software and people not using our software. A good search tool is like Rumpelstiltskin, it takes in straw and returns gold. The search capabilities have to be good, and they have to be forgiving. Geebis needs to have an integrated spell checker and grammar checker. It has to search on every non-id field in the database. The search should look for key words and sort the results accordingly. It should be fast, it should be indexed. Searching should be everywhere, from customers to invoices to terms. If searching is pervasive people will rely on it, and if we can get people to rely on the searching than they won't lose their stuff. How common is it to have the same customer in your database three times, or have the same product listed twice? If the searching is really good people will be able to find what they are looking for, even if they only know vaguely who or what it is. And not only does that mean they can get their work done, it means they aren't frustrated with the computer.

The live as you type searching (like in iTunes and Spotlight) is really great, you don't have to push enter or click search or anything, just type in your criteria and the results automatically fill in. It is very fast too. I certainly have not seen any other software in the "three letter acronym" (ERP, CRM, B2B, etc) market come anywhere close to this kind of polish. And that is what is going to make Geebis better than those other guys. We still have a lot of work to do, but I think that we are on the right track.

New Post Soon

2006-11-16T03:16:00.000-08:00

A new post coming soon about why searching is so important.

You can't trust the client

2006-11-16T02:11:00.000-08:00

I recently read an article entitled "Linux Users Banned From World of Warcraft?"
on Slashdot.org.

http://linux.slashdot.org/linux/06/11/15/1652222.shtml

I also read the resulting discussion which went into more detail about exactly what challenges Blizzard employees faced while developing World of Warcraft.

Blizzard engineers learned from MMORPGs past and Battlenet that you cannot trust anything the client says or does. You cannot assume anything about the hardware, the operating system, the user, or anything going on outside of your servers. Despite all of this you have to listen to your clients because if you don't they are going to stop paying you. You have to listen to potential customers even though they are not paying you.

Balancing this paradox is the challenge that Blizzard faces. Sensationalist articles like the one mentioned above only serve to misguide the public about the true difficulty of social software. However, the discussion that resulted really showed how wonderful the level of discussion is on Slashdot. People mock the site but articles like this show how unique a discussion Slashdot engenders.

This is one of the challenges that Geebis Faces. How do we balance the fact that we cannot control the clients? The way Blizzard regulates cheaters is to make everything server side. This brings up questions as to how reasonable it is to ask people to run server side accounting software. After all, accounting software is even more susceptible to cheating than a game is. If you cheat in a game you can get banned, if you cheat in your accounting software you can go to jail. The stakes are much higher.

Removing trailing whitespace in Eclipse

2006-10-24T23:01:00.000-07:00

I was running Geebis Books through checkstyle, and I noticed that I had a bunch of errors saying that there was trailing spaces in the code. Since I didn't want to do a full Format with Eclipse, I decided to do it the old fashioned way.

Now, there might be a better method (i.e. a built in function) to do this, but when you have a bulk text manipulation every tool looks like a regular expression.

You might be tempted to do a find and replace with this regex:
find: [ \t]+$
replace with: \n

Well, because of an eclipse bug, this isn't possible. It just inserts 'n' instead of a newline.

So then you might, like I did, try to match the newline with a positive lookahead like this:

find: [ \t]+(?=\n)
replace with:
(that's replace with nothing)

Well, that doesn't work because of another eclipse bug that prevents performing a replace on a find that has a lookahead.

Well, here's how you actually get it done:
find: [\t ]+(?:(\n)|$)
replace with: $1

this will match and capture the newline (if there is one) and replace with the result of the first capture (the $1). The expression got a little more complicated to handle the last line of the file. The last line doesn't have a newline at the end, hence we had to match either a newline OR match the end-of-line ($). If the capture group is not entered because a newline isn't found, but the end-of-line is found, then the capture group is a blank string so when we replace there's no harm done.

Geebis Searching Screencast

2006-10-18T13:04:00.000-07:00

Click here to see what I'm working on for searching in Geebis Books.

The customer database being searched in this example has 45,000 customers in it. There isn't any audio, but it's fairly straightforward. It demonstrates searching by just typing in a customer's name, and by specifying the field you want to match on (like name:).

Wicket 2.0 & Google Code

2006-10-15T09:03:00.000-07:00

I've recently moved the Geebis Books project to Google Code for SVN and bug tracking. The Google Code page can be found here. I did this because Google code is a lot cleaner than sourceforge, and while it doesn't have all the features SF has, they're either in development, or really not important for most projects. The links should be updated accordingly on the SF svn page and on the Geebis webpage.

I've also converted the Geebis Books code base to Wicket 2.0 since that is the future of wicket. Most new development will happen in the 2.0 branch and there aren't any huge outstanding bugs to stop us from using it now.

Disk Inventory X

2006-09-30T05:31:00.000-07:00

Yesterday I stumbled on a piece of software called Disk Inventory X for Mac OS X that is pretty cool. It shows you graphically, with colored blocks, the relative size of files on your hard disk. It's unrelated to Geebis, but is a useful piece of software for finding those old Ubuntu ISOs that you've been saving up that should be deleted.

For Windows users there is a similar program called WinDirStat.

Embedded Jetty

2006-09-27T14:56:00.000-07:00

One of the goals of Geebis Books is to make a web application that is easy to install. Because we're using Java that means Servlets. To accomplish this, we decided to embed Jetty 6.0.1 into our application.

We modeled our embedded Jetty after the OneServletContext class (found in the jetty-6.0.1/examples/embedded example collection). Unforutnately this example doesn't allow the correct use of servlet context listeners because the Servlet's init() method is called before the listener's contextInitialized() method. This is not correct according to the servlet specification (2.3 and up).

The reason for this is that we're using the Context class not the WebAppContext class. The WebAppContext does all the work of tying the peices together like filters, mappings, and listeners. Using WebAppContext is a bit more complicated since wants you to have a Java web application directory structure (myapp/WEB-INF). If you want the simplicity of Context, but still want to use listeners, here's what you have to do:



package org.geebis.books;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.mortbay.jetty.Server;
import org.mortbay.jetty.servlet.Context;
import org.mortbay.jetty.servlet.ServletHolder;
import org.springframework.web.context.ContextLoaderListener;

import wicket.protocol.http.WicketServlet;

/**
 * The <code>Launcher</code> class launches
 * and configures Jetty to run geebis books
 */
public class Launcher {
  public static void main(String[] args) throws Exception {
      System.setProperty("DEBUG", "true");
      Server server = new Server(8080);
      Context context = new Context(server, "/", Context.SESSIONS);

        // Add the wicket servlet
        ServletHolder servletHolder = new ServletHolder(new WicketServlet());
        servletHolder.setInitParameter("applicationFactoryClassName",
          "wicket.spring.SpringWebApplicationFactory");
        servletHolder.setInitOrder(1);
        context.addServlet(servletHolder, "/app/*");

        // Add the Spring context listener
        context.getInitParams().put("contextConfigLocation",
          "classpath:applicationContext.xml, classpath:dataBeans.xml");
        ContextLoaderListener listener = new ContextLoaderListener();
        context.addEventListener(listener);

        // We set InitializeAtStart to false, start the server
        // and then initialize the servlet handler in order to
        // make the servlet listener (above) receive a
        // contextInitialized() event before the servlet itself
        // is init()
        context.getServletHandler().setInitializeAtStart(false);
        server.start();
        context.getServletHandler().initialize();
        server.join();
    }
}

The last four lines of the main method are the key. The idea to do this came from investigating what WebAppContext did differently, and learning a little of how Jetty is structured internally.

That's it. You may find that it is easier to use WebAppContext in the future but if all you need is something as simple as the above, it will work fine.

Wicket

2006-09-13T01:53:00.000-07:00

I've been thinking about Geebis Books and the philosophies that we have and I've decided to reevaluate our choice of web frameworks. We chose Seam because it looked like it was a decent framework that was built on mature technologies. After spending time with the framework we learned that our initial thoughts on Seam were true. It's built on a pile of Sun standards. Sun standards aren't all bad. Wicket for example uses a servlet to do it's work, but using a bunch of standards based products does have some downfalls. It can be slower to react to new technologies and often has other issues like being burried in a sea of xml config files.

And that's why I've decided to look at the Wicket web framework instead. While Seam has a lot of features, and I won't have too hard a time finding a job related to Seam/JSF, it just doesn't seem like it fits with the Geebis culture. The biggest reason is that creating custom components in JSF can be difficult, especially if you want your components to have lots of javascript/css that it contributes to the page. JSF requires that you use a writer to send your component's HTML to the browser. With this system you end up with spaghetti code that's hard to debug, and hard to test. Add ajax functionality to the mix and you have a featureset that JSF just can't handle in the current version.

I know about Facelets, and I know about all the Ajax frameworks out there for JSF, but those things do not reduce the complexity to the point where I would feel comfortable pumping out thirty controls.

I've read more than a few flamewars on Javalobby about JSF vs Wicket vs <insert framework here>. The JSF supporters have a good defense for a lot of the attacks, but when someone comments on how difficult it is to create custom controls in JSF, they say that you shouldn't be creating too many controls if you use the framework correctly. Creating custom controls in a component web framework id definitely what you do. That's why we use these things and not Struts. Plus, if it weren't something you should be doing, then why does Oracle and so many other vendors have large collections of components that you can buy or download?

That's the JSF part of Seam. The Seam part of Seam is actually pretty cool, and I wish I could use those parts, but I don't think they're shiny enough to put up with JSF. Dependency injection, outjection, conversations and workspaces are all very cool. I didn't get too far into using those features, but they looked very much of the now.

Aside from Seam, I've also decided to look at using an embedded Jetty webserver instead of JBoss. Because GB is meant to run on an internal network with a small number of clients connecting to it we can't justify the download size, complexity, or memory consumption of JBoss for Geebis Books. This decision means that we have to sacrifice some enterprisey features, but I think in the end it's the right thing.

On to the Wicket parts of the post.

I chose to look at Wicket as the replacement web framework because I had seen it in the past and liked what I saw. Wicket is a framework that includes everything you need to develop modern web applications:

A templating system for creating consistent a consistent look and feel for your application

An ajax system for making your application repsonsive

Localization for those pesky strings

A security framework that is customizable

Those are all features that you would expect to find in a modern web development framework, but what's interesting about Wicket is how it does those things. A quick way to describe Wicket would be to say that it is Swing for the web. Everything is done with events and callbacks. When you add a link to a page if you want to do processing when that link is clicked you implement the link's onClick() callback with the functionality that you want. Want to create a new page? Create a class for that page and extend the Wicket Page class.

They way you associate HTML with a Page class also pretty cool. In the rails-esque way of defying configuration you simply create an HTML file with the same name, but a .html extension right alongside your class file in your package tree.

And of course the whole reason for looking elsewhere, creating components, is do-able in Wicket. Just create a subclass of the Panel class and put the control's html in a file with the same name as the java file. If the control needs css or javascript you can easily tell Wicket where the .css or .js files are <link>s to them will be rendered in the resulting page's <head>. If you use the same control more than once on a page, those resources will only be included once.

For more information about wicket visit the homepage or view some of the tutorial articles on javalobby.

Geebis Books Security

2006-09-07T00:27:00.000-07:00

We've been over ideas for security in Geebis Books, and I've come up with a system that is both easy to use and easy to expand. There is a point at which it will break and actually get in the way, but for the foreseeable future it will hold up.

Permissions are represented by a Java enum called Permission:

public enum Permission {
    // Customers
    READ_CUSTOMERS,
    WRITE_CUSTOMERS,

    // Vendors
    READ_VENDORS,
    WRITE_VENDORS,

    // Products
    READ_PRODUCTS,
    WRITE_PRODUCTS,

    <more permissions...>

    // An employee requires this permission
    //to log into the system
    LOGIN
}

An employee in the system has a Set of these permissions which the user (programmer) can query and manipulate like this:

// adds the LOGIN permission to employee
employee.addPermission(Permission.LOGIN);

// removes the LOGIN permission from the employee
employee.removePermission(Permission.LOGIN);

// returns true if employee has the LOGIN permission
employee.can(Permission.LOGIN);

// returns true if employee has the LOGIN
// and the READ_CUSTOMERS permissions
employee.can(Permission.LOGIN, Permission.READ_CUSTOMERS);

// returns true if employee has either the LOGIN
// or the READ_CUSTOMERS permissions
employee.canAny(Permission.LOGIN, Permission.READ_CUSTOMERS);

If an employee is marked as being an administrator, then he automatically has all permissions. There must be at least one administrator in the system.

With 15 modules in Geebis Books, there will probably be 30 permissions related to those modules (READ_ and WRITE_ permissions for each module). There may be other permissions that aren't module related, like the LOGIN permission, but there shouldn't be many. With this in mind the above system should work fairly well. I believe that initially the permission interface will be implemented with a checkbox for each module which when checked on grants the READ_ and WRITE_ permissions for that module. This should make it easier for the end user.

Can I?

2006-09-01T14:51:00.000-07:00

Have you ever asked for permission to do something and the other person grants that permission, but has their own stipulations? Wouldn't it just be easier if that didn't happen?

I've spent some time thinking about security in Geebis Books. The direction we're going is toward a simple, UNIX-like security model. The user loads up an employee, and simply selects which modules that employee may access. By making the security system do-able we let the end user actually use it. But the underlying system should allow us to expand the system in the future by adding more fine-grained control over permissions.

Initially we talked about including a more fine-grained system in Geebis Books, but the thing that kept coming back to me was the complex security systems that I've used in the past like SELinux/ACLs and Windows XP. These frameworks do give the user complete control over the security in their operating systems, but they are very complicated and a person who has 5 computers to network is not going to need the advanced features. When the user doesn't need those features, he won't learn them, and if he doesn't understand his security system it will just end up getting in his way. SELinux is particularly bad because it's caused problems that have taken me an hour to find the cause and fix. The fix is to disable SELinux.

I'm not suggesting that SELinux or the Windows permission model are too complicated, but that if I just want to run a database server or share a folder with another user on the system, I would want something easier. Now, if I were running shell.sourceforge.net I would probably want those more advanced features.

On the other hand, the UNIX system has on occasion frustrated me for doing even simple tasks. Keeping a directory and all the files created in it owned by a particular group and forcing the group write permission on all subfolders and files (even newly created ones) can be annoying. The solution to these kinds of problems in UNIX are not always easy. This will probably be a problem in Geebis Books too. If the user wants to allow employees to read some customer information but not other information, they will be out of luck. This is a problem, but one that is not worth alienating 95% of our target audience for.

I thought about how to solve this problem. The answer to the granularity problem is to have an Advanced permission system that gives fine grained control.... oh wait, that's not the answer. Well, not necessarily. The path of "add an advanced tab" is a dangerous one, filled with snakes and stuff. Before taking it, a lot of thought has to be had on whether it will be used, or if it will make the system more complicated. There's no easy answer but a lot of designers would answer with "add an advanced tab".

As far as how to implement all this in Geebis Books, I've looked at what's out there for Java in the realm of security. What I've turned up is all fairly powerful (like JAAS, and ACEGI), and more research will be needed before deciding whether to use a 3rd party framework, or to write my own.

Early Screen Designs

2006-08-25T14:32:00.001-07:00

These are very early renditions of what the initial Customer spline and drilldown to a customer instance might look like in Geebis.

As you can see, the design and features are heavily influenced by Google, Deli.cio.us, and perhaps iTunes and Digg.

Business tools tend to be written by accountants - for accountants. I see Geebis as a product written for users. We will push the seventeenth century rules of business process and bookkeeping into the attic and lock door! Yes, we will still meet accounting requirements - but our focus is on removing the current pain users have from ERP.

It is quite a challenge and I feel it's a privilege to participate in this project.

There are currently two main principles we are applying so as to remove the pain users currently experience:

1) Search - We are incorporating simplistic search everywhere throughout our screens. Simply ask for what you want, and then go there.

2) Up-Front customizability - This takes two forms at the moment. A) Customer defined labels on every type of object B) Simple and easy screen configuration only a few click and drags away.

Customer Spline:

Customer Instance:

Comments are welcome and encouraged.

Scott

More == Less and Less == More

2006-08-20T17:37:00.000-07:00

I got a document in my mailbox today that I think is interesting and applies to Geebis. It's called the Simplicity Cycle

It describes a characteristic of design that I always felt in my gut was correct, but have never expressed as eloquently as in the paper. In a nutshell what it says is that a truly effective design requires itself to be less complicated than a bad one. This lesson is difficult to apply because of our tendency to believe that something that is complicated is worth more. After all, it's often true when comparing things. A graphing calculator is worth more than a four function calculator. Unfortunately we subconsciously carry this thinking to our designs.

While reading the Simplicity Cycle I found myself thinking about what it said from two directions. The first is from the perspective of a computer programmer, and someone who has to design a system that is fairly extensible, but is also reasonable to work with. This is an even bigger problem for framework designers since lots of other people have to interract with your code, but who knows, maybe Geebis someday will become a framework that other developers write plug-ins for. If this is the case then it will be important for the internals of Geebis to be clean yet powerful.

The second was as an interface designer. While I'm not the primary interface designer for Geebis, I do appreciate good interface design, and I like to talk at lengths on the subject. The Simplicity Cycle makes just as much sense from the point of view of the interface designer as it does from that of the programmer. We've all used programs that have a lot of features, but the interface makes them painful to use. But making more simple interfaces shouldn't just be a focus of complex features, but also simple ones, you know, those features that you use everyday. Using a better interface to do the same tasks that you do all the time can reveal pain that you didn't know was there.

As a comparison I looked at searching for a file in Mac OS X, Windows XP, and Ubuntu 6.06 with GNOME. Searching for a file that's in a particular folder hierarchy is a fairly common task that can be made annoying by a bad interface.

Windows XP

When you want to search for a file in Windows XP you can open the folder that you want to search in, and click the Search button in the toolbar or hit Control+F. Your side panel is replaced by a panel with an animated dog that asks you what kinds of documents you want to search for, and then allows you to type what you want to search for. MS loves their wizards, and this is just a mini-wizard for a task that doesn't require a wizard. To exit the search you just press the back button.

Ubuntu 6.06 with GNOME

Searching for a file in GNOME is easier. Open up the folder that you want to look in, and either click the search button, or hit Control+F and the breadcrumb part of the toolbar is replaced by a text field where you enter your search criteria. Hit enter and you're off. It shows you the results, and allows you to refine your search by adding criteria. To return to the non-search mode you press the back button. The fact that GNOME is more simple and powerful than the windows search is interesting given that Linux/UNIX isn't exactly known for it's clean interface design.

Mac OS X

The easiest of the three operating systems to search in is Mac OS X. Open the folder that you want search in, and simply type into the box in the upper right hand corner with the spyglass (a universal icon in OS X for a text box that is a search box). The system starts searching as soon as you start typing so you don't even have to press enter. OS X doesn't allow you to add criteria when you use this method of searching, which makes this mode more simple, but also more powerful since you have access to the functionality that you use the most very quickly. To add criteria you must press Command+F in a folder window.

These are the issues that we are thinking about when designing Geebis. Searching in Geebis might well end up a find-as-you-type solution like it is in OS X. If it's reasonable and it works well, that is the path we will take. At the very least, the search box will be omni-present on all of our screens, so searching is just a click away.

Geebis will not try to be overly friendly like is popular in Windows because we believe that adding unnecessary blocks and even snippets of text can actually hurt more than help the user. Like in the third screenshot of the Windows XP example, we wouldn't have written "There was one file found. Is it what you wanted?" and "No, refine this search and...". Those are unnecessary bits of text that clutter the screen and make the software less usable.

The purpose of this post is not to bash Windows XP, but to try to learn from the mistakes of successes of others to make a pleasurable user experience in Geebis.

Myfaces / JSF RI save & restore state problems

2006-08-15T14:35:00.000-07:00

A free for all technology has little chance of multiple implementations living side by side, but even with standards there can be incompatibilities. This didn't surprise me, and it shouldn't surprise anybody else, but it can cause a lot of hours spent debugging especially if one is new to the framework.

I've been playing with JSF recently, trying to create my own toolbar control. As a reference I was using the Navigator control from JSF in Action since it looked similar to what I wanted to do. Unfortunately the JSF in Action book was written to JSF RI, and I'm using Myfaces. This caused a lot of problems with what should have been a simple control.

The Navigator example from the book fires an ActionEvent when the user clicks a button in the toolbar. The control itself wants to know when the user clicks a button, so the author added an ActionListener in the constructor of the control. The problem is that he removes this listener in the UIComponentBase#saveState() method because he wants to save memory/bandwidth by not serializing the listener. This works in theory because a new listener will be created and added when the control is constructed again. Then the rest of the properties will be filled out when UIComponentBase#restoreState() is called.

To understand the problem, a little background into the implementation of UIComponentBase is required. Both implementations save and restore your listeners for you. The problem in the MyFaces implementation (1.1.1 as included with Jboss 4.0.4.GA) is that is just blows your existing listeners away and restores those that were serialized in UIComponentBase#saveState(). In the RI, UIComponentBase#restoreState() merges the serialized listeners with those that already existed when the method was called.

To me it seems like the MyFaces implementation is more correct since the purpose of UIComponentBase#restoreState() is to set up the exact control that was serialized, and any values in the control before UIComponentBase#restoreState() is called are erased and overridden with those from the serialized one.

When you're a newbie at a framework like JSF this can be incredibly frustrating when you're just trying to get out the door with an example. Of course, if you're seasoned I'm sure there are many more discrepancies that are even more annoying.

I'm now working full time on Geebis

2006-08-10T20:14:00.000-07:00

One of the reasons why I haven't updated the blog recently is because I'm in the process of transitioning to working on Geebis full-time, so this blog will be updated more frequently. I'm doing this because I feel a great amount of excitement over the Geebis project, and I've learned that this is the project I want to work on the most.

As far as development of Geebis goes, there was a dry period during this changeover, but I did get some development done, mostly in the area of Labels.

Labels in Geebis are similar to labels in gmail or in del.icio.us, but a bit more specialized. Labels can be attached to almost any business object in the system, and some labels imbue objects with magic properties elsewhere in the system (I will post more on this later). Labels come in many flavors and colors, and generally can only be applied to specific kinds of objects. For example: AccountLabels can only be applied to accounts, CustomerLabels to Customers, and so on. Other labels, like JobLabels can be applied to Customers, PurchaseOrders, Invoices, etc so that the user can look up all objects related to a job.

The label system currently uses an EJB3 @Entity bean called Label as the root class of all labels. The Label class is abstract, and there is a subclass for each type of label (CustomerLabel, JobLabel...). The Label class has some static utility methods that deals with removing, adding, and other label tasks. Classes in the Geebis system can be annotated to restrict the kinds of labels that can be applied to them. Here is the definition of the Account class that demonstrates how to do this:


@Labels(labelClasses = {GenericLabel.class,
                        AccountLabel.class,
                        AccountUsageLabel.class})
public abstract class Account<T extends Account>
implements Labelable, Serializable {
...
}

As you can see, the account class implements the Labelable interface. All classes that want to have labels must implement Labelable. The Labelable interface has one method:

public Set<Label> getLabels();

Once a class is set up with the @Labels annotation (this isn't strictly required, since any Labelable class that doesn't have a @Labels annotation will allow GenericLabels to be applied to it) and the getLabels() method is implemented, you're ready to add and remove labels from objects of that type.

To do this we use the static methods on the Labels class:

public static void addLabel(Labelable labelable, Label label)
throws IncompatibleLabelException

public static void removeLabel(Labelable labelable, Label label)

public static boolean isLabelCompatible(Labelable labelable,
                                        Label label)

These methods allow you to add labels, remove labels, and test the label compatibility of a Label with a Labelable object. the addLabel(Labelable, Label) method throws an IncompatibleLabelException if the Labelable object doesn't list the Label's class in its @Labels annotation (or the Labelable doesn't have a @Labels annotation and the label is not a GenericLabel).

These APIs will most likely change in the future, and most features will be added for dealing with labels.

The next job to work on is to create a data access layer so that our beans can query the database for these objects. One approach I was thinking about going with was the command pattern. I've written a few data access layers, but I would like to think more about Geebis's DA system because finding objects easily is a priority and I'm not sure the DAO blueprint is the best way to go. I'll have to put some thought into this subject.

Design through removing an element that seems important

2006-08-01T17:55:00.000-07:00

In designing the object model for Geebis, I ran into a bit of a snag that took quite a bit of thinking to get out of. The biggest reason for thsi problem is that I've never done a design from an object perspective. All of my previous work has been in Visual FoxPro which doesn't lend itself to OOP very well. I know there are those who would claim otherwise, and I myself use a lot of OOP in VFP, but things just aren't that easy when compared to a language that has had OOP since the beginning.

The technique that I used to get out of this design rut was to remove the functionality that was the core of the problem. In this case, it was how to structure the class hierarchy to fit an item type called a Kit. Basically a kit is a group of products that you sell for a price that may be different than the sum of the retails of the parts.

The problem came from the fact that while a Kit is really a non-retail item in that it doesn't have a cost associated with it (when a kit is sold, the cost is the sum of the cost of the parts), it does in fact have a retail. Well, the current design of this hierarchy is this (I'm not a UML wizard...):Unfortunately, while a Kit has a retail price it does not have a cost. I struggled with this problem until I applied this method to overcome mental roadblocks. I removed the part of the design that was giving me the most trouble and looked at it again. The first thing I realized was that Geebis didn't need that feature, and that removing it would be the most logical thing to do (since Geebis already has what are called Bundles which are groups of items that have a retail price equal to the retail prices of their parts). But if Geebis did need this feature I also came up with several ways to integrate Kits into the design. If we:

made Kit a child of RetailItem,
made the cost property an abstract getter method, and
pushed the cost member variable down to the children

then putting Kits under RetailItem made a lot of sense. Now the definition of a RetailItem is an Item that has a retail price, and that you may ask it what its cost is. The cost of a kit is the sum of the cost of the parts.

The point is that by looking at what was going on without the problematic piece in the way, I was able to more clearly understand how these classes fit together.

About GeebisBooks

2006-07-21T01:42:00.000-07:00

A little information about GeebisBooks.

GeebisBooks is an accounting/CRM/ERP type software aimed at small businesses (1 to 40 employees). One of the principles that is driving development of GB is that users who run small businesses are not accountants or bookkeepers.

Through past experience we (the GeebisBooks team) know how painful it can be to support software that has an accounting element when most users don't understand a T chart. To make the everyone's life better in the future we're developing GB with this in mind.

Here are a couple of examples of how we can lower the bar for small business owners:

When a user creates a new product, he should not have to specify an sales account or an inventory account. These backroom details should have sane defaults, and should not even be presented to the user unless they opt in.

In order to enter a credit memor from a vendor, the user should also not have to enter a list of accounts (identified by a code "101000-1000" of course) with a debit or credit value. The problem is that the user doesn't know what a debit is, nor what chart of accounts is for, so presenting them with their complete COA and then asking them to select the correct accounts from the list to correctly represent the credit memo is asking for support problems. One solution for this problem is to ask them a series of questions about the credit memo and then filter the list of accounts for them to pick from. Plus, giving the accounts human names really helps people understand their accounts.

We don't have all of the answers to these problems, but our goal at this point is to address some of them.

What this blog is about

2006-07-20T21:24:00.000-07:00

Software design is a relatively new field and open source commercial software is even newer. One of the focuses of this blog is going to be on the development, and distribution of a commercial open source small business software package designed for ease of use called GeebisBooks

I also plan on sharing information about the technologies, software and strategies we use during the development of GeebisBooks which might be of interest to those who are using those same tools.