[GoLUG] Writing an internet server (was: Mailing list, long term.)

[Kyle Terrien]

These kinds of thoughtful exchanges are why I like this list.

On Tue, Aug 19, 2025 at 04:03:00PM -0500, Barry Fishman wrote:
> 
> I think my point of view may be colored by a lack of trust in browsers
> in general and my situation in particular.  Browsers are complex
> programs where the security issues are complex, that requires the
> attention of people writing software for them.  They are in the hands of
> companies like Google, Apple, and Microsoft who have demonstrated a
> desire for profit that exceeds that of their desire to protect the
> interest of their users.  Firefox is a bit better, but to produce a
> browser that meet all the industry set standards and stay in business is
> limited in what they can do.
> 
> Being retired and programming primarily for my own benefit, I don't like
> spending my time writing software who's function is dependent on the
> good graces of an industry that has show very little regard for their
> users desires.

This sums up most of my frustrations with software development at the
moment.  If you develop software, the entire set of APIs you rely on
can be ripped out from right under you, only because some large
corporation decided it’s not enough benefit for them as whatever
newfangled thing into which they wish to throw money.

(Unpopular opinion coming...)

The other side of the coin is with the Scrum salesmen.  No group has
singlehandedly destroyed the software development process more than
overly eager Scrum consultants.  (This is not a rant against agile
development practices, or even scrum-like processes when they are
appropriate.  This is about Scrum being used when it shouldn’t.)
Instead of focusing on vision and planning, now the vast majority of
software orgs are obsessed with cranking out a small change every two
weeks.  Without the long term plan, it is difficult to measure if that
two week increment is forward progress or backward progress.  Software
engineers are demoralized from the lack of vision and stressed from
the two week arbitrary deadlines.

