The Intertwingularity of Donald J. Trump's Impeachment

Alan Dershowitz:
"If a president does something which he believes will help him get elected in the public interest," he said, "that cannot be the kind of quid pro quo that results in impeachment." So any abuse of presidential power designed at least in part to aid his own reelection is not impeachable.
Me: instant intertwingulitis.  From the intertwingled mess in my head:
Capitalism has failed such a large segment of the American population, that these folk have decided to throw democracy out of the window in favour of authoritarianism.  
I've long believed that democracy cannot be forced unto other people/countries.  It has to happen organically/naturally, sometimes (sadly) by conflict/revolution. 
What we seem to see unfolding in this trial-that-isn't of the Don is a revolution to bring about the end of democracy.  That has to be the weirdest thing I never imagined would ever be possible:  the strongest proponent for democracy, the beacon of democracy, becoming the poster-child for failed democracy. 
Long live King Trump ? 
America, it was a nice experiment while it lasted ? 
Trump sure knows how to run a reality tv show. 
As the Stomach Turns ...

The Intertwingularity of the Coronavirus

When I hear about the virus, or see a headline, I can't stop it.  Instant intertwingulitis.

Our planet was so perfectly designed. the land divided into continents with large bodies of water.  Making it difficult for deadly diseases to travel from one continent to another, protecting human populations in all other continents from the misery suffered by the human population of another.

I guess misery really does love company.

Us.  Such an intelligent species, yet at the same time so dumb.  We just can't seem to stop ourselves from creating our own misery.

We nullified a natural barrier between populations, and made it easy for viruses to have a world-wide reach.

With all the technology we have today (digital connectivity, virtual reality, you name it), one would think that it would be so easy to allow human connections and virtual exploration/experiences while taking advantage, again, of the natural barriers between populations .

More money to be made, I suppose, by quickly and freely moving people from continent to continent, and treating the threat of deadly viruses as just a business cost.

I say all of that after seeing on the news that countries are evacuating, bringing home, their citizens who currently find themselves in Wuhan, China.

Aside from praying for the folk who have caught the virus, I pray that all these folk leaving Wuhan, passengers and flight crews, are swiftly quarantined when they get home.  I like to think countries will do so, but we can be a pretty dumb species at times.

Although I understand the compassion and patriotism of bringing home our citizens (one for all, are for one), I can't help but think: wouldn't it have been safer to leave them there?

Then again, maybe the virus really isn't that big a deal, maybe health organizations have command of the situation?  Maybe it is just easy to overblow concern because of how the media presents the information?

Meh.  Not that I worry about any of it because I have no control over it.  As per the awesome expression: not my circus, not my monkey.

How one thought leads to another thought, and another one, to infinity and beyond.  Makes for interesting intertwingularity mapping.

Software Development, IDE's, and "code folding"

My career, since '95, has involved enhancing, maintaining, and supporting one very large system built with OpenText's © Gupta Team Developer (owned by various entities over the years, and going various names such as Centura Team Developer and Gupta SQLWindows.)

I first experienced Gupta SQLWindows, way back in 1993, while on a work term during my university years.  It was love at first sight: SQLWindows naturally allowed for organizing code, as it has since inception (late 80's? early 90's?), in a way that accommodates my way of thinking, in a way that facilitates slicing and dicing intertwingularity (while minimizing bouncing around the source code and maximizing ability to see any small bit of source code within a greater context.)

Looking around at the current state of IDE's (aka "Integrated Development Environments") in other products, I find myself really exasperated at how, thirty plus years later, none of these other IDE's come anywhere close to the quality of the IDE in Gupta Team Developer (or even the quality of the IDE in SQLWindows of old.)

In particular, I am really disappointed at how other of today's IDE's provide poor implementations of "code folding."  From Wikipedia:
Code folding is a feature of some text editors, source code editors, and IDEs that allows the user to selectively hide and display – "fold" – sections of a currently edited file as a part of routine edit operations. This allows the user to manage large amounts of text while viewing only those subsections of the text that are specifically relevant at any given time. 
Identification of folds can be automatic, most often based on the syntax of the computer language in question, indentation, or manual, either based on an in-band marker (saved as part of the source code) or specified out-of-band, only within the editor. 
Many editors provide disclosure widgets for code folding in a sidebar, next to line numbers, indicated for example by a triangle that points sideways (if collapsed) or down (if expanded), or by a [-] box for collapsible (expanded) text, and a [+] box for expandable (collapsed) text. This feature is commonly used by some computer programmers to manage source code files, and is also frequently used in data comparison, to only view the changed text.
Code folding provides immense help for an intertwingulitis sufferer such as myself, the kind of help well described further down in the Wikipedia article:
Most basically, applications use code folding to outline source code, collapsing each block to a single line. This can be only top-level blocks like functions and classes, nested blocks like nested functions and methods, or all blocks, notably control-flow blocks. This allows one to get an overview of code, easily navigating and rearranging it, and to drill down into more detail as needed, without being distracted by other code. Viewing-wise, this allows one to quickly see a list of all functions (without their bodies), while navigation-wise this replaces extensive paging past long functions – or searching for the target – with going directly to the next function.

