raspberry-pi-os VS circle

Last but not the least, learning by doing is fun so you can check out - raspberry-pi-os (writing an os from scratch) - https://github.com/s-matyukevich/raspberry-pi-os

CheesecakeOS for Raspberry Pi Volume 0: Booting, Processes, and Virtual Memory is the first in what I hope is a series of github markdown tutorials or volumes on bare-metal from-scratch operating system development.

I have dreamed of contributing to the Linux Kernel, but have yet to find the courage to jump in and do so. I started by attempting to read Understanding the Linux Kernel by Daniel Bovet and Marco Cesati, but found it was too advanced for me at the time. I found another text I credit with advancing my understanding, Computer Systems: A Programmer's Perspective by Randall Bryant and David O'Hallaron. I worked on the self-study labs from their book website, and found them to be a superb educational tool.

Further, then becoming interested in what creating an operating system actually means, I stumbled upon Sergey Matyukevich's Rasberry-Pi-OS github repo (https://github.com/s-matyukevich/raspberry-pi-os). I wanted to expand on his tutorial, for my own education, and, in the best case, for the benefit of others.

There are many ideas taken from Linux in the implementation, as when I didn't know how to proceed, that is the source I would consult. Though, I attempt to simplify and explain the details in the text. The implementation stops short of implementing or supporting a file system, the subject of the next volume.

Not familiar with this myself but aiming to start soon. Have found a nice youtube series for low level development on the RPi, not sure which version he uses, but reportedly it works for some on RPi 4. He also has a subreddit:

Here's one tutorial: https://github.com/s-matyukevich/raspberry-pi-os

C: Learning operating system development using Linux kernel and Raspberry Pi

> But Safe C++ and Circle are different languages, right?

Eh, bit of a mixed bag, I think, depending on the context in which the words are used. "Circle" can refer to the compiler/toolchain or the set of C++ extensions the compiler implements, whereas Safe C++ is either the proposal or the extensions the proposal describe. As a result, you can say that you can compile Safe C++ using Circle, and you can also describe Safe C++ as a subset of the Circle extensions. I wouldn't exactly describe the lines as well-defined, for what it's worth.

> There are presumably differences between them, and I do not know what those differences are, and I do not know if those differences were documented somewhere.

They're sort of documented indirectly, as far as I can tell. Compare the features in the Safe C++ proposal and the features described in the Circle readme [0]. That'll get you an approximation at least, albeit somewhat shaded by the old docs (understandable given the one-man show).

> I cannot find any occurrences of "reference implementation" in the Safe C++ draft.

The exact words "reference implementation" may not show up, but I think this bit qualifies (emphasis added):

> Everything in this proposal took about 18 months to design and implement in Circle.

[0]: https://github.com/seanbaxter/circle/blob/master/new-circle/...

I made a facetious comment to parry that of pjmlp, whom also made a facetious comment wrt to compiler complexity and what "one person" can do.

https://github.com/seanbaxter/circle

It is like if one tried claiming that Fabrice Bellard was an example of a median dev.

The number of C++ compilers written by one person is one. And because of this, it gives us no predictive power in what pjmlp was trying to assert.

I agree with you, Albert and Lorentz and Riemann got caught in the rhetorical crossfire.

I for one started working on a new project in C++ rather than Rust. I think it's unclear whether Rust is going to be the successor at this point. It's probably never going to pick up in the games industry, QT is C++ (and Rust bindings will always be second class or they could end up unmaintained), has better compile times and is said to be undisputed when it comes to high performance. Obviously the tool for the job factor is most critical.

Career wise, many people are picking up Rust and almost no one is picking up C++, while experienced C++ devs either retire or switch to a higher level language due to landscape change. I would trust supply and demand to be in favour of C++ 10 years from now.

There are also attempts to make C++ more memory safe like Carbon[1] or Circle compiler [2]. If they succeed, why would anyone want to switch to Rust? Also Rust is not ideal for security from a different perspective - I think the lack of a package manager is one C++ strongest points. After working for 9 years with npm, you really appreciate that the dependency you install is usually just a single dependency (even an option for a single header file is common), when there's a package manager, people will abuse it (like install a package with 3 dependencies of its own for something that could be 50 LOC copy-paste) and managing the security of the supply chain is nearly impossible (it will be a legal requirement soon in EU though).

Anyway, I wanted to ask. How is the contracting market looking in C++ world? I'm guessing it depends on the domain heavily? I'm mainly asking about QT and anything that would be desktop / mobile apps / systems programming except video games, but I'm curious in general.

[1] https://github.com/carbon-language/carbon-lang

[2] https://github.com/seanbaxter/circle

This is more or less what Sean Baxter was trying to do with https://www.circle-lang.org/.

Of course, this requires buying into a set of tooling and learning a lot of specific idioms. I can't say I've used it, but from reading the docs it seems sound enough.

Sean Baxter created a front end c++ compiler by himself, using llvm for the back end and the gcc or clang stl. I think it took him a couple of years. https://www.circle-lang.org/. Before this happened I heard a couple of different people claiming that there would never be a totally new compiler as it was too much work.

The real Typescript for C++ is Circle.

https://www.circle-lang.org/

Just like Typescript to JavaScript, the syntax is an evolution of what already exists, not a completely different syntax.

Sean Baxter's Circle [1] is arguably the spiritual successor to MOP.

[1] https://www.circle-lang.org/

Context: https://github.com/seanbaxter/circle/blob/master/new-circle/...

Note that Circle is not an F/OSS compiler as someone pointed out before. This however doesn't make Circle less relevant, because it is actually a testament to show that C++ could have been much better without the claimed breakage. If Circle does provide a number of desirable features and its compiler can be built by a single person, then why shouldn't the committee do the same?

From all wannabe C++ replacements candidates, the only language that is really a TypeScript for C++, is Circle.

For whatever reason, Herb Sutter decided to ignore this language on the presentation.

https://www.circle-lang.org/

This is the only one with the syntax based on C++, incrementally changing the features via #pragma settings.

"Circle Fixes Defects, Makes C++ Language Safer & More Productive"

https://www.youtube.com/watch?v=x7fxeNqSK2k

"Circle Evolves C++"

https://www.youtube.com/watch?v=P1ZDOGDMNLM