Goldenseal Pro Progress: Resources (Mar 23)

Goldenseal estimating and accounting software is built from three components. There is C++ source code that runs business functions and the user interface. There’s construction accounting and estimating data in the starter files. And in between, there are resources: text, layouts, icons and other program details.

The source code is compiled into machine language, with no easy way to see it. The estimating data is totally visible and easy to change. Resources are in between.

In the original Goldenseal for Mac, resources were built into the app file. Anyone could use an app called ResEdit to change them. One user actually converted all the text to Spanish. Other changes were possible if you hacked the right resources. Sadly, ResEdit never made it out of Mac OS 9. It was still possible to hack Goldenseal while it ran on PPC Macs, but the switch to Intel zapped all user access to resources. Meanwhile, the Windows version never had resource access at all.

We are still trying to figure how best to handle resources in Goldenseal Pro.

These days, the Mac hides resources inside what’s called a package or bundle. You can see the resources for any app: just right-click on the icon and choose Show Package Contents from the menu. Early on we wrote temporary code that exported all the resources out of the current Goldenseal, and into the Pro version. Those resources were in the bundle, and user accessible.

Apple really likes XML as a way to store data (it’s similar to the HTML that builds web pages). We tried XML at first, but didn’t like it. The text is hard to read: stuff like <tag><anothertag>blahblahblah</anothertag></tag>. Just one wrong punctuation mark, and it crashes. So, we switched everything to plain text. It’s easy to edit in Excel or TextEdit, and reads are 10x to 100x faster.

Qt also manages resources. It wasn’t hard to re-use most of the existing stuff when we switched over. Unfortunately, Qt hides them somewhere. If you open the app bundle, they aren’t visible. There may be some way to make Qt resources act more like Cocoa, but so far we haven’t discovered the secret.

It may be a moot point. Apple has toughened its security: to run Goldenseal Pro on newer Macs we must jump through hoops to guarantee that the app comes from a legitimate source. That probably means that users can’t hack app resources any more. The changes will be considered a security threat and it just won’t run.

We could store resources and other data outside the app bundle, but that makes installation and updates more difficult. Having just two things to keep track of (app and company file) is simpler for everyone.

Aside from the Goldenseal app, there is also your own accounting data, stored in your company file. One of the first things we wrote was a translator which converts existing Goldenseal files into Goldenseal Pro format. It even makes a few improvements along the way.

There is one piece of data that gets lost in the move: pictures. The current Goldenseal stores them in an obsolete format (PICT) which neither Cocoa nor Qt support. Fortunately, there are websites that convert PICT files to .jpg, .png or whatever. When we launch the Pro version we’ll provide links and instructions so you can salvage any pictures you may have stashed away.

Dennis Kolva
Programming Director

Goldenseal Pro Progress: Layouts & Actions (Mar 16)

After two weeks, Custom Layouts is starting to look like something. It loads fields. You can drag them around on the screen. Click a tool, and you can add a new field. The app is already further along than we ever got with the Cocoa version.

Unfortunately, there isn’t any Qt sample code for doing a MacDraw-like environment. We’ll have to create most of the interface from scratch. None of it is real hard to write, but there are many fussy details. Undo in particular is a PITA.

The original Custom Layouts command needed at least one programmer-year to finish. Qt will be faster, but most likely it will take 2 or 3 months to get everything working well.

This stage of programming is a bit like starting rehab work on an old house. Sometimes you have to knock a few holes in the walls, just to see what the guts are like. Then you can get a better estimate of what’s needed. We kinda just did that with Custom Layouts. Now there’s a clear scope of work, and we know it’s doable.

Speaking of knocking holes, I must share a construction tale from an Ithaca rehab project in the 1980s. It was a small, odd house that had been owned by a custodian who worked at Cornell. The new owner wanted to remove a non-bearing wall to combine two rooms. I tried knocking holes to check for wiring, but couldn’t. It was plaster over an old door, with concrete fill behind it, then wood scraps nailed together, then plaster on the other side. Demolition was like an archeology dig through all the random building materials that someone brought home from work. Bricks, putty, roofing tiles, wadded newspaper, grout, tar, woods of all sorts. Too bad YouTube didn’t exist back then, because the demo (or the construction process) would be an amazing time-lapse video.

