Vanilla Programming (Feb 6)

Last week, we discovered a huge trove of Microsoft sample code.  It included the interface source code for most of their apps (Office, Internet Explorer, File Explorer, Outlook…). It also had about 100 sample apps, showing how different features work. We spent most of the week building and running their code, and learned a lot.

Among the samples was RibbonGadgets, with all possible types of controls on a ribbon. We spent a few days trying to merge it into our code, so we could start with a working sample, and then modify it to suit our needs.  Unfortunately, ribbon setup is complicated and very fragile, and we just could not merge it. We finally gave up, and are now building a ribbon from scratch. Slower, but we can test at each step and make sure it still works.

We are building Goldenseal Pro for Windows to be as “vanilla” as we can, using the same MFC classes that run Microsoft’s apps. That way, there is less risk of incompatibilities in the future, and more likelihood that our code will upgrade automatically in future versions of Windows. The goal is Volvo station wagon, not Ferrari.  Boxy but reliable.

On the Mac side, Cocoa has no built-in ribbon interface. It does have toolbars, but not the kind we need. Fortunately, the screen layout tools in Cocoa are much more flexible than in Windows, so we can still create a similar appearance on both platforms. Being “vanilla” is tougher on Mac because Apple changes it so often, but at least we’ll be current for a while.

Enough interface is working now, that we can tell it’s going to be nifty. The main window will have almost everything that is now in pull-down menus, but organized better. It will be much more understandable for beginners, and not too hard a switch for current users.

We’ll release an ‘alpha’ version after we finish the new ribbon interface. That way, you can check it out and give feedback. The first release will also let you import your existing data, so you can see if it converts properly to the new format. If not, we’ll have plenty of time to fix the bugs.

Dennis Kolva
Programming Director

Ribbons, Goldenseal & Screen Size (Jan 27)

We started out designing software for the small monitors of the 1980s (Mac Plus was 512 x 342, and VGA was 640 x 480). It was tough fitting everything onto such a small screen, and we spent a lot of time trying to save a pixel or two.

Goldenseal was first designed for 800 x 640 monitors, then we upped it to 1024 x 768.  One estimate alone could fill up that much space, so we had to ‘hide’ most of the navigation in the menu bar at the top.  Running a business requires a few hundred possible screens and actions, so we split them up into 9 or 10 menus, with divider bars and submenus to organize them a little. It worked, but was relatively unfriendly for beginners, and not the ideal way to navigate through your company info.

These days, 1920 x 1080 is common for desktop screens: equal to 2 million pixels, 11 Mac Plus screens, or almost 7 VGAs.  Even cheap laptops have a million pixels to work with. Goldenseal Pro can stretch out now. We can use that extra space to make it easier to use.

Most of the menu commands are moving to the outline view on the left (called a tree view in Windows). It makes them easier to find, and easier to organize. There will be a Favorites folder where you can put your most common tasks, ready to access with a single click.

Almost all of the other menu commands can also move. Some will be on-screen buttons, and some will reside in right-click menus.

We started work on a Windows toolbar, but soon discovered ribbons. They are basically a fatter toolbar that also replace the pull-down menus. Now standard in MS Office. They look perfect for Goldenseal Pro. Everything on the left side and/or top of our current screens can go there, plus the few remaining commands in the top menus.

The Mac does not have ribbons built into Cocoa, and Apple’s OS design does not seem to be headed that way.  That means it’s going to be a design challenge to get Goldenseal Pro to look similar on the two platforms, but also stay true to the individual spirits of Mac & Windows. We’ll be working on it gradually over the next month or 2, while we also tackle the nitty-gritty of getting smaller details to work.

Dennis Kolva
Programming Director

Goldenseal Pro- Bank Accounts Change (Jan 20)

Goldenseal currently has 7 different types of bank accounts: Cash, Checking, Credit Cards, Escrows, Investments, Loans and Savings.

Our current interface for entering bank transactions is not that great. With the new outline view we can improve it, by showing your bank accounts individually on the left, so it’s easier to view them. 

These days, there is not much distinction between those 7 account types. People write checks from credit card or loan accounts, and use debit cards from checking or savings. It really doesn’t matter accounting-wise how we classify them, so we are considering consolidating all bank accounts into a single class, plus “other investments” for miscellaneous assets. We can add a popup menu so it’s still posssible to classify bank accounts by cash/checking/loan etc in reports.

If we go with this change, the converter from Goldenseal to Goldenseal Pro can translate existing accounts automatically. The only complexity will be asking users where to put each Investment account (it might be a bank account for an IRA, and an “other investment” for gold bars, etc).

User comments appreciated.

Dennis Kolva
Programming Director

Goldenseal Pro Progress (Jan 19)

