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.