Elongated Systems Description

First, for purposes of this document, I define a complex (elongated) system as one that requires several discrete processes (often running but not necessarily concurrently)  to coordinate and produce a result.

For example, in the 90’s I developed a system marketed by IBM as Remote Operator that allowed an operator on a DOS based PC to connect to and ‘run’ a remote computer running a custom operating system (Flex OS) via SDLC protocols. In its most elongated configuration, the PC connected via 7 intermediaries for a total of 9 computers end to end.

In more a more recent example, I work on a system to analyse banking systems and derive the data flow (lineage) through static analysis of the source code.    This requires several layers of processing where each layer produces results processed by the next layer.

These systems never work first time.  In order to understand the points of failure it is necessary to see intermediate results in a side-by-side view or even a side-by-side-by-side view.  As such, abundant screen pixels make creating these views easier.

For these reasons I have devised methods to configure multiple screens with KVM (keyboard, video, mouse) switches that employs multiple CPUs (which isolates systems and reduces interference and disturbances). This is described in detail in KVM Configuration with multiple mice and displays

Once multiple systems are being used it is convenient, if not necessary, to be able to clipboard copy text from one system to another. The NetClip Utility implements such a facility.

Elongated systems typically involve many lines of code in various languages spread across many modules.  I found jEdit to be an editor that is up to the task.  In particular, with the Eclipse interface I was able to create, I ended up with the best of breed in both compilation and editor technologies. This is described in Entering the Best Editor Fray

Entering the Best Editor Fray

It has been 3 years since I posted.  I was surprised to learn that in that time I have written over 300K lines of code in a dozen or so languages (mainly Java, Javascript, HTML and CSS).

I have also moved from MultiEdit (used for 20+ years), UltraEdit (7 months) to jEdit. Hands down, jEdit is the best editor I have ever used having been written by a community of programmers for a community of programmers.

My typical code/compile/test cycle is accessed via windows ALT-TAB which switches me from jEdit to Eclipse, F5 to compile, ALT-TAB to a PowerShell window where I type r to repeat the previous test. This means a code-change/compile/test cycle is often achieved in under 30 seconds depending on the complexity of the test.

I have used Eclipse as a compiler for about at least 10 years but always found the editor lacking. Once I had switched to jEdit I was intrigued by the possibility of building an interface so that jEdit could be informed directly about compilation errors.  The git repo jEdit-Eclipse-Interface provides the building blocks to allow this to happen.

With this capability my productivity increased enormously (no longer did I have to type line numbers to get to errors).  In essence in Eclipse I had the best compiler technology:

• fast - achieved through great dependency checking
• thorough - I have warnings fully enable which catches many many errors at compile time (for example I use private on method implementations so Eclipse warns me if I am not using some code)

and with jEdit the best editor for editing program code:

• incredible hypersearch
• markers
• column editing - I cannot work without this
• macros - I am able to enhance at will 
• community plugins (used several out of the box such as auto-save)

Admittedly, Eclipse has a great find facility and because it understands the Java code it has opportunities to do smart refacturing and code completion. However, the lack of column editing and a macro facility makes Eclipse for me a non-starter.

With jEdit's macro facility I was able to quickly add:

• smart cut/copy/paste (default is to copy line) (15 mins)
• class extraction utility to extract inner classes, display on alternate screen (1 hour)
• HotJump, HotBack - go to method/class implementation and back (20 mins)
• Account System interface (4 hrs, saved 4 hrs first year).
• Single-key cut/copy/paste (jEdit code changes also, 1 day).

These macros and others are available at the same git repo jEdit-Eclipse-Interface.

KVM Configuration with multiple mice and displays

This document describes a technique not found in the KVM manuals to control upto 9 systems with 1 keyboard, 3 displays and 3 mice.

I use StarTech.com KVMs.  It is essential that they can be daisy chained.

The KVM-middle is the ‘controlling’ KVM and the keyboard is used to control it.  The CPU- middle has its own mouse and display.

The KVM-left and KVM-right will always have an active CPU which will show on the display and the respective mouse-left and mouse-right will be active.  (It is surprising how many activities just need a mouse).

For my KVM the switch code is CTRL-CTRL 3 (middle CPU) or CTRL-CTRL 2x or CTRL-CTRL-1x where x is the CPU address on the right or left. This switches the keyboard to the CPU.  In the case of the right or left bank of CPUs, the CPU will also be switched if it is different.

I recently purchased a 34” curved screen for the middle display.  This gives me in total 74” of linear screen space.

This configuration I find ideal for working on the elongated systems I develop.

I can readily see and compare multiple probe points in the system being developed as well as view the code that is being developed.  Typically the right screen shows the source data, the middle screen the code and the left screen the resulting data.

The NetClip utility (Git NetClip) lets me copy text from one screen to another, often with just the mouse.