It's been a while since my last posting and I feel compelled to say some things as well as introduce everyone to my curses project.
Saying some things...
... to those whom I've not responded too in a while.
I have struggled my whole life with mental-illness of varying forms and degrees of symptomatic expression. I've thought I was bipolar, schizophrenic and/or manic depressive at various periods of my life. This past near-decade has been a ramped-up roller-coaster of traumatic levels of my problems. COVID has nothing to do with this. I'm a very private person in general and self-isolation has never been a real issue.
What is an issue is how sensitive I've gotten about what people say to me and how easily the thought process can spiral out of control and curl up in the darkest recesses of my mind. It makes me positively crazy and I know it has nothing really to do with the person speaking to me at the moment and everything to do with what happens in my brains.
I've adopted a general case of monk-like silence with pretty much everyone in my life, family included. This has proven wonderful in terms of alleviating anxiety and keeping me sane as I work on this journey within. This means I've not been responding to calls, texts, emails or even reading social media at all unless it's my mom or ultimately an imperative at the time.
This is not to say I don't like you, that I don't love you, that I don't respect you. Not at all. This is to say that I've now applied an alternate approach where I'm saying that I do like me, that I do love me and that I do respect my self in addition to loving you all unconditionally. My self has been crying out in pain and swimming in stress while my mind's "I" has been clinging to the "man's man" persona and just plowing forward with brute force. Brute force proved to be a tremendous error in judgment and I implore all male-identifying people to not fall for the trap of being a "man's man". That world, the old world, the frat-boy status quo, all that needs to die a quiet death. Just stop it. Listen to your self, your gut, your heart, your two hemispheres and all the nervous systems holding you together - not what the bullies in life try to hammer into you.
So, without this turning into some lengthy diatribe on my mental-health practices and personal world view, I just have one thing to say to the people who may or may not feel dropped or ignored from my life: I still love you, please allow me the time to heal, without grief, and learn the lesson of why I'm still alive.
Okay, so that's a little dark, talking all about the curse of my mental-illness and such... Let's move on to something not so dark...
A long time ago I even wrote a perl module UI::Dialog to automate tasks and generally make my life and the lives of co-workers easier. I still use this library to this day, however, there are limitations and drawbacks. I can't just design a customized UX per-application as they're all driven by whiptail underneath.
So, I decided to make a GTK-inspired curses perl module and that died fast. I just didn't have the steam to pour into a language that is fading in popularity with the new coders out there.
Then Go appeared in my life and I gave birth to my setlist generator project. I've always envisioned this ideal of having one formal UI library that works on modern desktops with GTK and seamlessly works in pure console environments where X is not present and all the widgets are entirely curses based versions of their GTK counterparts. Given that I needed to learn Go more and not get too complex, I settled on just implementing the GTK interface for the setlist project.
In the time since my last posting, I'm happy to say that I've actually built something entirely new that feels old. CTK. The Curses Tool Kit is not finished at all of course as this is a monumental hill to climb alone, however I'm happy to report that I finally got to a stage where I'm comfortable with publicly sharing the code. Will I support this code long-term? No idea (and yes I'm a fan of cleaning house on things I won't maintain for others). As it stands this thing is entirely an intellectual curiosity and deep dive into writing something big in Go. So why does this new thing feel old? Because when you code up a hello world... it feels distinctly GTK-ish in respects, which to me feels old because I'm used to coding GTK (in c, perl and Go).
Take a look over the README files for the two main libraries in the Go-Curses project space if you're interested in seeing actual code. For this posting, it'll just be screenshots and words describing things instead of a line-by-line walkthrough.
The first and main example, is a very simple program that displays a button that when pressed will exit. See the Programming Hello World in CTK section of the CTK README file. It looks like this:
Nothing really special in actual functionality, however, in order to display this content a whole slew of things had to be implemented. There needs to be a Window that contains everything. That Window needs to have a VBox to organize and contain things in. There needs to be an Alignment widget to center the button in the view and of course there's the Button itself which uses a Label and various Signal handlers to do things like exit the program when the button is clicked. Read the example code in the repo for more details as I've basically done a line-by-line commentary of what's happening and why.
The Curses Development Kit isn't something that is intended to be used directly, however, I needed to write some examples in order to test that layer of things while developing. Necessity drives invention and nothing says necessary like making some thing to say "Hello World".
Now, while CDK does in fact have it's own Hello World example, that's not the
one I'd like to mention here. Rather, there's a second example called
appserver and that one's the one I think will help demonstrate the bizzare
things one can do with these kits.
appserver works like this. Clone the CDK repo and
cd into it. Then run
make examples and if the stars have aligned, two binaries should have been
In the current terminal session, run
./appserver and you should see something
like the following screenshot displayed (and updating the timestamp every second
or so, not exact but roughly close enough). This invocation is what we'll call
the "Server Side", which is clearly labelled at the top of the screen.
Now, start up a second terminal session and this time lets login to the
localhost with port
2200. There are two possible
users to use:
foo with password
bar with passwod
$ ssh -p 2200 foo@localhost
Neat! If we take a look at the server-side session again we can see that there's a client connection being reported.
Ideas that go "curses!"
Now, the above examples may not do much, however they are in fact clear proofs
of the concept. For an example idea for an
appserver based thing, an
interesting one would be to write a system for managing a WireGuard VPN in a
weirdly secure way.
admins login to an
appserverand configure things, make new users, etc
- admins can see active users, system resources, network traffic or whatever people think would be cool to include in the application
users login using
sshas well, configure their things like passwords etc
QR codes would be dynamically served by an internal
httpservice with one-time passwords for the
config-zip-thing is also served via the internal
httpsof course), so that users can easily setup the VPN on their phones, tablets, laptops, desktops, etc
- could roll the entire project into a simple go binary that enables terraforming a remote host over ssh to get things started as well as manage the entire remote host in a pleasing curses way
the curses desktop
How about a little bit of insanity that may in fact be the sanest choice in some
cases... an appserver that is really a curses desktop environment where each new
client session is being used like a secondary monitor is used by X11, it extends
the space available. This could be implemented locally via IPC or remotely via
ssh connections. Add a WindowManager to CTK and now we've got a curses
Would anyone need this? Like for real? Sure! Why not in industrial control systems, embedded assembly line touch-screens, or any number of niche situations where the encumbrance of a full graphical environment is overkill or worse entirely cosmetic in it's necessity for being. Using Android for such things may be a "good idea" though I suspect it's a recipe for security issues, upgrade path problems, hardware support problems and so on.
Sometimes curses can be a good thing.
This wasn't as long as I'd thought it'd be. Groovy.
Thanks for reading!