What is a high-level language?
This is an episode of Thoughts on Functional Programming, a podcast by Eric Normand.
We've all heard the term high-level language. Initially, it referred to the step from assembly languages to compiled languages. But it has another definition, which has to do with how well the language lets you think.
[00:00:00] What is a high-level language? Hello, my name is Eric Normand. And this is my podcast. Welcome. So.
[00:00:13] I've heard. Discussions about, uh, the term high-level language. Someone in a talk I watched recently said, oh, "C and other high-level languages". And. Then the speaker was like, "Whoa! Oh, hold on a second. C is not a high-level language. It just isn't." Um,
[00:00:38] And the person looked kind of surprise, but also like, oh, I shouldn't have said that because that wasn't my real point. Anyway, the use of the term high-level language, and the way this person who's asking the question with using it, is different from the [00:01:00] way that, that I think the speaker was trying to encourage its use. So let's analyze the first way. Uh,
[00:01:10] If you go back in time, to early computers, you had to program them with machine code. And then there was assembly. And then there were what were called the high-level languages. Okay. And this started with FORTRAN and and continued on until today. So there's kind of a.
[00:01:35] Continuity of high-level languages starting from Fortran in the fifties, going until now, like there was no, like, extra high-level language, you know, there's no other step. Once you get to C or FORTRAN, like you're in the high-level languages territory, um, which is kind of unfortunate, right? That they use this term high [00:02:00] level language. It sounds like the end.
[00:02:02] It sounds like, oh, we're at the height. We got it, right.
[00:02:06] The way the speaker was trying to use the term was in a different way, and it's not quite clear what way that is. It seems more like a way to disparage C than anything else. Uh, C for being like low level, I guess, but I've been thinking a lot about it and regardless of what the speaker meant by it, I was thinking what I mean by it. And, to me, a high-level language is one you can think in.
[00:02:45] Okay. And it gets complicated. We're going to go there. But for right now, I think that a lot of the, the reasoning behind thinking about high-level languages is that you can think about the problem more, you spend [00:03:00] more time focused on the problem, less time focused on the details of the machine and how to make the compiler happy, how to make the the software run the way you need it to.
[00:03:19] And so in that sense, it is a spectrum. Okay. It's a relative term, high being a relative term. So high-level language. When you think C is not a high-level language, he's saying, "It's not very easy to think about the problem." And C , unless your problem is moving pointers around, and, uh, making a link list or, you know, something like that, uh, then it's not really a great language for thinking about your problem. If your problem is, simulating, the dynamics of [00:04:00] an ecosystem or something. Like, it's not the right language to do that in. It's not going to help you think about that problem.
[00:04:09] Other languages are better for thinking more about the problem. And, you know, one of the big improvements that we've had for languages to make them higher level is, uh, automatic memory management, garbage collection, or reference counting. And that really helps not have to think about those low level details.
[00:04:36] Because when you're thinking about the ecosystem of an ocean, you're not thinking about freeing your memory, and when two pointers, you know, go out of scope, and things like that. You want the system to think about that while you think about fish.
[00:04:59] So. [00:05:00] I guess my advice is when you're evaluating a language, uh, you can think about it: Will this language make it easier to solve my, my domain problem? Or will it simply give me a lot of homework to do, to eventually get to my. Domain.
[00:05:26] Uh, and then further, I want to take it another step, which is that I think the language is important, but as we get into, you know, larger systems, distributed systems, those problems, the problems of, you know, distributed systems, message passing, concurrency,
[00:05:52] synchronization of different services, those things start to dominate [00:06:00] again. Just like memory management dominated our thinking. Where we're using a lot of our brains thinking about queues and locks and promises and things, and are we thinking about our domain enough?
[00:06:18] Uh, so what, what do we need? What's the solution? Is it to, to make the problems go away? Make the compiler help us with the problems? Maybe the language, the semantics of the language, the execution semantics of the language could help us.
[00:06:39] So that's just an open question there. I'll leave that up to you.
[00:06:44] Well, I'm going to wrap it up. My name is Eric Normand. This is my podcast. Thank you for listening. And as always. Rock on!