
What Is Systems Programming, Really? (2018) - generichuman
http://willcrichton.net/notes/systems-programming
======
streetcat1
If your domain of discourse is the computer itself or the functionality of the
computer in the world (store/compute/ communicate) than it is system
programming. Else it is application programming.

It has nothing to do with the actual programming language.

~~~
tyingq
I think anyone's opinion on what makes something "systems programming" has a
lot to do with what it meant when they learned the term. The quotes from
Stroustrup and Alexandrescu, for example, very much call out language
features.

~~~
streetcat1
Right. They confuse "system programming languages" with "system programming"

~~~
icedchai
There are languages that are clearly better suited for systems programming.
You might call these "systems programming languages." Would you write a file
system driver in PHP?

~~~
streetcat1
Openstack was written in python...

Personally I use go for everything.

~~~
mekster
Isn't garbage collection the problem for being in the system programming?

~~~
pjmlp
No, that is a common myth from the GC-hate crowd.

Here is some stuff to get you started,

"The Cedar Programming Environment: A Midterm Report and Examination "

[https://pdfs.semanticscholar.org/33ff/212245ff8af0359e911883...](https://pdfs.semanticscholar.org/33ff/212245ff8af0359e9118832c9f29ee1fd291.pdf)

[http://www.projectoberon.com/](http://www.projectoberon.com/)

[http://www.ocp.inf.ethz.ch/wiki/Documentation/Front](http://www.ocp.inf.ethz.ch/wiki/Documentation/Front)

[https://www.whoishostingthis.com/resources/modula-3/](https://www.whoishostingthis.com/resources/modula-3/)

[http://joeduffyblog.com/2015/11/03/blogging-about-
midori/](http://joeduffyblog.com/2015/11/03/blogging-about-midori/)

[https://www.infoq.com/presentations/csharp-systems-
programmi...](https://www.infoq.com/presentations/csharp-systems-programming/)

------
lesserknowndan
I think it would be a unfortunate for people to start redefining what "Systems
Programming" means because it is vague enough now as it is - and we don't have
the luxury of being able to go back and update the term in the historic
literature.

My understanding is that, in effect, "Systems Programming" is analogous to
"Operating Systems Programming", or rather you might say (given the increasing
size of operating systems these days) that "Systems Programming" is a subset
of "Operating Systems Programming" that deals with the direct manipulation of
memory in order to provide a useful abstraction for "user" software -
remembering that most hardware interaction is via memory. Obviously, in order
to do "Systems Programming" you need a "Systems Programming Language" that
allows such direct access to memory.

These days, "Systems Programmers" would be those working on the Linux kernel,
or microkernels, or graphics drivers (basically those who have complete access
to memory) though those developing services one layer up might also consider
themselves to be such (especially micro-kernal-based operating systems).

It is probably worth emphasising that "System" is a generic term that is used
in a lot of different contexts. I think "Systems Programming" is used in the
context of a "Computer System", while modern day cloud programming would be
better described as "Distributed Systems Programming" as it is in the context
of a "Distributed System" (though I've probably just annoyed a whole bunch of
distributed systems researchers).

I think that what the author of the article is talking about is "System
Architecture" (or perhaps "Distributed Systems Architecture").

Should we talk about this as programming at all?

~~~
astrobe_
> I think it would be a unfortunate for people to start redefining what
> "Systems Programming" means because it is vague enough now as it is

Indeed. When people call something "systems programming" when it is just e.g.
server programming, it feels like when you are being told that "hacker" means
the same thing as "cracker" because that's what most people think it means.

In my slightly angry opinion, "Systems programming" is one of those terms that
are convenient _because_ they are vague and look cool. The plural on "systems"
is suspicious in itself. It's not just one system they are working on, but
many. Impressive, isn't it? The funny thing is, if you look up the definition
of "system":

 _a regularly interacting or interdependent group of items forming a unified
whole_

... not so many people actually do that. I think programmers usually work on
one thing, one component of a whole system (guess why you are part of a
team?). I'm not sure about how uncommon the opposite is because I actually do
that - I have worked at the driver level, OS configuration level and at the
application level in order to make a product work - and I am not that much of
an exceptional programmer.

------
forrestthewoods
I've primarily writing C++ for over 15 years. I don't think I'd ever heard the
term "systems programming" until the last few years when Rust talked about it.
I don't have a super formal CS education and most of my career has been in
gamedev.

What is sytems programming? I don't know. I don't care either. It's an
arbitrary label that is rarely used and doesn't affect anyone in any way.

------
aazaa
> To summarize, what we call “systems programming” I think should be called
> “low-level programming.” Computer systems design as a field is too important
> not to have its own name. Clearly separating these two ideas provides a
> greater conceptual clarity on the space of programming language design, and
> it also opens the door to sharing insights across the two spaces: how can we
> design the system around the machine, and vice versa?

Alternate definition whose source I can't recall:

Systems programming is everything that isn't application programming.

Maybe it's time to update that with:

Systems programming is everything that isn't application programming or low-
level programming.

~~~
Izkata
So, HTML?

;)

Slightly more seriously, systems programming seems to me to be approaching the
lowest levels, so including "not low-level programming" would give the wrong
impression that it includes the _really_ high-levels ones.

------
whateveracct
Maybe not the thread to post this, but I've seen too often "systems
programming" be intertwined with arrogance and gatekeeping. As if these skills
are special and inherently more difficult to pick up by developers without
them. But tbh all software engineers are programming abstract machines at
various levels. Systems work is just a different abstract machine to grok.

My education is in relevant skills (CompE), but the attitude I keep running
into in this domain has really started to disgust me, even if it isn't
everyone. When it's people I've seen in leadership, that's enough :/

~~~
gdy
"As if these skills are special and inherently more difficult to pick up by
developers without them"

It's because they are.

~~~
pkolaczk
My limited experience with bare metal programming tells me they are not. This
is just a different abstraction layer to learn. Often low level abstractions
are much simpler and less broken than high level programming. Even if
something goes wrong, you can plug in a logic recorder / oscilloscope / led
(!) and in minutes you know what's wrong. But this doesn't work if you have 10
semi-broken layers below.

I have 15+ years of experience in hl programming and almost none in low level,
yet I feel like at home with bare metal stuff. And it is a lot of fun as well.

~~~
gdy
I wholeheartedly agree with you, it surely is fun, especially when it is a toy
project!

As for the systems programming please see my answer to a sibling comment.

~~~
whateveracct
This comment is a lil passive aggressive. "Toy project"

~~~
gdy
It isn't, I meant it.

And you misuse this word, try googling what it really means.

------
s1k3b8
Systems programming concerns the code between hardware and the application
programmer. So pretty much kernel programming.

Application programming concerns the code between kernel and the ordinary
user.

Essentially, systems programmers write software that application programmers
can interface with. Application programmers write software that ordinary users
interface with.

It gets fuzzy at the edges like most definitions, but that's how I think about
it generally.

~~~
vnorilo
I've always thought of compiler programming as systems programming. I guess it
fits your definition of being something application folks interface with in
addition to kernel.

------
Taniwha
It's really (or was back in the day) simply short for "operating systems
programming"

~~~
haecceity
That makes sense. But everything we program are systems so shortening it like
that isn't really helping anyone.

------
kartayyar
One litmus test that a former coworker applied was "how resource constrained
is the application"?

I think conceptually this is a better test, more so than say if you have
access to a raw pointer - because more important parts of how to handle core
issues like scheduling, storage management, concurrency, parallelism and
distributed computation manifest themselves in many forms.

I started my career doing C programming in a OS / kernel environment. In
retrospect a lot of pieces of applications I've worked on are what I think of
as systems, and many parts of kernels are more applications than systems.

~~~
tom_mellior
How resource constrained is the Linux kernel when running on a modern x86_64
machine with 16 GB of RAM? Not very. So is Linux kernel development for this
platform not "systems programming"?

If you're going to say something like "but the kernel should be _fast_ when
servicing syscalls", you are right, but that is not a _resource constaint_ ,
it's a _user requirement_. LibreOffice should also be _fast_ when reacting to
my keypresses, but I hope we agree that LibreOffice development would fall
into the "applications development" camp, if we have to put things into bins.

The truth is, we don't have to put things into bins. There is no need for a
muddy, fuzzy term like "systems programming". If you're doing "kernel
programming" or "embedded systems programming on resource constrained
microcontrollers", you can just say that directly.

------
dang
Discussed at the time:
[https://news.ycombinator.com/item?id=17948265](https://news.ycombinator.com/item?id=17948265)

------
luord
I was really liking this article, until the "dynamic typing sucks" and
"functional programming is the path to enlightenment" stuff came up at the
end.

Specially jarring because it's out of nowhere. That conclusion does not follow
from everything that comes before.

