have been following the development of several different programming environments, but not so much with Qt/KDE and C++ in general, because of maybe irrational disagreements with the grammars and complexity of the compiler.

I started out learning how to code originally with BASIC, when I was 8 years old, on an 8 bit TRS-80 with MS Basic (2.1, I think it was), and by the way things were back in those days with the lack of a GCC compiler (at least, me not having access to USENET or an intel based processor computer) I spent a lot of time exploring languages that generally tend towards being clustered with the BASIC side of language types (by this I include also languages like Pascal, Python, Modula 2, Oberon) and it was quite some time before I really got much chance to learn C.

I wrote a Mandelbrot set generator, in Turbo C, back in the day, and it was quite exciting for me to have some time to access a laptop with an amber plasma display, that had a 387 floating point processor, and I used K&R's book to figure out how to translate my BASIC version of this simple program, to target C and the graphics library - I forget which - that let me see some really fast processing.

On my Amiga 500, it could take as long as 5 minutes to draw a view of the set, the more I zoomed it, of course, the bigger the iterations had to be to get a sharp boundary of the black region of infinite iterations that generates this famous mathematical object. On the 387, it was under 2 seconds.

Computer Language Theory

Anyway, I spent more of my time reading about languages and especially books about methodologies and models than coding, basically, and I read books from back in the heyday of Computer Science (the late 80s-early 90s) about refinements and developments in different types of programming languages. I did even start to try and write a python-like language that used whitespace structure - this is how my favourite language of all time back then, Amiga E, was structured also, using a book about compiler writing and language design, using Bison and Yacc and some other tools.

So, to sum up, I am very interested in the subject of computer language theory, but especially about issues like documentation, code readability and security against common bugs being built into the grammar of the language or in the compiler and generated runtimes. Correctness is a subject I am very interested in, and it is my view that the more cumbersome a language is to read, the harder it is to avoid serious logic errors that often also become vulnerabilities to exploits.

My explorations of possible systems programming systems for projects

A few years ago, after my first foray into the Blockchain world in 2013, I started to come up with ideas for blockchain architectures, and when I was able to sit at a computer and have a go at writing some code, my first issue as a long-time-out-of-the-loop aspiring programmer, I did quite a bit of exploration. I mean, I had looked at Qt, because I remembered quite liking KDE in version 1 when I first finally had a PC running linux (Red Hat 5.1) in 1998.

I also encountered GNOME, and its first iteration was pretty terrible, second version was better, but a few years ago as I was looking at my options for programming environments, I discovered that GNOME 3 is very very nice indeed. Not just a bit less memory intensive, but also very pretty, and with an interface that is only bettered by Android and Windows 8+ for coping with HiDPI displays.

But more than this, even since GNOME 2, it has had a very comprehensive event callback system which enables handy things like configurations that instantly apply, but is of great relevance to any software project, which especially with network based applications, are by their nature event driven.

My early ventures into coding applications

At first I was just tinkering with building GUI applications using Gtk+ 3, and I learned about Vala, which is a lot like C# - implementing OOP and Functional Programming features by using GLib and GObject and generating instead of assembly or binary code, it generates compliant GCC code. I have done a fair bit of code in Vala, and interspersed with that, Python, and though I did not in my own experience conclusively decide whether I liked Python's approach versus Vala, whenever I code in Python, I am always cursing not having access to the convenient anonymous function, as some callbacks can be incredibly simple and really don't warrant writing a whole function to implement it.

But it's not a dealbreaker - I prefer the readability of whitespace structured code. Python is just far slower than compiled code.

Enter Vala and Genie

For anyone who also likes non-C-like programming languages, especially ones like Python and Delphi, you can now use much of these grammatical structuring notations like these languages, but produce very tight code that is nearly equal to pure C, but with simple management of memory with almost completely automatic allocation and freeing of resources, as well as a strong type checking in the compiler, which is also enforced within the GLib and GObject libraries at runtime (as well as, introspection, which back in the day used to be called 'reflection').

The Vala compiler includes a second language called Genie, and you can find a good introduction to its grammar and syntax at this page:

https://wiki.gnome.org/Projects/Genie

I have up to this point avoided really digging into Genie, because there is not a great deal of documentation, or example code, but the compiler is stable as is the language specification, and because I was focusing on Gtk+ 3 applications.

But now I am wanting to write network database type applications, Genie, like Vala, includes always GLib and GObject libraries, which the equivalent in the C++ world would be like having Boost++ integrated into and implementing most of the language's constructs (GObject allows introspectable objects like how Python allows introspection of objects, allowing easy runtime changes of both code and objects, without the complexity of self-modifying code).

The other advantage of Vala/Genie is that it is not difficult to integrate any C libraries into it, the variable and function and class definition stubs just have to be written into Vala grammar, and by this, valac, the compiler, can then address these libraries correctly. At present, there is a pretty comprehensive set of library interfaces and for most tasks no new one needs to be made.

Digging into the Genie

I am commencing a second, more serious attempt at tackling the learning of this language, and further developing my ability to design and structure programs correctly. I want to also learn to document my code well.

There is a great inertia in the software industry towards new programming techniques and languages, partly because of the cost of maintenance of code and documentation. The majority of developers of systems and performance critical applications have a familiar set of tools, but these tools are much more cumbersome than, in my opinion, they have to be, and the opacity of the language grammar and excessive but not beneficial flexibility of these systems just makes them produce code that is harder to fix.

It should be a rule in programming, like the inspiration vs perspiration principle:

Good software is 1% good ideas, 2% coding, 7% debugging, and 90% maintenance.

Maybe it's Pareto distributed, and 80% is maintenance, and 20% is building it (including design). The design is very important - it should focus also on the facilitation of the most work involved in the life cycle of software. The more a system can be broken into smaller, simpler parts, the easier it is to isolate problem areas, as well as extend, and the most frequently executing code is profiled and optimised, when the design is modular, it is easier to eliminate side effects in algorithms, which increase with complexity of code.

Well, that's my opinion anyway. YMMV.

---

We can't stop here! This is Whale country!