Usually, Semplice is run by typing the bare command semplice. However, Semplice can also be invoked with the addition of one of three possible runtime parameters: that is, keywords prefixed with a doulbe-hyphen. These parameters trigger Semplice to do specific things which none of its main menu items allow for. They are not things you would commonly do, which is why no convenient menu options are available to trigger the same behaviour!
The four available runtime parameters are as follows:
Each is tacked onto the end of the normal "semplice" command, so that you might type (for example): semplice --checkver or semplice --debug.
I'll briefly explain the functionality of each parameter now -but the short version is that only --checkver is of much practical use!
Semplice's normal mode of tagging operation is to remember the last tags you supplied. It does this because you might be tagging up (say) both Beethoven's Symphony No. 4 and Symphony No. 5, recorded by Bernstein in 1962 and supplied together on the same hard disk. Doing the first symphony, you'd say the composer=Beethoven, the performer=Leonard Bernstein, New York Philharmonic Orchestra, year=1962, genre=symphonic ...and so on. And all those values would apply equally well when you start tagging up Symphony No. 5. So, by remembering the answers you provided when tagging up Symphony No. 4, Semplice makes it a matter of pressing [Enter] for most of what's required to tag up Symphony No. 5. Here's an example of Semplice 'remembering':
The 'remembered value' is displayed in blue text in this screenshot. It happens not to apply in this case, as I'm tagging up an opera by Ravel, so I type the correct composer name in yellow text, ignoring the blue prompt text, which has been remembered from my last Semplice session, and would apply to the new recording if I just pressed [Enter].
Compare that screen with what happens if, instead of launching Semplice with the bare command semplice, I instead tack on the --cleanslate runtime parameter and then attempt to tag some music with a composer name:
This time, you'll notice that there is no blue text: no composer's name has been remembered from a previous Semplice 'run'. This is what the --cleanslate runtime parameter does: it makes Semplice forget all previous tagging sessions, so that no previous tags are suggested as being possibly applicable to the new bout of tagging you are undertaking.
The --cleanslate parameter wipes all prior tags, not just the composer name I'm showing you here. Composition name, performers, recording year, genre: all are wiped, at a stroke, and without possibility of reversion. Semplice's 'memory banks' will only be replenished once you start typing in new tag values from scratch.
Why would you ever need this capability, to forget prior Semplice session answers? To be honest, I don't know. I can't think of why you'd ever bother using it, since as you can see from the first screenshot above, it's perfectly fine to ignore a 'remembered' answer for any given tag and just start typing your own, newer answer instead. Frankly, I can't even remember what possessed me to write the code that makes this parameter works in the first place! I rather suspect it was simply one of those development issues, where you want to be able to start the program in a clean, known state without prior test runs mucking about with possible outcomes. In which case, it has no practical application to anyone other than myself... but I've left it in there anway!
This is another runtime parameter that no normal person is ever likely to use -but it's definitely there so that I can help diagnose issues when writing the Semplice program code, and work out what's going wrong when a user reports a bug or problem to me. The runtime parameter --debug simply displays all the environment parameters and their values which are being used by the program, derived from settings in the Persistent Configuration File and other environment variables that might be set. Here's an example obtained by running the command semplice --debug:
The screen displays the values certain internal parameters have been set to, usually by means of editing the persistent configuration file. The information displayed is fairly cryptic and is unlikely ever to be useful to anyone who isn't trying to debug the program code! It is unlikely, therefore, that you will ever need to run Semplice with this parameter. Incidentally, when you 'press a key to continue', as the screen instructs, Semplice quits completely and returns you to the command prompt.
This runtime parameter is not only useful, it's practically compulsory to use it from time to time! It's Semplice's way of checking whether a newer version of the program is available as a download from this website's servers. If it detects a new version is available, it will ask if you want to download it and then prompt you to supply your sudo password so that the new download can be installed correctly. You don't need to use this option very often, therefore, because new versions of Semplice won't be released every wet Wednesday afternoon... but you should probably get into the habit of running it every couple of months or so, just in case.
So, here's what you will usually see when you type the command semplice --checkver:
That is, the program detects that the currently-running version exactly matches the version that's available from this website's servers. You would expect this to be the 'normal' state of affairs, 99 times out of 100. But occasionally, you'll see this sort of response instead:
When the program spots that a version number bigger than the currently-running version number is available for download, it will ask you if you want to go ahead and download the newer-version software. You can always answer 'n'o at this point, at which point you'll be dumped back at the command prompt with the message that the program is 'quitting without upgrading'.
If you answer 'y'es, however, then this happens:
You are simply asked to supply your sudo password; the program then goes off to fetch the new software version and installs it without further interaction. You end up dumped back at the command prompt once more. The next time you run Semplice, you should see the version number (in the header area of the program display) has increased from what it was before.
It is important you keep your version of Semplice up-to-date by periodic runs of the program with the --checkver parameter, as it ensures you reveive the latest bug-fixes and new feature releases.
From all that has been written above, therefore, I trust you get the idea that no-one is ever really meant to use the --cleanslate and --debug runtime parameters (though no terminal harm will come to those that dare to do so!) The --checkver runtime parameter, however, is not only useful for the ordinary user... but definitely something that ought to be used every so often, to ensure you're running the latest, most bug-fixed version of Semplice at all times.