Goldenseal Pro for Windows now fetches screen layouts from resources, and draws fields on the screen. It was an exciting milestone to reach, because now we can actually see what we are doing, after we make programming changes. The same code is used to make reports, printed forms, and Custom Layouts screens, so it opens up most of the software features.

Handling resources is not easy on Windows. We had to import 338 layouts, then individually rename them, then go through a third time and renumber them. Unfortunately, there are 375 menu resources that need the same treatment. Maybe we can find a faster way to do it.

The Windows code is almost caught up with the Mac version, so we will be alternating between them, from here on out.

The MFC libraries we are using on Windows are totally designed for creating Microsoft products. Doing anything that looks different is much harder. So, it looks like we will have a tool bar at the top and a status bar on the bottom, pretty much like Excel or Word.

The Goldenseal Pro software now uses Unicode for most text.  Unicode includes characters from all languages, and also extra stuff like emojis (including the infamous U+1F4A9). Unfortunately, Windows uses UTF-16 (2 bytes per character) while the Mac uses UTF-8 (1 byte). One of many small, annoying differences between the platforms. 

There are still many details left to complete, before Goldenseal Pro can go live. But, we’ve gotten through the hardest parts. The work is growing more rewarding, with tangible results coming faster. It’s kind of how it feels when a winter construction project gets closed-in and waterproof.

Dennis Kolva
Programming Director


Windows & MFC (Jan 6)

We are making good progress on the Windows version. It was easy to get the new outline view working, since we could use a ‘wizard’ that set it up automatically. After a week of programming, the Windows version already opens files, converts old Goldenseal accounting files to Pro format, and shows the main window. It took more than a month to get to the same point using Cocoa on Macintosh.

We use something called MFC (Microsoft Foundation Classes) for the Window interface code. MFC has been around since 1992, and is still being improved (and used heavily).  MFC is entirely C++, so it’s easy to tie in with our code. In fact, we already use quite a bit of MFC already, in the current Goldenseal for Windows.

Writing good code in C++ takes skill and practice.  Writing apps for Windows and Mac also requires a great deal of patience, since it means working with libraries from massive, semi-monopoly corporations that don’t need to make life easier for their software developers. MFC’s maturity is great, but it also means that many parts still read like DOS from the early 90’s.  Hopefully, we won’t need to spend too much time looking at code such as LPCTSTR lpszItem, LPCTSTR szFilePath.

Dennis Kolva
Programming Director

Outline View (Dec 28)

The Goldenseal Pro ‘outline view’ is now working, and it looks very snazzy! It will reduce clutter and make navigation much easier. Still rudimentary, but we’ll refine it.

The Macintosh interface is far enough along now that we’ve switched over to Windows programming for a while, to get that code caught up to the Mac version. After that, we will work on both, approximately in parallel.

After 3 months of grappling with Cocoa libraries, we now understand why it was so hard to find contractors to do the Mac update. Cocoa is rather programmer-unfriendly, especially for existing apps written in C++.  As a result, Microsoft is just starting to use it for Office, and Intuit is abandoning QuickBooks for Mac, rather than update it. We kinda assumed there would be a huge cottage industry of experienced Cocoa converters by now, but in fact they don’t exist.

Doing the work ourselves is definitely slower, but the good news is that we can try new approaches, and improve the interface as we go.

The fact that Mac programming has grown more difficult also has its bright side.  It sucks to spend months of programming just to stay in the same place, but there is less competition now, than 10 years ago. There are a few big apps and many small ones, but not much in the middle. That leaves many empty niches to fill.

Dennis Kolva
Programming Director

Goldenseal Pro Menu Commands (Dec 16)

Right now, Goldenseal has 316 different menu commands which each open a different type of window.  There are 17 accounts, 51 transactions, 95 lists, 24 action dialogs, and 129 reports.  Running a business is complicated! We probably can eliminate a few commands, but nearly all are needed by at least some users.

In Goldenseal Pro we plan to reduce the number of menu commands and windows, to make navigation easier.  As a start, we just finished a Preferences command that consolidates 8 menu commands into a single window, with tabs. The new Preferences window looks nice and works well.

Using the same approach, we can probably convert those 316 menu commands to 30 or 40 windows with tabs. It will reduce clutter, and group related items together. For example, the Estimating command will show Estimates, Allowances, Bids, Project Phases, Cost Items and Assemblies all in one window, with tabs to switch between them.

There is another approach we are working on, that consolidates the menus even further. It has a column of accounts, transaction types and lists on the left, grouped in folders that can be opened or closed. Click on one, and that type of record fills the rest of the window, on the right. It works the same as tabs, but handles more choices.

Once we finish the Macintosh data entry windows, we will get caught up to the same place in the Windows version, and then release them as a ‘pre-alpha’ version so users can try out the new interface(s). There are many fussy details to address, so it probably will take a month or 2 until we get to that point.

