I’ve just redone my code signatures today.

One of the habits which I have in my life is, first to undertake a programming project, then to make sure it works, and finally to post some of it on my blog, where I can tell people ‘what I did, to make the project work’. As a result, some of my postings point to a ‘binaries page’, which has the following URL:


What gets shown is a table of contents, from which it’s virtually impossible to intuit what each compressed file is actually about. However, individual posts which link there, usually state, which compressed file resulted from the exercise.

Later, I got the idea to compile some of those projects, on behalf of readers who may not know how to do so, AND, to compile a subset again, to run under Windows.

What makes this tricky is the fact that, under Windows, people like me are obliged to put code signatures onto executables. My code signature only identifies me positively, as the author of the program. It doesn’t, by itself, guarantee, that the user won’t get the scary Windows defender message, when he or she double-clicks on the file-icon.

What makes this even tricker with the type of certificate I chose (to use, to sign the .EXE Files), is, that each certificate expires after one year. Even if readers did download the bundles before yesterday (May 12, 2021), the code would absolutely refuse to work, after May 25 this year. Thus, I need to buy a new certificate, and anybody who might want to keep using my programs, also needs to re-download them.

As of today, I have re-signed all the .EXE Files, with a newer certificate, which will ‘only’ expire after May 13, 2022. So, my readers may proceed, if they have used my program(s), and wish to continue doing so.


(Update 5/14/2021, 14h30: )

Just to be exact, the certificate which I actually used, has the Serial Number ‘154a757a67e7fd31188adce1474afadc‘.




Improvement in my ability to compile code.

One of my practices on this blog has been, to compile certain programs for use either under Linux or Windows, depending on which compiled binary gets used by my reader, to sign any Windows .EXE Files, but only to be able to generate such Windows executables, if they did not have a GUI – i.e., if they were meant to be used in text-mode only, from a Windows command-prompt.

One reason for this has been, the fact that I was teaching myself the Qt5 GUI library, which is cross-platform, but which requires software beyond Visual Studio to compile on the Windows platform I’ve been using, just for such projects.

Ideally, I’d be able to write a Qt5 application once, and then compile it separately, for use under Linux or Windows, and on top of that, to put my code signature on the Windows executable.

Well, I’ve gotten closer to this objective, by means of brute force. I’ve installed the Qt SDK for Windows, in a way that parallels my installation of Qt development packages under Linux. I am able to transfer the source code, and then compile it on the other platform.

Once again, the URL at which my list of potential binaries resides, is:


And the 4 new additions, which did not previously have Windows executables within, are:

  • ‘Creator_Test3.tar.gz’
  • ‘Creator_Test3.zip’
  • ‘Dirk_Roots_GUI_1.tar.gz’
  • ‘Dirk_Roots_GUI_1.zip’





A Basic Weakness, in my Polynomial Roots Finder (Resolved).

One of the subjects which I’ve written about often is that, in the past, I wrote a program which approximates the roots of polynomials, and more recently, that I wrote a version of the same program, that has a (Qt5-based) GUI – a Graphical User Interface. AFAICT, both versions of the program seem to work fine. The GUI version additionally displays a plot of the polynomial.

Note: Polynomials of a degree greater than 4 generally don’t have exact, algebraic solutions – with some exceptions – so that their roots are usually best found by numerical approximation.

Because I’ve published all the recent versions of this program on my blog, I also retest it thoroughly, with polynomials that I know will give it some difficulty each time. And what I have found was that presently, the simplified plotting window has a behaviour that is not false, but that may be difficult for the user to understand. This is less than ideal, because the purpose of that plotting window is, to make the polynomial which the user entered easier to understand, and not harder.

The problem manifests, if the user enters a polynomial that has exactly one root, or that has the same root with some multiplicity. In that situation, my plotting window will assume that the interval on the X-axis to be displayed, deviates from that root by ±0.25, which is also the smallest interval its internal logic allows it to display. While what it displays is not wrong, the very narrow range can make it hard to read:




Here, I’ve used an established Computer Algebra System, to construct a polynomial that has a root of (0.5), with a multiplicity of 8. It’s a polynomial of the 8th degree. Its behaviour near (x=0.5) is the same as what the behaviour would be, of x8, near (x=0.0). In other words, the Y-values never get big, because, to raise some small fraction (x <= 0.25) to the power of 8, will always produce some even-smaller fraction.

But what the plot does non-ideally, is, to centre at (x=0.5) in this case, and only to cover the interval from (x=-0.25) to (x=0.75), as described above. The user must then read from the bottom of the plotting window, that the X-Tick-Interval is only (0.05), and must recognize that the plot is indeed centred at (x=0.5), 4 ticks after the labelled tick at (x=0.3). In this example, it’s easier to read the text-form of the solution.

The reason why my program does this, is the fact that its auto-determined interval spans the range of roots, adds some small fraction to that positively and negatively, but that in this case the spread between the roots is zero, because there is only one. And, I refuse to make the minimum span ±1.0, because some polynomials may in fact have roots closer together than that, which might also need to be plotted…

This program can be found at the following repository on my site:


The source code can be found in the files:

  • Dirk_Roots_GUI_1.tar.gz
  • Dirk_Roots_GUI_1.zip

And an AppImage can be found in the file:

  • Dirk_Roots_GUI_1-x86_64.AppImage


(Updated 9/04/2020, 15h40… )

Continue reading A Basic Weakness, in my Polynomial Roots Finder (Resolved).

I have now created a GUI version of my polynomial roots approximation program.

One of the facts which I had blogged about some time ago, was that I had developed a program that approximates the roots of polynomials, the intention being that it be used on polynomials of a very high degree, by entirely numerical means. And I did this with the knowledge that polynomials with a degree greater than 4 have no exact, analytical solutions, except for certain special cases.

I think that maybe, one reason why some readers were disinterested in that program, could have been the fact that it was entirely command-line driven. So, what I have now done was,

  • To convert the core program into a truly object-oriented format, so that it could act as a module within some other program, and no longer have its own ‘main()’ function, And
  • Applied what I’ve taught myself about the Qt5 GUI Library, to design a minimalistic GUI for it…
  • One of the things the GUI now does, in addition to just listing the roots as text, is also to provide a rudimentary plot of the polynomial each time.
  • One thing which the GUI version can no longer do, is to accept complex coefficients from the user. The command-line version was able to do that. But the GUI version can still find all the complex roots, given some luck.



The AppImage can be found at this repository on my site:


The relevant file is named ‘Dirk_Roots_GUI_1-x86_64.AppImage‘. It will only run under Linux, unfortunately.