Anyhow, next on the agenda for Goldenseal Pro is the final untouched mode: action commands (Reconcile, Pay Bills, Deposit Funds, Project Billing, Sales Billing, Write Payroll, Job Costs). It definitely will be hard, because the current code sucks. Giving a complete overhaul to the interface has been on the to-do list for more than a decade.

The rest of Goldenseal uses Custom Layouts to arrange fields on the screen. It makes setup easy for our staff. It also lets users make changes. Action screens currently use a different system that is awkward for us. Users can’t change anything there at all. Since we have to rewrite anyhow, now is the time to switch them over to the Custom Layouts system.

Our staff probably will be working on the two areas in parallel for a while. If it gets too frustrating, we’ll take a break and work on other, simpler loose ends.

Meanwhile, this winter I’ve been doing major interior work on my house. In 2 or 3 weeks it will be ready to list and sell. This area is in a seller’s market for single-family homes, so it probably will go fast. I’m already looking at fixer-uppers to replace it.

The current house was built in 1910, right after the chestnut blight came through. Chestnut lumber was cheap for a while, so they used it for all the trim work. I wouldn’t mind finding another house from the same era. Chestnut looks great, and it’s easy to work with. Too bad it’s now a fossil.

If the next house needs trim or flooring, I’ll put in ash. This century’s cheap hardwood caused by a major species loss.

Unfortunately, the whole selling, buying and moving process may cut into programming progress for a couple months. We’ll see.

Dennis Kolva
Programming Director

Goldenseal Pro Progress: Reports & Layouts (Mar 1)

Our estimating and accounting software has five different modes. Three of them are now working: data entry, Find command, and reports.

That doesn’t mean the project is 60% finished. Our rule of thumb: this stage is the first 1/3 of the work. The second 1/3 is finishing all the little details. The final 1/3 is testing and debugging.

Building software is similar to building a house. We did foundation work last Fall. Now three wings out of five are framed up and closed in. The app is starting to look like the architect’s drawing, but it’s not too late to tweak the floor plan. There is still plenty of utility and finish work to do.

It took a couple months to get the basic app window set up. Data entry screens needed a couple more months. Find and reports only required a week or so apiece. The two remaining modes (layouts and action screens) will be somewhere in between.

While working on the new Qt code, we often step through the old, partly-finished Cocoa version to recall how it works. No sense in re-inventing any wheels. If there’s nothing useful in the Cocoa app, we can also go back and step through source code for the current Goldenseal.

Back when we stopped work on the Cocoa version, I estimated that it was 1/2 to 2/3 complete. However, stuff keeps turning up that was never even started. That estimate probably was too optimistic. While struggling with Cocoa every day, I guess it was hard to see what a morass it was. Not seeing the forest for the trees.

Last week our staff worked on Reports. To see a report in the current Goldenseal, you choose something from the Reports menu at the top of the screen. It’s way over on the far right, so people often miss it. In Goldenseal Pro, there is a Reports button right on the main window. It makes navigation easier. From then on, the interface is similar.

We just started on the 4th mode: Layouts. It lets you change the appearance of data entry screens, printed forms and reports. In the current Goldenseal you get there via Options–Custom Layouts. Another nifty feature that is tucked away and hard to find. In Goldenseal Pro, it also gets a button on the main screen.

Custom Layouts was one of the first components we built in the current Goldenseal, back in the mid-1990s. It allowed the project manager (me) to design the app, while the programmers were writing C++ code to make it work.

It would also be nice to have Custom Layouts right away in Goldenseal Pro. Then we can adjust the current layouts for bigger screens.

