Comment by pmoriarty | Hacker News Reader

Comment by pmoriarty | Hacker News Reader

It looks like this is not a pure Go implementation:

"We originally implemented these functions in pure Go and tried to force reads and writes through empty C calls as Go does not have the volatile key word or an equivalent for our needs as far as we know. This resulted in strange behaviour: while initialization seemed to work, including the corresponding register getters and setters, the program failed later when the NIC never set flags that were necessary to continue. We invested a lot of time in this specific problem but could not find a reason for this behaviour. With the help of cgo, which enables the use of C code in Go programs, we imported the corresponding functions in device.h alongside log.h of the original C driver and replaced our go functions. This fixed the aforementioned problem though we never were able to provide an exact explanation due to limited time constraints."

It's still an interesting effort, and it makes me wonder if we'll ever see a day when a significant portion of Linux is written in a safer language.

Actually cgo, had some performance issues. Whenever a call to C program is made from go program, there is lot of work needs to be done.

Go authors have thought to do initialization and set up the work for only once, but I don't think it is implemented yet.

> It's still an interesting effort, and it makes me wonder if we'll ever see a day when a significant portion of Linux is written in a safer language.

I really hope Ada makes a comeback, especially in commercial kernel programming.

We can start with nodejs. Nodejs with async model will be the best solution to achieve the best performance(after 'delete spaces' method of course).

Performance isn't an issue with C code. Security is.

It can be. Unless one resorts to macros, templates are usually faster.

Everything can be an issue everywhere. No one will choose Node JS over C to counter performance.

No, but one can get code to perform as fast or faster than C with any other systems programming language, especially if they have templates/generics.

The libuv library Node makes us of for handling async calls is written in C.

It's not a problem. The main problem is the assembly code. There is no way to inline it in JS code. After boot time system should make some things like A20, enable paging/protected and long mode, build GDT/IDT.

Right, but my reply to the parent was that Node isn't a performance improvement over C because it has async, when the async part is written in C. JS popularity has led to some wild claims. Never thought I'd live to see the day someone proposed a JS runtime would be more performant than C for writing operating systems.

Someone suggesting re-writing the Linux kernel in nodejs may be a strong contender for Peak HN

Why Linux? It's a simple hybrid kernel. It will be better to rewrite HURD/L4.

What's your opinion on Rust? It seems to be successfully filling the niche Ada could not, even if Ada's problems were more political than technical.

I hope Rust or Rust-like languages make it into the kernel, but I think it's worth noting that a huge problem right now is the toolchain and its dependencies. Go may have a better story here though I wouldn't bet on it being a more likely choice for kernel mode.

What is the problem with the Rust toolchain?

Same question: I am not sure go has solved the dependency problem at all.

When I said dependencies, I was not referring to dependency management. I was referring to the footprint of the toolchain. I'll reply to parent on what I meant in more detail, though.

Ok! I see. Yes that is true. Thanks for the clarification.

Nothing at all, really, but kernel developers are going to be picky. For example, does LLVM target all of the architectures Linux supports today? Also, I think it's hard to sell Rust as a hard dependency of the Linux kernel when it isn't nearly as widespread as almost every other kernel dependency.

I also sorta remember some kernel developers (not necessarily Linux) making a fuss about rustc using a huge amount of address space and not working on 32-bit systems for that reason - although frankly, I can't remember where I read that and I'm starting to question how much I'm misremembering there.

> I also sorta remember some kernel developers (not necessarily Linux) making a fuss about rustc using a huge amount of address space and not working on 32-bit systems for that reason - although frankly, I can't remember where I read that and I'm starting to question how much I'm misremembering there.

You might be thinking of Theo de Raadt: https://marc.info/?l=openbsd-misc&m=151233345723889&w=2

Yep, that's exactly what I was remembering. Though I disagree that rewriting coreutils in Rust is a good place to start, there are definitely some valid points in there. I wonder if the i386 situation has been resolved at this point.

I doubt the Linux kernel will ever allow non-C code, so the toolchain is not really a concern.

And I hope other projects don't trade off safety/productivity/etc. for portability to obscure hobby architectures.

Well, if you want to be pedantic, there's already non-C code in the kernel, it just doesn't make it into the runtime. I've seen Linus's opinion on C++ in the kernel, but I've never seen anyone explicitly state that no other languages would be accepted. I'm sure that it's something that's always possible even if very unlikely right now.

Blanketing every architecture LLVM doesn't support that GCC does an "obscure hobby architecture" is not really a great way to look at things imo. I haven't looked into it but I'm pretty sure outside the bubble of desktop computers there are plenty of important uses of Linux on less common architectures, I would assume mostly embedded systems.

I'm not a kernel programmer, and I haven't used Rust before, so take that into consideration.

Some of my favourite things about Ada is it's approach to concurrency, which (I think) is far superior to other imperative concurrent languages like Go. We should never have to deal with low-level primitives like semaphores and mutexes - it's 2018! Why are we stuck in the 80s?

I've heard that concurrency is difficult in Rust, but I've never used it, so I can't comment. I plan on learning very soon!

We should never have to deal with low level primitives like functions and variables - it’s 2018 why are we stuck in the 50s?

That is an incorrect analogy. Semaphores are the "goto" statement of the concurrent world.

Semaphores are not typed. They is no semantic connection to the thing they protect. Debugging concurrent systems with mutual exclusion enforced through these low-level primitives is a nightmare.

If you forgot to lock/unlock, you'll never know! The compiler cannot check it. Deadlocks are imminent.

We've had better abstractions since the 80s. Conditional critical regions, monitors, and (ideally) protected objects. Hell, even guards are better than semaphores and mutexes - at least they are associated with their critical region!

I struggle to think of situations where a semaphore is the best choice. Maybe in extremely high-performance cases, but even then the compiler can usually make a better decision.

Well, Alan Key pretty much said that in the 70s, and has stuck to his high level guns all this time.

Interesting comment...considering concurrency in Rust is significantly safer to do.

This is the whole point of the borrow checker which is to ensure data-race free code.

The story with concurrency is still being worked out with async server-side applications which is coming together swimmingly!

> This is the whole point of the borrow checker which is to ensure data-race free code.

That's awesome! I never knew Rust had safer concurrency. I'm quite keen to learn it - just waiting for the time.

Not sure why I'm downvoted for this. I struggle to think of a "modern" imperative language that offers similar levels of safety and concurrency, aside from possibly Rust. Erlang is fantastic, but not imperative.

Go has channels, which is nice enough for message-passing behaviour, but nothing for elegantly sharing memory. ("Share memory by communicating" doesn't always work)

Things like conditional critical regions, monitors, and protected objects are much better abstractions for concurrency.

> I struggle to think of a "modern" imperative language that offers similar levels of safety and concurrency, aside from possibly Rust. Erlang is fantastic, but not imperative.

D

Doesn't D just have message passing & mutexes?

Which is fine, since D is supposed to be a better C.

I wouldn't consider its concurrent primitives comparable to Ada. This is to be expected, since I don't believe they aim for such a nuanced level of concurrency. The Ada runtime is incredibly huge and complex - it was created by the US military, after all.

One of the talking points of Rust is fearless concurrency.

Concurrency in Rust is not difficult (neither complex nor error-prone), but you have some high-level primitives that you must know how to choose and use.

More likely to see something like Redox take off.

Reply on news.ycombinator.com