Name: Anonymous 2013-10-07 3:37
/prog/, about five to seven years ago I was a fairly normal
programmer. I dabbled in Java, Sepples, even tried out some
functional languages. Then, about four years ago, that changed. I ran
into a bad experience with the JVM and resolved to stick to C in the
future. I decided to actually buckle down and know a language,
so I started reading through the standards. But I didn't like seeing
justifications of ``in order to support construction X, we chose
semantic definition Y''. So I restricted myself to C89, seeing it as
the least twisted.
One or two years later, I became irritated when dealing with a GTK+
application which crashed whenever the gtk-toolbar-style was
not GTK_TOOLBAR_ICONS, I decided to forswear any library in my
own programs whose source was too vast for me to read through and at
least nominally understand. This has, thus far, restricted me to
ncurses and scanf for user interfaces, though I have been looking at
FLTK a little.
A month ago, I was struck by the thought that, given the age of
applications we currently use, it is quite possible that source code
we write today may be adapted/used in the inevitable transition from
Earth to space, and possibly to the stars. Yet with this comes the
dangers of radiation which currently impose strict hardware
limitations. So I was just firing up qemu to emulate a 486 to ensure
that the program I was writing would run smoothly. ``It will be a
good habit to get into,'' I told myself.
Last night, I began implementing some of the networking features of my
program, and I thought that in the future, the speed of light might
become a significant factor , and that I should examine it with
wireshark to ensure I was only sending packets that I absolutely
needed to send, and began doing rough calculations of how much of a
CPU/Network tradeoff I could take by doing a rudimentary Huffman
encoding before sending my data to the network.
At this point, I realized that I may be stepping beyond the bounds of
sanity. I'm writing a stupid fucking program to play user-configurable
chess-variants over a network. I don't need to make sure my program
will survive circum-solar routing 2268 taking place outside the Van
Allen belt. I don't need to be evaluating each of my dependencies to
estimate whether they will break dependencies in timespans measured in
centuries. I don't need to transcribe my source code to MMIX to ensure
that it will remain readable for the future.
What's happening to me, /prog/?
programmer. I dabbled in Java, Sepples, even tried out some
functional languages. Then, about four years ago, that changed. I ran
into a bad experience with the JVM and resolved to stick to C in the
future. I decided to actually buckle down and know a language,
so I started reading through the standards. But I didn't like seeing
justifications of ``in order to support construction X, we chose
semantic definition Y''. So I restricted myself to C89, seeing it as
the least twisted.
One or two years later, I became irritated when dealing with a GTK+
application which crashed whenever the gtk-toolbar-style was
not GTK_TOOLBAR_ICONS, I decided to forswear any library in my
own programs whose source was too vast for me to read through and at
least nominally understand. This has, thus far, restricted me to
ncurses and scanf for user interfaces, though I have been looking at
FLTK a little.
A month ago, I was struck by the thought that, given the age of
applications we currently use, it is quite possible that source code
we write today may be adapted/used in the inevitable transition from
Earth to space, and possibly to the stars. Yet with this comes the
dangers of radiation which currently impose strict hardware
limitations. So I was just firing up qemu to emulate a 486 to ensure
that the program I was writing would run smoothly. ``It will be a
good habit to get into,'' I told myself.
Last night, I began implementing some of the networking features of my
program, and I thought that in the future, the speed of light might
become a significant factor , and that I should examine it with
wireshark to ensure I was only sending packets that I absolutely
needed to send, and began doing rough calculations of how much of a
CPU/Network tradeoff I could take by doing a rudimentary Huffman
encoding before sending my data to the network.
At this point, I realized that I may be stepping beyond the bounds of
sanity. I'm writing a stupid fucking program to play user-configurable
chess-variants over a network. I don't need to make sure my program
will survive circum-solar routing 2268 taking place outside the Van
Allen belt. I don't need to be evaluating each of my dependencies to
estimate whether they will break dependencies in timespans measured in
centuries. I don't need to transcribe my source code to MMIX to ensure
that it will remain readable for the future.
What's happening to me, /prog/?