Author: Dennis Kolva

Our new accounting software now runs on iPhones and iPads. The three-part networking contract is now complete: Internet and LAN connections, then apps for Android and iOS.

Mobile apps are not something we can ship yet. In fact, we won’t do any further iOS or Android work until after the desktop versions are out (and stable) for Mac and Windows. The past 7 months of effort were just to see if they could be done at all, and how hard it will be to finish them.

On iPad and Android tablets, the app looks like the desktop version. Many things work OK, but it’s probably a long ways from a final interface. The mobile apps use Internet or LAN to fetch data from a desktop server, just like a desktop client.

The dream is to store file locally on the tablets. Then we will have a cheap, mobile small business monster. Still uncertain if that will be possible.

Both phone apps connect to a desktop server, but they do nothing after that. We came up with a pretty good interface design, but programming it wasn’t in this contract. Once we develop the first app (entering material purchases), others will be easy.

Next on the list is building apps that users can download. Most of the work is jumping through hoops for Apple and Microsoft, so it runs on their newer hardware. We managed to do it once, a year ago. Then tried again and couldn’t duplicate the feat. This time we’ll try harder, and make a cheat sheet so it goes faster in the future.

Once there are final, there will be download links on this blog so users can try it out. It will be a free public download, and stay free for quite a while.

As Goldenseal users and others actually start working with the new app, our staff will be busy for quite a while: fixing bugs as they turn up, and gradually finishing the new website. It has been a long slog.

Dennis Kolva
Programming Director
TurtleSoft.com

Our new accounting software works for iOS now, at least on the simulator. Our subcontractor just got the app running on their iPhone, though it probably will be a struggle to get it working on other machines.  Setting up the app to run on new Android devices was also a big problem. We never fully solved it, but decided to switch to iOS. If we can’t run on iPhone and/or iPad, it’s probably not worth the effort to build Android-only software.

These days, entry into Apple’s 3-trillion-dollar walled garden is hard. Even for a beta version there are many hoops to jump through. The rules are complex and ever-changing. Then, a final iOS release needs to comply with Apple Store rules, which are even tougher.

However, the whole struggle probably will be worth the effort. Right now, very little business software runs on iOS. TurtleSoft can fill a niche that is almost empty.

Once we know whether iOS apps are doable, our staff will take a break from mobile programming, and focus on the desktop app full-time. After that is released and stable, it will be time to launch apps for iPhone, iPad and Android.

Meanwhile, it’s garden season. Our staff has done almost zero programming the past few weeks, and the gap probably will continue through most of May. That has been the routine ever since TurtleSoft started in 1987. Like all creative work, software-building benefits from the occasional gap and vacation.

Dennis Kolva
Programming Director
TurtleSoft.com

Last October, TurtleSoft hired a subcontractor to write networking code for our new accounting software. It was a three-part contract: first for desktop, then for Android phones and tablets, then for iPhone and iPad.

The desktop part finished in December. It lets multiple users access the same file over a LAN (local area network), similar to what Goldenseal does. Even better, it also works over the Internet. Connect a laptop to Wifi, enter the IP address for the server machine, and it’s just like you’re at home.

Part two of the contract was to build a prototype app to run on Android. That just finished last week, much later than expected.

The good news is that we probably can run the full desktop app on Android tablets, plus a smaller, simpler version on Android phones. The bad news is that programming it will be hard. Getting Qt, Android and Java to play nice with each other is no easy task.

Part three of the contract starts next: building a similar prototype for iPad and iPhone. Hopefully it will be easier.

The projects for mobile devices were mostly just “proof of concept”. We wanted to see if they could work at all, how they would feel to use, and how hard they’d be to program. Final work on them will wait until the desktop version is released and stable.

Meanwhile, testing on the desktop app still turns up up plenty of bugs. We used it full-time to run our own business for a while, but had to revert and re-enter a couple weeks of purchases and sales, all because of a serious bug in bank transactions. They were missing some important data that only showed up when we added running totals to the display.

If the iOS project goes quickly enough, we plan on a first public release of the new accounting software for Mac and Windows desktops, soon after it’s done. If iOS bogs down as much as Android, then we’ll launch the desktop version before it finishes.

Dennis Kolva
Programming Director
TurtleSoft.com

This week is a milestone for our new accounting software. TurtleSoft now uses it full-time to run our own business. We have used it in parallel with Goldenseal for many short spells, but now data only goes into the new file.

The new app still has plenty of glitches. Using the software every day turns them up more quickly. Most are just annoyances that don’t take long to fix. If something more serious turns up, hopefully the daily backups will be enough to allow recovery.

The previous TurtleSoft company file had a few hundred bad Sales breakdowns buried in it, left over from similar beta testing in the early days of Goldenseal accounting. Most were fixed by the code that translates from Goldenseal to the new app, but some were too damaged. Those didn’t survive the transition and disappeared. In the new accounting app, at least that block of Sales records from the 1990s won’t crash any more when you view them. Now they just give an error message.

Meanwhile, work on a mobile version is progressing, but slowly. Android is very difficult to work with! Our staff has a comfy routine to build test apps on Mac and Windows, but phone and tablet are much more fussy. Mystery problems and error messages galore.

If the desktop app seems solid enough by the time Android work is finished, the first release will happen soon after that. If still too many bugs, it will wait until after work is completed for iPhone and iPad.

Dennis Kolva
Programming Director
TurtleSoft.com

There’s a saying for construction work: cheap/fast/good, pick any two.