Apple has sample source code for a drawing app that is very similar. We had high hopes it would make the work easy for the Cocoa version. Unfortunately, the sample code was old and unusable. As the project bogged down, we finally decided to skip Layouts entirely for version 1.0.

Based on results so far, I am optimistic that Custom Layouts will be easier to create in Qt. We’ll know better about that in a few weeks.

Goldenseal’s layout mode is similar to the MacDraw program on early Macs. That app never made it to OS X. Too bad, since I had useful data in MacDraw files: house plans, travel maps, flow charts, ad layouts. There was never a great replacement.

If Qt is not too much of a struggle, it will be tempting to spin off a MacDraw clone some day.

Dennis Kolva
Programming Director

Goldenseal Pro Progress: Monopolies (Feb 21)

Ithaca has five new-car dealerships scattered along the main drag. Years ago they were independent, but one of them started to buy up the others. Now they’ve gobbled all five, and are expanding into nearby towns and cities.

There’s a lot to be said for owning a monopoly. You can charge your customers more. You can pay less to your sales and repair staff. Where else are people gonna go? Even better, you can use the excess profit to expand and/or purchase the competition, and get even more monopoly. It’s a positive feedback loop. A chance for exponential growth. One reason why the rich get richer.

Doing business with a monopoly? Not so great. Fortunately, there still are independent repair shops in town. It’s also possible to drive an hour and get dealer services for 1/2 to 2/3 the local price. Both those options may dry up if the trend continues.

Sadly, more car monopoly is likely: dealerships are consolidating everywhere. The local group isn’t even in the top 150 for size. Their industry is following the same path as banks, auto parts stores, lumber yards. However, the difference is that auto dealers already have franchises: a local monopoly for one or a few brands. Merge them, and it’s like owning every bank in town. Hedge funds must be drooling.

Monopoly is a problem we face as a construction software company. TurtleSoft is a minnow swimming in a sea owned by trillion-dollar tech monopoly sharks.

The Apple/Microsoft desktop duopoly doesn’t mean higher prices for us. In fact, their development tools are free. The problem, I think, is a more general arrogance. It happens when wealth and power get concentrated. No competition, so no need to make their tools excellent. If it takes 4x as long to build for the platform, well, that’s just the cost of entry. Suck it up.

Plain old incompetence may also be part of the problem. Too many pointy-haired bosses in the decision chain. Or maybe there is something else at play. Minnows can’t easily understand sharks. All they see is skin, teeth and turbulence.

For whatever reason, we wasted more than 4 years with Cocoa/Xcode from Apple, and MFC/Visual Studio from Microsoft.

I did a post-mortem recently, looking back at all our past successes and failures. They very much correlate with monopoly.

TurtleSoft started with MacNail, estimating software based on Excel spreadsheets. It was back when Microsoft was the scrappy underdog struggling against Lotus 1-2-3. Later we released BidMagic, made with Apple’s HyperCard when they were the scrappy underdog competing against IBM, DOS and Windows. Next came Goldenseal, built using CodeWarrior from Metrowerks. They were the smallest, scrappiest underdog of them all. CodeWarrior was also the best tool our staff has ever worked with.

In all three cases, I think the scrappiness led to excellent programmer tools. They had to be amazing, or die. The end result for us was being able to create software in a reasonable amount of time. The tools were satisfying to use. Almost fun. Definitely productive.

Sadly, all three of those tools lost their greatness prematurely. Excel grew bloated after Version 3.0, with a bug that randomly zapped code in our macro sheets. HyperCard stagnated and soon disappeared. Metrowerks was absorbed by Motorola. After a few years they butchered CodeWarrior and sold its organs.

Scrappiness does not guarantee great software. Over the years we’ve tried at least a dozen development platforms that didn’t work out. Some came from big fish, but most were made by minnows that later died. It’s always a gamble.

Fortunately, Qt is proving to be like the 3 best development tools we’ve used. Every week it lets our staff make serious progress on Goldenseal Pro. Things are really cruising.

In the future, TurtleSoft will be less tolerant of BS from the trillion-dollar companies. They lost something important, getting to be so big.