> Python is community (although I don't tend to use it myself) which
> has shown a strong desire to make its users welcome.  Even when they
> make a fundamental change like Python2 -> Python3, they don't suddenly
> withdraw the previous version, or remove functionality from the
> language.  Looking at their APIs, I find them to be very well
> designed.  
> 
> Even Gnome, which I have many differences, at least seems open about
> what they are doing and where they are headed, and their software base
> is far easier (for me at least) to look at the code and workaround any
> problems than that of any of the browsers.  I still disagree with a
> great many of their decisions.
> 
> Some people here feel that they are overly influenced by companies like
> RedHat, but I think they suffer more from the Silicon valley mindset
> with their perceived meritocracy and single minded lack of consideration
> of other points of view.

Red Hat bankrolls Gnome and many other platform level components.  Red
Hat’s political sway is the reason we got systemd instead of runit as
the /de facto/ init system for GNU/Linux.

Silicon Valley mindset is an interesting theory.  They do seem to
share the pride aspect.

> And a sand-boxed crypto-miner, or DoS agent might not change files on
> your computer but I still class a security issue.

Also, that’s the #1 reason for running a so-called adblocker nowadays.
A more accurate term is malicious script blocker.  Some of these
adware JS libraries redefine core library functions to hook in their
own code (and for a while they engaged in a game of leap frog to
disable JS libraries of competing adware companies).

Sure it’s sandboxed, but why waste time and energy?  Why would you let
a horde of orcs hammer on the walls of Helm’s Deep when the Ents can
come and eliminate the orcs?

> Python does have the issue that all extendable interpreted environments,
> in that it does require careful user setup.
> 
> This is mostly avoided when you install all the required parts with you
> distributions package manager, but when you use things that are not in
> the package manager things can get more complex.
> 
> I'm not sure of the current situation is with Python, since I don't use
> Python very much, and use NixOS where the situation is quite
> different. The Free Desktop solution with its ~/.local, ~/.config/ etc
> setup work well with packages and distributions that use it.  I know
> that some programs are distributed as zip executable that seem to work
> just fine.  I did that a long time ago.

Outside of NixOS, we have venv (for sandboxing) and pip (for package
management), and the biggest problem is that people don’t know how to
freeze their Python dependencies to do reproducible builds.  But
that’s not a Python problem.  That’s a problem of bad programmers.

The Python side of the problem is that Python itself subtly changes
its core library APIs between point releases---the primary reason I am
still looking for a good Python replacement.  Sadly, many modern day
languages and tools seem to forget they are platforms and change
things arbitrarily.

> Sometimes what drives someone to write code is that although other
> solutions exists, they tend to be far too complex or involved to want to
> use.  One would have to spend time working around issues in an existing
> code base that you are not familiar, rather that on thinking about what
> you really want to do.

There is so much old cruft nowadays that I am beginning to wonder if
we will need to build a new libre computer architecture, all the way
down to the CPU and firmware.

People are giving up.  Think about how many websites you use on a
daily basis which are broken or fragile.  This kind of stuff really
bugs me as an engineer, because my job is to solve problems not create
them.

> I was a enthusiastic C++ programmer, but when faced with some basic
> programming problems it became clear it was a language problem, not a
> coding problem.  I learned to code around them, but it felt like a hack.
> 
> I began looking at Common Lisp, and learned how these problems were done
> in that language.  It changed my feelings about C++ completely.

I really want to look more into Emacs Lisp, Guile, and the Lispy
languages, because from the outside looking inward, they did solve a
bunch of problems in very well-thought-out ways.

> For example I am writing this in a Emacs text window, which as a part of
> GNUs, is made into a reply window with its own extra functionality.  It
> then has some additional functionality I have wired in from other
> packages, some not distributed with Emacs.  Even though they are layered
> they are still separate and don't usually interfere with each other.  It
> like object oriented class hierarchy.
> 
> For example, my code (via the Corfu package), as I type it often suggest
> completions for the word I am typing in dynamically changing popup
> window which appears just below (or above) where I am typing.  Being a
> bad speller I have enabled this functionality.  I can ignore the window,
> or just hit tab and select the current option.  Or using the up and own
> arrows move around in the popup list of words, select another word and
> use that.  The interaction takes a bit of getting used to.  This is a
> bit like the mobile phone keyboard widget that continually suggests
> completions.
> 
> If you find this annoying in Emacs, as I sometimes do, Your can shut it
> off at any point in time (and later turn it back on).  Of course by
> default the mode is never turned on, you have to choose it.
> 
> The choice is mine not the Emacs main developers.  Many of them hate it.
> They might never have conceived of doing it but someone saw the
> possibility and implemented it.  It also used the popup functionality of
> another package, although you can provide a different means of
> displaying the options such as another Emacs buffer.

I am also writing this from within Emacs.  🙂

A little aside about the philosophy behind extensions, how it has
changed in recent years, and Firefox:

Emacs is basically a well-maintained and still relevant
retro-computing environment.  (I can’t remember who told me that, but
it’s a decent observation.)  Like you pointed out, every piece of it
is extensible, and 3rd party code can hook in and extend the editor in
any direction a developer wants.  No one writes computing systems like
this anymore.  You want a new mode?  Start with an existing mode and
define the pieces you want on top of it.  After 30-40 years of that
process, we have an entire IDE and computing environment for
programmers by programmers.  The really cool part is that Emacs is
much lighter and much faster than any other modern IDE.

However, most corporations which maintain the platforms don’t like 3rd
party code that can hook in to any part it wants.  There are various
reasons for this.  The #1 truth is always control.  The #1 lie is
“security.”  Big corps want the software to earn them money, and so
reducing support footprint always helps.  So, they setup limits and
throw just enough bread to keep people complacent.

A good recent example is Firefox, unfortunately.  You used to be able
to write XUL overlay extensions, and you could hook anywhere you
wanted, and if you wanted you could add an entirely new feature to
Firefox.  (E.g. Chatzilla added an IRC client.)  Moreover, an
extension was a first class citizen in the browser code.  It ran in
the same context as the browser code.

Enter Google Chrome, and a change of management at Mozilla around
2012.  Chrome started to eat Mozilla’s lunch, and the best idea the
new management at Mozilla could conceive was to mimic whatever Chrome
did.  Things came to a head around 2016-2018, when Mozilla decided to
block XUL overlay extensions and only support sandboxed WebExtensions.
What are WebExtensions?  Why, WebExtension is a special Google API
(designed for Chrome) that lets a browser run an extension in a
sandbox.  Much like how Newspeak in George Orwell’s 1984 decides what
you can and can’t think, the WebExtension API decides what you can and
can’t do with a browser extension.

It was an obvious step backward and met a lot of resistance.  If you
had code that did not translate into the limited WebExtension API,
then tough noogies!  Big corp loves you.

Meanwhile, the user got a sub par experience.  The primary reason for
using Firefox was because Firefox extensions made the browser much
more useful than Chrome.  Firefox was always slower than Chrome, but
the fact you could program it to do your bidding made up for the
difference.  In their pursuit of the mythical “target user”, Mozilla
forgot that, and now Firefox usage share is below 5%.

Things get even fishier if you follow the money.  Mozilla gets $500
mil / yr from Google for setting the Google search engine as the
default.  So, they are very nervous about the pending antitrust suit
with Google.

/Requiescat in pace/, Mozilla Firefox.

Anyway back to Emacs...

Thinking about it, it seems almost a miracle we still have a computing
environment which is still extensible in the sense that anybody can
bolt his own module onto it and the module runs as a first class
citizen.  Nobody writes computing systems like this anymore.  I hope
we have Emacs for many years to come.

Freedom is not free because we must defend it, and unfortunately
liberty dies with thunderous applause.

> If I was into AI, there are AI plugins that will come up with what words
> or phrases to put in the popup.

I want this feature in Emacs.  I’m sure it exists or someone can write
it easily because all of these coding assistants are still SaaSS.  I
always bring it up to people who tell me I should be “using AI” to
write code, but the reaction is usually, “Oh, those Emacs people hate
change.”

Instead, the “AI Vibe Coding” plugins most of the AI advocates rave
about are entire IDEs forked from VSCode.  Now, I have never used
VSCode because Emacs is pretty good.  However, the forking problem is
apparently so bad that Microsoft has made it difficult to impossible
to install certain Microsoft VSCode extensions on forks of VSCode.
There is a whole battle to have the most mindshare, because mindshare
means profit.

It’s like having one billboard after another shoved in the face.

> But the fact that it may seem hard for new users does not mean the that
> experienced users should not have the ability to use it.
> I am not a meritocracy believer who feels everyone who doesn't spend their
> time learning a system does not deserve consideration.  But I don't feel
> that because most people find it hard, it shouldn't be made impossible,
> or even extra hard to do.  And its existence does not keep others from
> using simple editors

I agree wholeheartedly.  You should not ban experienced users from
doing things that seem hard for new users.  Computers are tools, and
as a master of the tool, I should be able to conform the tool to do my
bidding.

Unfortunately, most people have been trained into thinking a computer
is like a refrigerator loaded with delicious snacks.  I suppose you
can blame Microsoft et al with their “computer literacy” classes
(which were really just training sessions for their products).  It is
a diabolically clever plan on behalf of those who wish to profit from
mass mediocrity.

Right now, the entire technology industry is obsessed with one metric:
screen time.  If an application keeps the user on a treadmill
interacting with the application, then the application developer has
done his job.  That’s why we have such crazy timesinks and
psychological problems now, because the software is psychologically
manipulative.  In that regard, these such apps qualify as malware,
because they are malicious to your psychology.

As my priest recently commented during a sermon: “Control your phone
or it will control you.”  It’s a good thing I removed all that malware
from my phone, and my real computers run GNU/Linux.  It’s not perfect,
but at least I have more control over it.  I regularly hear my friends
who run inferior systems complain about malicious features being
forced upon them.

Computing is less fun than it used to be, unfortunately.

> Note that neither Gnome nor KDE allow Emacs like key bindings in their
> text windows.  But both MS Windows and Apple do support them.  Gnome did
> up to version 4, but actively removed the code and made it difficult to
> add it back in.  I could add the code in myself but it would involve
> replacing the whole GTK4 library package, and on an invariant OS systems
> like mine, having to rebuild all of Gnome from scratch.  GTK was built
> on a great and very flexible object model, which made moving it from
> Gimp to build a general window system was possible.  Gnome has since
> then systematically pulled out features that they had used to do that
> port.
> 
> They say that the code makes it more difficult to build the window
> system that they are designing.  If people are given this kind of
> functionality it will make supporting the functional they want all Gnome
> users to use harder.  In some sense it does.  But the cost is their code
> is less useful to others.  They want their Window system easier for
> their perceived new users.  My impression is that people coming from
> Windows tend to choose KDE over Gnome partly because its more familiar,
> but mostly because it easier to modify to make it like they want.

This is where I have to pick on Gnome, which is unfortunate because I
do like them, and I do like how they really want to create a nice
design and sane defaults.

Gnome’s vision ever since 2011 has paid attention to their developers
but ignored their users who just want a stable desktop.  That’s fine
if the project is in active development, but it wasn’t.  Gnome 2 was
pretty good and solid.  They should have used a new name and went hard
on marketing their new desktop as the next big thing, because they did
get some things right, like how quickly you can launch any app with
nothing more than the keyboard.

Somewhere in the past few years, Gnome decided to change the design of
their desktop again.  I was running several addons just to keep things
sane.  They prioritized changing things arbitrarily over fixing bugs.
Over in the Funtoo project, we lamented how we were picking up more
regressions each time we upgraded GNOME, until we gave up on upgrading
it.  Why upgrade if you get a new set of bugs instead of fixes?

I ran Gnome in Debian and Ubuntu for a while, but it’s still the same
pattern.  They change the design radically, just because they want to,
and I have to adapt and update my configuration.

So, I’m back on XFCE.  It’s simple, it’s customizable, it’s popular,
and they haven’t changed their design radically in decades.

> KDE makes it easy to change its behavior.  But it doesn't seem to have a
> simple way of undoing a set of changes, or even snapshot the current
> setup so you can restore it latter, or move it to another computer.
> I had a friend who invested a lot in tailoring a KDE4 environment the
> way he liked it.  When KDE5 came out he was very reluctant to use it
> because he would loose all the effort he put into his KDE4 environment.
> 
> Gnome does have the ability to snapshot your configuration into a single
> text file, and restore it onto another system, or restore a system you
> have messed up.  I don't use that facility but have a set of "gsettings"
> shell commands and procedures that I use to make my usual changes to
> Gnome.  Its like editing the Registry in MS Windows.

Yeah, KDE doesn’t have a good way to kopy settings around.

For Gnome, I went as far as defining dconf layers in text files.
Documentation was a little thin, but once I got it working, it was
amazing stuff.

https://github.com/KlipperKyle/dotfiles/tree/master/dconf/db/local.d

https://help.gnome.org/admin/system-admin-guide/stable/dconf.html.en

Once you drop things in /etc/dconf/db/local.d, you need to make sure
it is listed in /etc/dconf/profile/user and then run ‘dconf update’ as
root.

On XFCE, we have xfconf-query, and everything is stored under
~/.config/.xfce4.  So, I suppose it is possible to seed a config from
an existing configuration.

-- 
[*] Kyle Terrien
    Terrenus => from the Earth, to the Cloud
    https://terren.us/

Dilexisti justitiam, et odisti iniquitatem.  -- Psalmus 44:8