Wow, I have to say first of all: I am really glad that this milestone has (almost) reached its end. It’s not visible to the outside world, we’ve always tried to touch on the issue through (admittedly relatively infrequent) reports, but the truth is: It was an incredible mammoth task that was initially completely underestimated even by us who deal with software projects on a daily basis in our professional lives.

The last release, version 2.3.1, is now about 9 months ago. After that, first primarily I, later an upgrade of the internal programming language Dart, forced us to have an entire review and in order of that a renewal of the code base. It is simply necessary from time to time to take a critical look at one’s work and see which parts are still up to date, which are outdated and which have meanwhile grown so much that nobody understands them anymore. Wipe through, re-sort, renovate. And since the programming language Dart slowly grew up together with our project, it just so happened that it also got a make-over, which meant for us: even more restructuring.

We already talked about our refactoring goals here and here in January, so I’ll skip the explanatory details now. The important thing is the bottom line: We had gotten the plague on board. Even though we didn’t write it explicitly, there were rarely two days in a row where at least one of us didn’t work intensively on the code. I actually only had such an intensive workload during the first ten months when I launched this baby. Besides many private projects, family and Covid, this task here was really extremely stressful for us. And in contrast to the initial phase back then, the current one was really anything but nice, because it was thankless to the highest degree: In the best case, after days of programming, the tool “only” did what it did before, in the more likely case, something else broke.

We learned to structure ourselves, we involved the testers even more closely in the development process, and we also tried to integrate you, the users, directly by providing a separate test version (which unfortunately went rather meeeh, as we hardly ever got any external feedback). We massively revised, updated and expanded our internal testing so that we could catch our own bugs as early as possible. We thought we were at the finish line several times, but new bug reports from ourselves kept coming in over and over again. It drove us crazy. It was frustrating. Changing the code base was no fun, but I think we all learned along the way and the team matured within itself.

Of course, my thanks go to all the members of the team who have dedicated all their energy to this great goal! You all were incredible!

The Limits of the Version

Besides the code refactoring, version 3.0 initially had very ambitious goals. However, since the refactoring itself kept us much busier than expected, some things have of course not yet been achieved as we would have liked. In the refactoring itself, the complete chapter around the Reflection thing is missing, where it’s still not clear anyway if it won’t lead to an extreme slowdown of the startup process. But I will definitely test it in the next weeks.

Also with the “Web API” we did not reach the final goal, which was to ask our server internally for the solution of a problem and to get an answer. Nevertheless, we have made a very big step here, because at least it is now possible not only to call individual tools by means of special URL, but even to fill the most common ones explicitly with inputs.

But why don’t we just wait longer? On the one hand, Google is again giving us an ultimatum, because they are currently threatening to throw all apps out of the Play Store that do not have a new minimum requirement, which we could not yet aim with the old versions. On the other hand, a line simply has to be drawn. Sure, there will always be things here and there that we need to work on, but ultimately we don’t want to keep users waiting, some of whom we promised a new feature months ago or who reported a bug in the existing version. Thanks for that by the way (I hope we didn’t forget any bug reporter for our tester list in all the chaos, otherwise feel free to contact us).

Highlights of the Version 3.0.0

Enough of what we didn’t get done. I think it’s time to reveal what makes the new version not only internally entitled to a major version jump, but also visible to you users:

First of all, I would actually like to mention the Web Interface, which goes to Mike’s account. Because unlike before, all tools can now be accessed directly by calling them up in the address bar of the browser. The advantage of that is that you can now link directly to a tool instead of always saying, “Go to the web page for GCW, then click here, then click there.” It is even already possible for a number of common, simple tools to immediately include the input text and possibly some parameters directly in the link. This now opens up the possibility that external tools or browser plugins can be designed to take certain codes directly and use them to go directly to our website, where the solution is displayed immediately. (As said, the step of playing the solution directly back to the caller is already being worked on – without promising anything).

• https://gcwizard.net/#/? Overview of the web links of all tools. The ones with a check mark have a continuative API for direct input or parameters etc.. On the question mark button behind you get an OpenAPI-like description of the interface
• https://gcwizard.net/#/vigenere?input=Ohisr+Drosg&mode=decode&a=1&key=GCW Example of a direct call of a tool with parameters in the URL

Besides the mammoth project of stabilizing and test-proofing the Wherigo tool, Thomas’ goal was to implement the scripting engine GCW Script. The older ones among you can surely remember the script function of Mopsos. This here is an attempt to create an analogue, and I think it looks pretty good already. GCW Script is basically based on a BASIC dialect. Some of GCW’s own functions are already directly integrated as function interfaces. I personally think that there is still a lot of maturing to do here, but this can only happen through concrete applications on your, the users’, part, which is why the BETA flag is applied on this.

The only right moment to include so-called Breaking Changes are major version changes? We took the chance to revise an earlier decision, which turned out to be impractical: The Formula Solver got the text functions some time ago, in order to be able to calculate the alphabet values directly, for example. This was simply done by av(C) = 3. But there was the problem, what if there was a variable C in parallel? We had a couple of algorithms that made sure that some consistent behavior was generated, but it was always not that lucky. When c:geo introduced its own formula engine, we thought it would be a good time to align ourselves: Texts will only be interpreted as texts if they are enclosed in quotes or quotation marks. bww("C") = 3, but av(C) would grumble if there was no variable C. With this, however, it is possible that your old formulas with text may now no longer work, which is what constitutes this breaking change.

(Separate posts for the Formula Solver and the Web API will follow)

So what?

Unlike usual, we will roll out the individual versions in stages – due to the size of the update:

• Today, the normal Android version went into public beta. It will stay there longer than usual, because we really want to make sure that we didn’t break something fundamental. I have my reservations about the cooperation of our almost 600 beta testers, but you can still dream 😉
• At the same time we updated the Web version, so that interested people can have a look at the Web API and leave feedback.
• If everything seems fine so far, we can follow up with the Android Gold version in a few weeks. Of course, the Gold users are not disadvantaged and can use the new features in the same way, because they can install both versions in parallel.
• In parallel, we will test the iOS version. Yes, in all these months we haven’t done that yet – we’re simply afraid of it, since we’re all only Android users (at this point, once again, the call: If any iOS user would like to contribute: Always welcome!), and iOS still has its own problems. So the iPhönes will have to be patient a bit longer, sorry 😉

Changelog

Well, and since I’ve already talked too much again: Here is the obligatory, final changelog of the release, in which of course the thousands of bugfixes and small, partly well hidden tool improvements could not be listed individually:

[chg] New internal structure
[new] WebAPI, Deep Links
[new] GCW Script
[new] Number Pyramid
[new] Diplomat License Plate Codes
[new] Spelling Alphabets
[new] Stellar Images
[new] Base64: Detect Files
[new] Least Common Multiple
[new] Greatest Common Divisor
[new] Geohashing
[new] Ave Maria Code
[new] UFI Codes
[new] Unix/Excel Times
[new] Velocity/Acceleration
[new] Calendar Week
[new] Settings: Save/Restore
[new] Keyboards: Smartphone Layouts
[new] Segment Displays Types
[new] Open Map: Lock Points
[new] Units: Acceleration
[new] Coord Measurement: Map View
[new] Formula Solver: c:geo Export
[new] UpDownLeftRight: Diagonals
[new] Symbol Tables
[new] Gade: Export to Formula Solver
[new] Settings: DMM Default Precision
[chg] BREAKING: Formula Solver Texts