Looking at the bigger picture, monopolies may have grown too powerful. There’s too much concentration of wealth and power these days. Too much arrogance and incompetence.

It may be time again for some Teddy Roosevelt-style monopoly busting. Clamping down probably won’t help car owners around here, but at least it can rein in the biggest of the sharks.

Dennis Kolva
Programming Director

Goldenseal Pro Progress- Smart Fields & Qt (Feb 8)

Accounting software is all about accounts: the people and companies you do business with. There may be hundreds or thousands of them. MacNail Accounting, our first attempt at job costing software, gave everyone a number. Data entry meant using a printed cheat sheet (or memorizing numbers). It was easy to make mistakes.

For Goldenseal, we found a better way: clairvoyant fields. They pop up a list of items when you start to type, so you can just use regular names for your accounts. Usually you type a few letters, and get what you want. Worst case, you scroll through a list or use a pop-up button.

Goldenseal Pro still has the same thing, but with a name change to smart fields. They are an important part of our estimating and accounting software.

For example, when you enter a Material Purchase, smart fields link it to a vendor account, sales tax rate, payment method and payment terms. They allocate job costs to a project, cost category and subcategory. Smart fields may also tie the expense to an allowance, bid, change order, room, unit or project phase.

Goldenseal does useful stuff with all those links. It sets up Accounts Payable, or pays the vendor instantly. It gives you expense reports and job cost reports. It does time & materials billing for projects. If you include an itemized breakdown, it updates material prices for future estimates.

You may interact with smart fields hundreds of times per day. Because of that, they need to perform well. It took some effort to make that happen in the current Goldenseal.

Last week we used the Qt framework to set up smart fields for Goldenseal Pro. After a couple days they already look great, and perform properly.

Smart fields are the last interface detail we were worried about. As a tool for finishing Goldenseal Pro, Qt has aced the test. It’s going to build the new 64-bit interface on a reasonable schedule. Wheee!

For the short term, the question is: how long will it take to finish? We don’t have enough experience with Qt to answer that yet. It took 3 years with Cocoa to get roughly half to 2/3 done. So far, programming with Qt has gone about 4x faster than Cocoa. If that math continues, the best guess is another year or so.

One uncertainty is Apple’s new M1 chip. We won’t have to change our code for it, but the Qt framework needs an update to run natively there. Qt is mostly open-source, and folks are working on M1 compatibility now. They probably will finish before we do. It helps that TurtleSoft doesn’t use anything fancy in Qt— just the basics. BTW that need to rewrite for M1 is a big part of why we decided to halt Cocoa development. It was last straw on camel’s back.

For the medium term of five to ten years, my biggest concern is that the Qt Company probably will get bought. It could be swallowed by any big fish that sees strategic value in them: Apple, Google, Microsoft, Oracle. Nokia owned Qt for a while, and maybe they will re-buy before they get swallowed. With luck the actual Qt framework won’t suffer too much from assimilation, so we’ll get a 10 year lifetime or more.

For the real long term, we’ve found out the hard way that long term planning does not exist for software. It’s risky to rely on any small or medium-sized company: they often disappear. It’s risky to rely on the big players: their frameworks and tools often disappear (or become useless). Maybe things will settle down some decade, but probably not soon.

Dennis Kolva
Programming Director

Goldenseal Pro Progress- Breakdowns & Smart Fields (Feb 2)

Our staff started work on breakdown tables last week. After two days, they already looked great. Values filled into cells. Text was editable. General appearance about the same as our current accounting software. Even better, the code (QTableWidget) was easy to understand. It got the job done without too much sweat. That is a very, very good sign.

It took a month to get to the same place using Cocoa for Macintosh. NSTableView has many built-in features, but it is complicated and hard to adapt. There were many quirks to overcome.

MFC for Windows was even worse. They don’t have a built-in table class at all. We found a few libraries to make a grid of cells, but they were ancient and buggy. So we started to write a table class from scratch, but then the pandemic hit. The break gave us time to realize that MFC was just not going to work out. It’s too old, and too creaky. Hence the pivot to QT.