It also applies when writing software for accounting. TurtleSoft is not rolling in money like the early to mid 1990s, so this time around we had to go for cheap/slow/good rather than cheap/fast/bad.

One issue we still need to decide on is file size. For that, the choice is more like fast/small/reliable, pick any two.

The NeoAccess database we used for Goldenseal was fast & small, and not reliable. We had to rewrite their code in order to make software good enough to sell. It made files bigger. Some of that was because we added sanity-check data to the indexes that kept track of where each record is located. We also added a second place to store record addresses: a list sorted by file location instead of a binary tree. That way, if the Neo code lost track of a record, we could still find it and repair the damage.

For the new accounting software, we used the same ideas, but added a few more to make the database even more reliable. It has a price. An empty Goldenseal file starts out at 106K. The new app currently starts at 14 megs, over 100x bigger.

Much of the extra bulk comes from a design decision. Any record database needs to keep lists of where records are located in the file: it’s called an index. There are over 200 record classes, and each gets its own index.

NeoAccess started a new index the first time you used a class. It went at the end of the file. Once an index had 8 records, another index went at the end (later we upped that to 32). Their approach was frugal with both RAM and disk space, but the result was indexes scattered throughout the file. They were hard to locate, and fragile. One stray bit change in an index could destroy a big chunk of the file.

The new app starts with 200+ empty indexes at the beginning of the file, even if you don’t ever use them. Doing that adds to file size, but it makes repair easier. We know exactly where everything is. Right now the indexes are big enough that the “tree” of indexes is not very deep. We can shrink them, but it will make things slower and a bit less reliable.

Another index tracks the contents of each file sector. More empty space at start-up. We also can shrink that, with similar consequences.

Goldenseal is a monster. It does all sorts of things: construction estimating, accounting, project management, rentals, sales, contract writing. Most users don’t need all that. We really need to pivot to smaller, cheaper apps that just do one or two things. Those users probably won’t like to start with a 14 meg file.

This is one of several quandries we are still working on, in the time left before first release. There are many things we can do to reduce file size, but it’s a matter of weighing the costs.

Dennis Kolva
Programming Director
TurtleSoft.com

Almost a year ago, I announced we were ready for a first release of our new accounting software. However, the app just was not ready then. Testing turned up more bugs than expected. Too much important stuff was still undone. Also, building a finished app able to install on Mac and Windows machines proved to be harder than expected. There are extra hoops to jump through, these days.

After a extra year’s work, code quality is looking much better now. Almost everything important works like it should, and almost all serious bugs are zapped. Last week we fixed about 1000 minor compiler warnings. Most were trivial, but a few future mystery bugs lurked in there. Those are now zapped.

The past couple months our staff has focused on multi-user coding, and now Android. Soon iOS. We found a good subcontractor who is doing the hard stuff. What that is done, we probably will also hire him to set up the final builds for Mac and Windows apps. Most likely it will happen in 2 or 3 months. During that time our staff can do more testing, and iron out more wrinkles.

Being able to run business software on any combination of desktop, tablets and phones will be a big plus for TurtleSoft. Intuit and most other competitors have shifted to online “software as a service” systems. The monthly fees are great for their bottom line, but it leaves a gap that we can fill. Some small businesses will prefer to run locally with their data stored on their own desktops. If they can also use phones and cheap tablets at jobsites and on the road, all the better.

A year ago we assumed the first release would be an “alpha”. Something to look at, but not reliable enough to use long-term.  This year we’ll start with a “beta” release. Some lingering bugs for sure, but good enough to rely on day to day.

Dennis Kolva
Programming Director
TurtleSoft.com

When thinking about computers, I like to compare them to automobiles. Both technologies have followed similar paths, with a gap of about 100 years.

Cars and computers started out big, slow and awkward: massive steam tractors in the 1850s and 60s; room-size mainframes in the 1950s and 60s.

Then came a half-century of innovation, much of it done by small start-ups. One round created useful vehicles to move people and goods faster than horses. The other built hardware and software to run a business, view cat videos, and do other amazing things with glowing rectangles.

Next was a couple decades of industry consolidation. For cars, most innovators either disappeared, or became brand names at General Motors or Ford. Computer hardware and software followed a similar path, boiling down to Microsoft, Apple, Google, Amazon, Adobe, Meta, Intuit.

Then came a long spell of bloat, perhaps because competition was gone. Cars grew chrome, fins and stylish updates, with little focus on being reliable transportation. With some exceptions (e.g. VW Beetle), 1920 to 1970 was filled with gas-guzzlers: dangerous on the road and hard to maintain.

It took a few more decades until cars turned into reliable transportation that just worked, without much fuss. My current Honda Fit is light-years more reliable than my first vehicle in the 70s: a Fix-Or-Repair-Daily pickup truck.

Computers are not doomed to follow the exact same path as cars, but they sure are in the bloated/mediocre stage now. TurtleSoft first faced that 20 years ago, as Apple migrated through chips, frameworks and programming languages. At first we kept up, but each change grew harder. Goldenseal 4.96 was the furthest we could go without a total rebuild.

Coding a 64-bit desktop accounting app was a long, failed slog, mostly because of poor quality tools from Apple and Microsoft. Qt, a surviving scrappy start-up, saved the day.

Right now we’re struggling to build accounting for Android. It relies on code from two other superpowers: Google and Oracle. Setup has been a version-matching nightmare. We still can’t get it to build apps on TurtleSoft computers, despite more than a week of trying. There are too many libraries necessary, and no instructions on how to get them working with each other.

We will persevere, but it’s not an easy task.

Dennis Kolva
Programming Director
TurtleSoft.com