Hacker News Reader

Comment by throwaway894345 | Hacker News Reader

This is pretty remarkable and surprising that it's only 5-15% slower. The Go compiler isn't very aggressive about optimizing even ignoring GC overhead concerns. I'm also curious to understand better how they bootstrapped the dynamic memory and scheduling facilities since Go obviously relies on an underlying operating system for these things.

View on HN

I believe the Midori project at Microsoft found similar in trying to write an OS in C#.

Several posts from Joe Duffy, who led that project, are at [1].

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

It's because typically for most applications the OS isn't very much overhead.

If the kernel was only using 1% of the CPU time before, and you rewrite it in QBASIC for a 5x slowdown, your application only sees a ~4% slowdown...

But didn't you just explain why our kernels should be in QBASIC? Or any other safe language? I feel like this is the next version of Christmas not being true. That unsafe languages were a dumb scam.

Most of it comes from a few bad decisions in C in particular that we ended up with stuck for a very long time (nulls, badly designed array type) OSes were written to run on very different hardware from what we use now and over time the hardware was adapted to running specifically C code well. High-level languages like we expect these days hardly existed at all before the mid 90s or so, and they have been gaining in dominance ever since.

You will notice that Go shares some authors with C.

They did the same with C back in the day, versus what was being done in systems programming since the 60's.

The language C builds on, B, is a spin off of BCPL, a language designed to Bootstrap CPL.

Thanks to UNIX's success we ended up with a language whose original purpose was to bootstrap compilers, not to be a full stack programming language.

Here, systems programming in 1961, 10 years before C was born, still being sold by Unisys.

https://en.wikipedia.org/wiki/Burroughs_large_systems

Or at US military,

https://en.wikipedia.org/wiki/JOVIAL

Or during the 70's,

https://en.wikipedia.org/wiki/PL/8

https://www.computerhistory.org/revolution/input-output/14/3...

https://en.wikipedia.org/wiki/Interlisp

https://en.wikipedia.org/wiki/BLISS

https://en.wikipedia.org/wiki/Modula-2

https://en.wikipedia.org/wiki/Modula-2%2B

Remember that project Bell Labs stepped away from, which gave C's authors plenty of free time?

https://en.wikipedia.org/wiki/PL/I

https://multicians.org/myths.html

"Thirty Years Later: Lessons from the Multics Security Evaluation"

https://hack.org/mc/texts/classic-multics.pdf

Future programming historians may indeed look back on Ken Thompson as the Thomas Midgley of the software world, having plagued us more than once with costly and dangerous mistakes: null pointers, C, and the abhorrent POSIX API.

> In 1923, Midgley took a long vacation in Miami, Florida, to cure himself of lead poisoning. He "[found] that my lungs have been affected and that it is necessary to drop all work and get a large supply of fresh air".[9]

Null terminated strings.

In, "Trusting Trust" Ken tacitly admitted that C itself was the inside job. Once you align yourself with Cs core tenets, performance above all else, the game itself is up and your mind has been infected against looking at things holistically.

I’m not sure what you’re trying to tell me but I’m certainly aware of these facts already.

Comments in these forums are directed at two populations, the direct participants and everyone else viewing from the bleachers. I don't think the parent is implying that you don't know these things, but added them for context.

This is true. I got a lot of downvotes for my GP.

That was indeed the case.

> High-level languages like we expect these days hardly existed at all before the mid 90s or so

I beg to differ.

Lisp has been influential since the 60s, especially in certain niches (AI, symbolic algebra, etc.) and is still going strong.

Smalltalk was used throughout the 70s (although first "released" in 1980), and is far more "dynamic" than the scripting languages widely used today (e.g. Python); the classic example is 'ifTrue' being a method call which we can override (via a built-in live editor, no less!).

Prolog has been around for a while, and saw a lot of attention in the 1980s. It's much more high-level than most languages, since its interpreter runs a search algorithm to calculate results, rather than dumbly stepping through a single execution path.

Most of the cool features popping up in "modern" languages, like pattern-matching, currying, (Hindley-Milner) type inference, etc. came from ML in the 70s.

Scheme is also from the 70s, and has features like tail-call elimination which many languages/platforms are still lacking (spawing a whole sub-genre of blog posts about how to implement it in language X via trampolines). Scheme also brought attention to continuations, giving us things like coroutines. The async/await and yield features added to many languages recently are close cousins of Scheme's call/cc; as are try/catch/throw, for that matter! Although call/cc is undelimited, delimited continuations have been around since the 80s.

That's just off the top of my head, wearing my Programming Language Theory hat. If I put on my Hacker hat I could mention Sh, Snobol, Awk, Icon, ABC (Python's predecessor), etc.

I’m aware of all these facts but Lisp wasn’t practical except on Lisp machines for quite a long time, and most of these languages only started running on microcomputers in the mid to late 80s. Caml Light, (Xavier Leroy) the standardization of ML, object oriented scripting languages, etc.

My initial statement was too strong, what I meant to say was that the higher level languages were not practical for commodity application development and distribution until more recently. They’ve been along for a very long time but Smalltalk is an infamously isolated system and it was very slow even when running on an Alto (I’ve used it!). I admittedly know much less about the practical history of Scheme and Prolog.

I think you are both right.

To jolux's point, Scala, F#, Ocaml/Reason, Clojure, Haskell, Erlang while not as huge as Java and C#, they have billions in value attributable to them.

The quoted text says that overhead on the kernel code was 15%, not the application.

iirc they modified Go runtime

Obviously, usually a language runtime expects an underlying OS.

When one isn't available, the runtime plays the role of an OS, and much be adapted as such.

Reply on news.ycombinator.com