Breakdown tables are not completely done in the QT version, but they are good enough for now. We’ll come back and finish them later. The plan is to get past all the potential deal-killers at the beginning, before investing too much time.

Next on the list is smart fields (called clairvoyant fields in the current Goldenseal). Those have a popup button that shows a list of projects, vendors or whatever. You can click the button and choose one. Or you can tab into a field and type the first few letters, or start typing then choose from a scrolling list. It’s ideal for accounting software, where everything links to other stuff.

The basic design for smart fields came from Bruce Tognazzini at Apple, one of their human interface gurus. He called it a disambiguating field.

Cocoa has something called a combo box. It is similar, so at first we thought it might be Tog’s design brought to life. We fiddled with NSComboBox for weeks before realizing it wouldn’t work. Close, but users could type in things not on the list, and there was no way to prevent it. No good way to deal with it. We ended up building smart fields from three components, just like in the current Goldenseal. There’s a text field, a popup button next to it, plus a scrolling list that pops down when you start to type.

MFC also has combo boxes, but with the same basic problem. QT has them too, but they are even less adaptable than in Cocoa or MFC. Being worse was better, since it was obvious they’d never work. We didn’t waste time trying.

This will be the 4th time we build 3-part smart fields, so it probably won’t take very long to get them working.

Breakdown tables use smart fields. For example, for each line item in an estimate there are three: Category, Subcategory, and Cost Item. Each row in a construction estimate can show all sorts of stuff, so the code to manage them is very complicated. It’s a collision of many complex things.

In the Cocoa version, we never managed to get smart fields to work properly when in tables. The eventual solution was to have a pop-up window to enter each line item, instead of doing it inside the table row. That turned out to be a nice interface. We may use it for the QT version also. Not so cramped as working in little table cells.

If QT is very cooperative, we could do it both ways. Then users can choose which they prefer.

Dennis Kolva
Programming Director

Goldenseal Pro Progress (Jan 26)

Our staff is making good progress on Goldenseal Pro. The part-time schedule is great. Too much programming time means getting fat. Too much construction work means carpel tunnel syndrome and other joint problems. This is close to the sweet spot in between.

Last summer we hired an experienced QT contractor to write a prototype. By now we have replaced almost all of his code, but it helped to get a running start. The code had a few ‘tricks of the trade’ that we didn’t have to learn the hard way. It definitely was worth $500.

When we first tested the button to make a new record, the app gave a weird database error. It turned out to be an accidental infinite loop. Within a few seconds it filled the file with the maximum number of records that it can hold: 65536 x 4096, or about 1/4 billion. Oops.

Until we ship, those numbers aren’t fixed, but we probably won’t change them by much. It’s a balance between maximum capacity, empty file size, and code complexity. We’ve used Goldenseal f0r 20+ years for our own accounting, and aren’t even in the millions of records yet. So 250 million is very conservative. The file size for that is about 500 gigabytes.

The app now gives a better warning when it starts to get close to the max, just in case someone really creates humongous data. It asks the user to contact Turtlesoft so we can program in a higher limit. It probably will only take a few days of programming and testing to add support for multiple billions of records, but there are more important things to work on right now.

Goldenseal Pro has a lot of interface, which means many small details to finish. So far, QT is handling them well. We’re just about ready to start working on breakdown tables: the most difficult task. It’s where both Cocoa and MFC stalled out. It seems very likely that we can make it work. Then it’s just matter of time to complete everything else.

Six years ago, we hired a different QT contractor to build the first attempt at Goldenseal Pro. He gave up after 6 months. Afterwards we checked his work to see if it was worth salvaging, and decided it wasn’t. That was a fateful decision. After ruling out QT, we subsequently threw away five years trying to build Goldenseal Pro with other frameworks (Cocoa and MFC). First with other contractors, then with our own staff.