Let's compare !

From OpenText's "Developing with SQLWindows" (Gupta Team Developer version 7.2):
SQLWindows represents the entire application in the outline. Each line in the outline is called an item. To see the entire outline, click the highest-level item in the explorer tree and then click the Outline tab on the right.  For other items, the Outline tab presents that part of the outline that corresponds to the selected item.
An item can be a parent item or child item. Outline items can be nested. Therefore, some items can also be both child and parent items. A parent item has a solid diamond that signifies that subordinate child items are indented below it. If you double-click, the items expands and the child items appear. Double-click again to collapse the item and hide the child items. An item with a hollow diamond does not have child items.

While most decent IDE's out there can handle one-level code folding, seemingly none of them can handle "nested folding" anywhere near as elegantly as Gupta Team Developer.  For example, in this Visual Studio .NET screengrab from a YouTube video circa 2017:

Well, all of that really is in the eye of the beholder.  The kind of folding we see here in Visual Studio .NET may very well suit the great majority of developers out there, but that kind of folding does not float this aging kid's boat as he's frantically trying to plug them intertwingularity leaks...

So yay for nested folding that reduces visual clutter !

Hmmm.  Me thinks I just wrote a mild-mannered rant.

Sidetracked by some hobby programming

When everything always seems deeply intertwingled, I think it healthy to throw one-intertwingulitis-suffering-self into a hyper-focused activity without a buffet of interconnections to parse through.

After my last post, I finished coding my version of the vintage Acey Ducey game without that mess of GOTO's (i.e. well-structured programming code.)

Not having quite gotten my fix (reliving BASIC programming fun from my long-ago teenage cutting o' my teeth), I decided to tackle another programming challenge by creating a "GOTO-less" version of the classic "Amazing Program".

After about 20 minutes of burning out a few brain cells while attempting to figure out pure GOTO insanity, I decided that my mental health matters too much to me: I instead decided to study "Prim's Algorithm" (as explained by Jamis Buck), and build a SpiderBasic app from scratch.

Good times !

Aside: major props to the GOTO wizards of old, because they were doing some pretty wickedly wild stuff that really couldn't be done any other way.  Very impressive, but just not the kind of "brain-age" game struggle that floats this kid's canoe.

If you are looking for a little bit of fairly mindless clicking, then from me to you:

Acey Ducey (like the vintage game, not playing the dealer, but rather just betting based on your two cards and the chances of the third card falling between your two cards.)

A Mazing Program (currently very simple, good enough for printing and playing the maze by moving a dot.)

Basic Programming: GOTO Intertwingularity

Back when I was 12 years old or so, my grandfather bought me my first computer: a Commodore Vic-20.  My joy of programming started back then with the Basic programming language.  (Thank-you Grandpa!  I miss you and Grandma, my "Mamie and Charlie", something fierce.)

Although any programming since (during my post-secondary studies and on-going profession) has remained a solely career-related activity, I've found myself recently interested again in hobby programming and a return to my roots with the Basic programming language.

Since I'm a Chromebook user at home, the following products have really hit the sweet spot for me:

  • Fantaisie Software's SpiderBasic
    • Although I appreciate the simplicity/minimalism of SpiderBasic, I am particularly fascinated by a Basic for the web (i.e. creation of web/iOS/Android applications via a Basic that compiles to javascript)
  • Benoît Minisini's Gambas
    • We could say this is like a "Microsoft Visual Basic" for Linux, but I don't think that does Minisini's Gambas any justice.  This is a "Rapid Application Development" Basic for Linux that works A-1 on Linux(Beta)-enabled Chromebooks.
  • Microsoft's Small Basic
    • Although designed for kids, the kid-like and fun-loving side-of-me appreciates the superbly designed online gem something silly.  Microsoft did a truly wonderful thing with Small Basic. 

All of that aside, I've been having some fun over the past couple of days converting some Vintage Basic source code for "Acey Ducy" to create a SpiderBasic version.

As I studied the original few lines of source code, I found myself bouncing around because of the large number of "GOTO" statements.  Mildly frustrated by the bouncing around but mostly forgiving (familiar territory from my Vic-20 experience of the 80's), I wound up hearing myself saying: man, this is some intertwingled mess.

Lo and behold, my first intertwingularity sighting happened in the 80's as I dealt back then with "GOTO intertwingularity" !

For the $hit$ and the giggle$, I've decided to highlight/diagram the "bouncing around" in the vintage source code, just to show the complexity in understanding the program flow:

Click here to view the full-size Google Drawings document.

I'm sure Ted Nelson never planned on anybody appropriating his terms "intertwingularity" and "intertwingled" for this kind of context.  I hope he and any of his followers forgive me a little bit, because:

I see intertwingularities everywhere,
and they don't know they are intertwingularities ???