I have a problem with modern computing.
these days, I'm seeing more and more programmers promote
languages like javascript or python to folks who just
want to understand how to work with their computer as...
a computer.
this isn't that bad. javascript and python are "okay"
languages. they're pretty easy to work with for learned
programmers. they have easily obtainable environments...
so what's the problem?
in the days of hobbyist computing, we used small systems.
microcomputers. these systems were tightly designed to have
a single language bundled with the system to control everything.
for many microcomputers, this was BASIC. for others, it was FORTH.
or something equivalent.
through these languages, things were.. simple. everything was at
your fingertips. the system was there, in front of you, with
components that could be peeked at and poked at in order to
provide useful functions, such as putting something on screen,
playing a sound, or accessing external peripherals.
if I, as the naive programmer, wanted to do something, all I
had to do was refer to the manual that came with my machine.
there was no documentation other than the manual.
anything else was for me to discover.
and boy, was that fun.
sketching things out in such a basic environment was a lot
of fun. if only for the "what if" moments and the "aha!" that
followed.
I don't see that anymore.
there's a lot of frustration these days. open architecture
led us to want more and more out of the different kinds of
peripherals we could stuff in a desktop box. and we've paid
the price for it.
modern computing is plagued by a city of ivory towers,
each of which is built upon a foundation of quickly evolving
or legacy standards. the operating system has shifted from a
straightforward boostrap environment to a confusing mess
of program code.
I can remember when a single application dominated your workflow.
apparently that's called an "app" now, and only exists on mobile phones.
when a person wants to sit down and write something, sketch, what have you,
they do so in an unbelievably limited environment. the operating system
gives you nothing. the connection to your underlying
hardware is completely abstracted, even in languages like C.
it makes me long for something as simple as BASIC, with all the "ground truth"
that assembly or machine language provides. that what you're doing has a direct
connection with the underlying machinery that you're using.
at the same time, I resent modern assembly/machine language. x86, as common
a platform as it is, has too many different instructions to keep in one's head.
I don't see the reason for this. we built better, faster systems with smaller
instruction sets. but somehow we're here.
that, plus the fact that x86 assembler looks and feels like a completely
different language than the code it's supposed to be representing.
I thought we were supposed to have a 1-to-1 representation of what we write?
guess that failed.
now, take a walk on the weird side. brainfuck is effectively "machine code" for
an abstract processing unit based around vaguely structured programs
(no direct jumps).
it has a set of operations that a novice could fit in their head.
and while it's verbose, and many of the simplest operations take a bit of
working and thinking, it does teach one fundamental lesson.
you have to put in what you expect to get out.
that's the kind of teaching I don't really see nowadays. esoteric
languages are famous for this kind of a push. but brainfuck is a little
more mellow. you have to spend some time and think about how different
instructions can be combined into larger effects. you then build up a
neat little library of tricks that you can use when presented with a certain task.
there should be more languages like brainfuck. languages that encourage a small
number of simple commands. a lexicon that's small enough to fit on a notepad.
something that's easy to digest for the new programmer, but also approaches
programming in a "constructivist" manner, where you build very small working
parts that can be re-used. not functions, not libraries, but small sub-expressions.
C is nowhere close to this. modern languages are nowhere close to this. there's
this stigma that languages like this are turing tarpits and are "unreadable"
and "unusable", but I aim to show that it's possible to develop a language that breaks
both of these stereotypes.
and I encourage you to do the same.
please, let's get back to simplicity. let's get back to understanding what's under our
feet before we go soaring towards the stars, aimlessly flying on a cargo-cult-built ship
that we know nothing about save for "it flies".
please, the next time someone asks you "what language should I start with?".
say "try brainfuck."
cheers,
imode
posted on: 2016-10-27
[back]