I think the difference is that the original guy tried to change all of our existing interface code into QT classes. It made a big, complicated mess, and was extra work besides. No wonder the project failed.

Starting over, our current approach is to use new QT classes for what’s visible. Then link it into our existing code. I suppose it helps that we already did that with two other frameworks. Our staff has learned some stuff along the way. Maybe we only wasted two or three years instead of four.

Oh well. Creative work is hard. It’s not the first time we’ve wasted time, or thrown away big hunks of code. What counts is actually finishing an app. This time around, it’s looking pretty good.

Dennis Kolva
Programming Director

State Payroll Withholding (Jan 6)

Yesterday, TurtleSoft released 2021 payroll tax tables for our accounting software. It’s our 31st year of doing so.

We kinda got into the payroll software business without meaning to. Its origins are similar to our estimating and accounting software. Turtle Creek Construction never had actual payroll: back then it was easier to pay under the table, especially for short-term workers. But as the software biz ramped up, suddenly there were actual white-collar employees who needed withholding, FICA and the whole nine yards.

Eventually, the early cobbed-together payroll spreadsheets were good enough to include in MacNail Accounting. It started with just New York and California, but expanded to the whole US a year later. The whole system improved vastly in Goldenseal, and we even added Canada.

Updating US payroll is quite the PITA. 50 states is a lot to wade through. Even worse, many states have found odd-ball ways to calculate withholding, and most years there’s at least one state that finds a new, even wackier way to do it. I think creating tax formulas is probably one of those low-status jobs that gets pawned off on some lowly official, or maybe the brother-in-law of the Governor.

A couple years ago, Utah changed their payroll withholding formulas to something complicated that Goldenseal couldn’t handle. Rather than write new code for just one state, we decided to graph their numbers, and figure how to match them. It turned out to be a straight line. So we now have a simple one-step table that gives the exact same results.

Connecticut is even worse. I think they must have disliked some part of their “tax curve”. Rather than tweak it, they added another table to correct it. Then that caused new problems, so they added another table. Then that still wasn’t right, so they added a couple more: including the Table C 3% Tax Rate Phase-Out Add-Back table. Dave Barry would consider it a bad name for a rock band. Someone with basic math skills could simplify the whole mess in a day or so, but I’m sure the political and bureaucratic process would drag out for months or years.

There’s a similar problem happening with the response to Covid-19. States and local health departments and governments are kind of on their own. Everyone is guessing and improvising.

The good news is that it will provide interesting data. Maybe we’ll learn from the mistakes.

Dennis Kolva
Programming Director

Goldenseal Pro Progress (Dec 31)

Our staff made some progress on Goldenseal Pro, then the holidays hit. This week we are futzing with payroll tax tables for 2021. Next week it’s back to working with QT. The big question is, how fast will it go?

Since the pandemic started, I have done a lot of of construction work. As a result, I’m now almost as lean as during Turtle Creek Carpentry, 30+ years ago.

The other day I carried a bucket of joint compound upstairs. About 60 pounds, the difference between my current weight (195) and my maximum during programming spurts (255). I imagined carrying that kind of load around, every single day. Nope. I really, really don’t want to go back there again. The mass piles on gradually so you don’t notice it right away, but I sure notice the lack of it now.

From 1987 to 1992, I was the main programmer for Turtlesoft: writing Excel spreadsheets and a HyperCard app. It meant many days sitting at the computer full-time. I gained 60 pounds. Then I switched to supervising real programmers, bought a fixer-upper house, and did a major rehab evenings and weekends. By the end of that I was lean again.

After the year when Apple almost died, I ended up finishing Goldenseal myself. It was six years of C++ frenzy, and back up to 255. That seems to be the usual max. Some combination of burning more calories because of the extra burden, and feeling unhealthy enough to do something about it.

Since then, my weight has correlated pretty closely to the amount of time spent sitting at a computer. Usually it’s somewhere between the two extremes.