Dennis Kolva
Programming Director


Smart Fields (Dec 5)

Back in 1985 we started to write estimating and accounting software in Lotus 1-2-3 on a Tandy 1000, and then in MS Excel on a Mac Plus. It first sold in 1987 as MacNail 1.0.

At the beginning, the spreadsheets had vendors, cost categories and jobs as plain text fields.  Unfortunately, reports would show Smith and Snith as separate jobs if you made a typo.  Even worse, an extra space character also split it into a different job, even though it looked identical on the screen. OK for perfect typists, but not for humans.

We switched to number codes, but that was hard to remember.  So we added “lookups” that showed the name next to the number.  Better, but you still had to memorize hundreds of numbers, or use a cheat sheet, or guess a lot. The lookup formulas were also very fragile.

Back then, Bruce Tognazzini was the “interface guru” for Apple.  He wrote about a hypothetical disambiguating field, designed to choose items from a list by typing the first few letters.  It also had a popup button so you could enter data with the mouse. The setup sounded ideal for accounting data. There was nothing at all like that in Excel, which was one reason why we decided to develop Goldenseal as a stand-alone accounting app.

Apple never added the disambiguating field to its standard controls, so we wrote one from scratch.  Disambiguating seemed too odd a term, so we called them clairvoyant fields.

When we started the Cocoa update this year, we were excited to see a class called NSComboBox. It looks like a disambiguating field, with text and a popup button.  Unfortunately, when we tried using it, it turned out to be just the opposite.  For accounting, everything needs to go into a specific vendor account, job and cost category.  It’s nice to have an easy way to add new accounts, but you do not want to create a new account every time you make a typo.  Unfortunately, the combo box gives suggestions, but is happy to accept whatever you type. We tried hacking it, but it is just not meant to have other behavior.

So, we are now in the middle of redoing clairvoyant fields to work with Cocoa native controls.  It will be a text field next to a popup button, just like before. Type a few letters and it shows a list.

Clairvoyant fields sound too complicated, so they’ll become smart fields.

It will take some experimenting to come up with a new look for them. Probably a gray border? It needs to look good on Mac, Windows, Android and iOS.

As a boon to data entry, popup fields will also become smart fields. That way, you can do all data entry from the keyboard, and never touch the mouse. It will be a Preferences option, so you can keep the original popup appearance, if you prefer.

Dennis Kolva
Programming Director


Inside Macintosh Cocoa (Nov 25)

When we first started work on the Goldenseal accounting software, there was a set of printed books called Inside Macintosh. It was 7 or 8 volumes, about a foot wide, and pretty much the Bible for Mac developers.  Our copies grew battered from constant use, and we had a ‘cheat sheet’ that pointed to the pages we used most often.

These days, Apple’s documentation is all online. Unfortunately, it’s also more scattered. The Web makes it very easy to find answers quickly, when you know what question to ask. Unfortunately, it also seems to make discovery harder, when you don’t know if something exists in the first place. Hard to search, when you don’t know which words to use.

For example, last week we set up the record window layouts, but then stumbled upon a Cocoa class that makes record scrolling seem more like pages in a book. To use it, we had to throw out what we did, and start over.

To help discover what else we don’t know, we are now gathering all of the Cocoa classes into a spreadsheet.  It won’t be Inside Cocoa, but at least it will show everything it can do. There are already 250 rows, and it’s not even half-way done, yet. The project has already turned up several nifty classes that will improve the interface, without much effort.

Meanwhile, we also spent the last couple weeks improving the new database code. It was giving a few error messages after converting old files to the new format, and those bugs are now fixed.  It also does a better job of deciding how long records stay in RAM.

For a while, we were concerned that we might have made a mistake by writing our own database code, instead of licensing from someone else. However, so far it is working extremely well. It’s much simpler, and probably will be much more reliable. Between 1998 and 2015 we rewrote more than half the old NeoAccess code, so replacing the rest was not as overwhelming as it might have been. And, of course, alternatives like Core Data or SQLite have their own bugs, quirks and design flaws.

Dennis Kolva
Programming Director

Goldenseal Pro Progress Report (Nov 11)

We are now in the “middle” stage of the Goldenseal Pro project.  There are many different things we can work on, and it doesn’t matter which we do first.

When we removed blocks of obsolete code last year, we replaced them with one line of code that gives a beep. So, as we make progress on the interface, it also starts to beep a lot. Eventually that gets too annoying, so we go in and add code just to shut it up. For example, this week we added ‘new style’ code to handle dates, times, and error messages.

Judging by how the work has gone so far, I think we will have something ready to ship by late Winter 2017.

Dennis Kolva
Programming Director