Programming work is intense. It requires that you hold a huge mass of stuff in your brain’s RAM. The big picture is necessary so new code fits in well. Remembering many hundreds of names is necessary, so you can whip out code without looking up functions and classes. C++ syntax and good programming rules need to be in the brain’s best Level-3 cache, on call constantly.

Loading it all is a big mental effort. But once it’s in, you can get into a productive groove and really fly. Write a few lines and boop, something works when you run it. The process is very satisfying. I can’t think of anything in construction that gives such amazing results so quickly. But it requires sitting still, only moving fingers and eyeballs, and living in a fantasy world of CNextRecordButton and ShowBreakdownTable(const SInt32 tableID) for hours at a time.

Losing it is like a blown engine. Bye-bye forward motion. Programmers are often surly, because a single interruption can pop the whole mental picture like a balloon. It may take hours to restore it.

Because of all that, when not programming, it’s hard to start. Then once you’re in, it’s hard to stop. If it were a drug, a programming buzz would have the unpleasant start of mescaline, followed by the addictive rush of cocaine.

Some types of programming don’t require all the intensity. Fixing small bugs is possible to do in shorts spurts. Adding a small feature to familiar code is easy. Problem is, building a whole new QT interface for Goldenseal will require full-on high-impact frenzy. I’ll need to be in the zone for quite a while. Maybe 100 days of it? It’s still just a guess now.

I still haven’t figured out the right balance, to be both code-productive and healthy. The next few weeks I’ll try scheduling two-day spurts, and see how that works out. Then tweak it if needed.

The goal for 2021 is to finish Goldenseal Pro on a reasonable schedule, but not get fat. And not get Covid-19 before a vaccine is in my arm.

Dennis Kolva
Programming Director

Goldenseal Pro Progress (Dec 14)

Our staff is back to cruising on Goldenseal Pro. Productivity really went up once desks, equipment, wiring and amenities were all settled in at the new office.

These days, we are reinventing the wheel for the third time. Our staff built the original Goldenseal interface in the late 1990s and early 2000s. After that, we worked on improvements to the accounting and estimating code. From 2016 until Sept 2019, we tried rewriting the entire interface using the Cocoa framework: a necessity to run on 64-bit Macs. Then we started over, and repeated with MFC for Windows, until the pandemic hit. After neither of those frameworks worked out, we started over yet again with QT (cross-platform) this summer.

All that previous work wasn’t completely wasted. TCS_FOR_COCOA marks the places where our code connects with the Cocoa version. We are going through all 258 of them one by one, and writing a QT branch to do the same thing. It saves a lot of thinking and testing.

So far, QT seems pretty decent. However, it does have its oddities. For example, we will need to use four different QT classes to replace our current text fields. Cocoa and MFC only needed one, as did the original Goldenseal.

QDateEdit is pretty neat, because it pops up a calendar to enter dates. A bit nicer than just typing in text. QTimeEdit provides a similar pop-up tool for times (which we don’t use very often). For regular text, there’s QLineEdit for single-line fields, and QTextEdit for multi-lines. Splitting them is a minor nuisance, but QTextEdit does show scroll bars if multi-line text gets too big. To do that in the original Goldenseal would have required too much extra code.

The real test will be breakdown tables. We wasted almost a year on them in Cocoa, and still never got them working right. MFC was even worse. There’s other stuff to do first, but I think we’ll be able to move on to tables within a month or two.

QT just released a major update. Up until now, QT has been a weird mix of a commercial version, and one that is free and open-source. The bad news is that QT 6.0 won’t have a free option. The good news is that they dropped the license fee to something much more reasonable for small developers like us.

This may be a good thing in the long run. We wrote the original Goldenseal using a paid app (CodeWarrior). It cost something like $300 a year, but the software was a joy to use. Their support was great. These days most desktop programming happens with either Xcode (free from Apple) or Visual Studio (free from Microsoft). They and their frameworks have been a constant struggle.

Paid-but-great definitely beats out free-but-mediocre, especially when you’re using it for hundreds or thousands of hours.

Dennis Kolva
Programming Director