39 ms·

Fuchsia is not Linux

• mankash666 9y ago
  Google clearly has a LOT of cash to play with. They could have refactored/re-used the permissively licensed BSD core, but ended up re-inventing the wheel, breaking a TON of POSIX based software. For what benefit exactly?
  • tpush 9y ago
    ??? The whole point of this OS are concepts like capabilities that aren't represented in POSIX interfaces.
  • tmikaeld 9y ago
    Complete and total lock-in?
    • jasonvorhe 9y ago
      That must be why the code is on GitHub.
      • martin1975 9y ago
        So is Linux' code, except if you try to redistribute it by linking to it, you'd have to disclose your mods. Not so with Fuchsia's license. They can push out proprietary code all they want.
    • martin1975 9y ago
      They certainly picked the correct license to do just that. GenodeOS has exactly what they needed on a formally proven kernel. Why didn't they use that? NIH syndrome... that's why. And of course, control.
  • lainga 9y ago
    Promotions at Google are based on quality of implementation, not original ideas.
    • forgottenpass 9y ago
      The history of chat products out of google shows that it's about quantity, not quality.
      • calebh 9y ago
        Yup, I'm wondering how many more days Allo has to live. I don't even bother with the proprietary Google messenger apps anymore because I know they'll be killed within a couple years or less.
  • butterisgood 9y ago
    I'm sure people said that about Bell Labs and Unix too.
  • mtgx 9y ago
    I read in an older article that POSIX software compatibility may infringe on Oracle's copyrights. Maybe that's why?
    • AdmiralAsshat 9y ago
      Making a piece of software that follows the POSIX standard, a term that Richard Stallman came up with, runs afoul of copyright? That would seem like a massive slap in the face to the cause of freedom, if so.
      • sp332 9y ago
        It would be ironic. But RMS only proposed the name, not the standard itself.
  • izacus 9y ago
    There's nothing implying that Google wants to make a POSIX compliant OS. Why do you think that's important for a Fuchsia type project? The other huge Google OS (Android) doesn't benefit from POSIX either at all - the POSIX interface isn't even exposed to the user applications.
    • saagarjha 9y ago
      Well, not the full POSIX interface. Bionic does expose a significant portion, though.
      • pjmlp 9y ago
        It is not part of the official NDK APIs, use it at your own peril, regarding NDK lockdown. ANSI C and POSIX do overlap, but aren't the same thing.
      • izacus 9y ago
        In NDK yes. Those aren't really as fully compliant as we'd wished (and differences in implementation are sometimes really annoying to deal with). Nevertheless, vast majority of applications will never include NDK code and even if they will, they probably won't really talk to POSIX calls directly either. For the type of OS Android is, it doesn't really gain anything by being POSIX compliant far away from developer APIs. And Fuchsia, if anything, is trying to be an Android type OS.
    • mankash666 9y ago
      Well - requiring basic frameworks to be re-written for your vanity-OS is the fastest path to irrelevance. Most libraries and frameworks (from curl to zlib/git) assume a POSIX interface. If Fuchsia doesn't care about these fundamental utilities being functional, then that's a flawed assumption regarding the developer ecosystem
      • saagarjha 9y ago
        Assuming Google is even targeting the developer ecosystem here. I'd assume that most of the users of Fuchsia will be end users, so that's what Google is targeting.
  • forgotmypw 9y ago
    For the benefit of one or a few individuals "burning through a lot of cash", "spearheading the effort", and "padding their resume(s)".
    • mankash666 9y ago
      I don't know why they down-voted you. The pitch, if any, for fuchia, wouldn't stand muster outside Google. Clearly, some folks benefit from "burning through a lot of cash", "spearheading the effort", and "padding their resume(s)"
      • tomc1985 9y ago
        Why not? Many are tired of Linux's constant convention thrashing. I would love to reimagine Linux minus all its ancient, historical cruft. Yes there's BSD, but it is nice to have another take.
        • mankash666 9y ago
          I don't know if you see the irony in your arguments. You demonize capitalism in another comment to me, and argue here that another take that requires a LOT of funding is a "nice to have". Do you realize that this "nice to have" is made possible by the deep coffers of Google, whose existence is owed to capitalism?
          • majewsky 9y ago
            Non sequitur. Capitalism is not the only (possible/existing) deep-coffer generator. See China.
          • tomc1985 9y ago
            Yeah I'm not really agreeing with ya there. Whether its put together by Google, or the community, or whoever, really doesn't matter. Yes in this case it's Google, who does exist due to capitalism (not exclusively due to capitalism, though, as other systems work in other countries), but then capitalism is not the only economic or political system that produces 'deep coffers'. And this 'nice to have' is not build-able exclusively by Google. By your logic anyone born to a family where the parents have U.S. employment would owe their existence to capitalism. Does that instinctively seem correct?
  • amaccuish 9y ago
    Umm, with android apps being written in java, I don't think most developers or users worry about POSIX, and Linux isn't fully posix anyway.
    • saagarjha 9y ago
      > with android apps being written in java Many Android apps drop down to the NDK, where POSIX does matter. > Linux isn't fully posix anyway It's close enough that the difference really is just an issue of not getting certification.
      • pjmlp 9y ago
        From POSIX, only the thread APIs are officially supported on Android. Everything else on the NDK has nothing to do with POSIX. https://developer.android.com/ndk/guides/stable_apis.html https://developer.android.com/ndk/guides/stable_apis.html
    • tracker1 9y ago
      Not to mention other higher level languages that have an abstract for io. (libuv in node and elsewhere for example)
  • wbl 9y ago
    Better security model when number of users per system is less than unity.
  • mkozlows 9y ago
    The "wheel" is 40 years old. It's a great wheel, it's doing a hell of a job. But with 40 years of perspective, maybe it actually can be re-invented better without carrying around a pile of legacy back-compatibility needs.
    • JustSomeNobody 9y ago
      > The "wheel" is 40 years old. It's a great wheel, it's doing a hell of a job. But with 40 years of perspective, maybe it actually can be re-invented better without carrying around a pile of legacy back-compatibility needs. Newer is rarely better. Besides, in computing, so many "new" things are just rehashes of old (and not so old) ideas. I really wish we could get away from the "that software is old" meme in this industry.
      • jay-anderson 9y ago
        Old software often had requirements or made design decisions based on assumptions that aren't true anymore. These can make it more difficult to deal with or extend. I agree that in general we should just use the old software that works. However big projects like fuscia can reap some long term benefits. In the end it's a cost/benefit analysis to decide.
        • gnufx 9y ago
          Well, the context that shaped old software has a habit of re-appearing, so the design decisions/trades-off may have become relevant again at least once since. The first vectorized code I saw was a relic from a long-gone Cray 1.
      • IshKebab 9y ago
        What? New software is usually better, or do you think people never improve anything? That just makes no sense.
        • JustSomeNobody 9y ago
          Of course software improves. The context was BSD, Posix, etc are based on 40 year old tech. Those systems got a lot right and it takes a hell of a lot of hubris to think just because it’s 40 years old it is somehow not good anymore.
  • willvarfar 9y ago
    Google invest heavily in securing computing generally, from creating the secure browser Chrome because the alternatives at the time were very insecure to a big paid team of security researchers (recent successes include discovering Spectre and Meltdown) to creating secure operating systems to possibly eventually replace Android and ChromeOS. A lot of security-interested programmers think it easier to secure a small microkernel like Fuchsia than to secure the older generation of operating systems and the baggage they have acquired. Google want everyone to trust the Internet. If consumers are scared to shop online, Google dies. This is why they put so much effort into securing it.
  • globuous 9y ago
    Would it be possible to conceive a POSIX layer of compatibility for Fuchsia?
    • JdeBP 9y ago
      Yes. https://news.ycombinator.com/item?id=16816742 https://news.ycombinator.com/item?id=16816742 https://news.ycombinator.com/item?id=16816742 https://news.ycombinator.com/item?id=16816742
  • jjrh 9y ago
    > For what benefit exactly? Wouldn't surprise me if the unofficial reason is because it's more fun.
  • dreta 9y ago
    Personally, i'll be happy if we can move past read/write constructs designed for tape drives.
    • kps 9y ago
      Networks are the new tapes — still slow and sequential.
  • noselasd 9y ago
    Why would it break a ton of posix software? They seem to have ported the musl c library, they removed to have stuff like cmake vim git openssh running on it
• lerax 9y ago
  To people which don't understand the overall decision to create another system, I'll talk about at least one benefit to create a system that is not Linux: make software more simple and efficient. Do you really think that Linux is so great? Linux is a bloat system [1], POSIX is not so great as well (do you really read the WHOLE POSIX spec?). It's important standards, it's important sometimes (SOMETIMES) compatibility. But not all this stuff defined in POSIX it's important. POSIX sucks sometimes [2], only GNU can be worse about being bloated [3]. Only users which don't touch in code can think that Linux, POSIX and GNU are entities following principles based in simplicity. Linux following Unix guidelines? This only can be a joke of Linus. Creating custom software, maintaining and other stuff on things THAT YOU DON'T UNDERSTAND has a massive cost. As well, the cost to understand complex things, it's even worse. Sometimes it's even more simple re-inventing the wheel than understand why a wheel was build with a fractal design [4]. [1] Linux LOC overtime https://www.linuxcounter.net/statistics/kernel https://www.linuxcounter.net/statistics/kernel [2] POSIX has become outdated http://www.cs.columbia.edu/~vatlidak/resources/POSIXmagazine.pdf http://www.cs.columbia.edu/~vatlidak/resources/POSIXmagazine... [3] Code inflation about /usr/bin/true https://pdfs.semanticscholar.org/a417/055105f9b3486c2ae7aec22a7dbd57e1ba3c.pdf https://pdfs.semanticscholar.org/a417/055105f9b3486c2ae7aec2... [4] The Linux Programming Interface https://doc.lagout.org/programmation/unix/The%20Linux%20Programming%20Interface.pdf https://doc.lagout.org/programmation/unix/The%20Linux%20Prog... (that cover of book has a reason and yes: it is what you think)
  • ansible 9y ago
    > ... POSIX is not so great as well ... Ugh, tell me about it. Just dealing with a relatively simple situation where you've got signals coming in while reading a pipe is a hassle to get completely correct. I am so there for an operating system API that is relatively simple and sane. Where writing correct programs is, if not the easy path, at least not the hard and obscure path.
    • Viper007Bond 9y ago
      Interestingly PowerShell is petty awesome in that regard. You pass around objects instead of trying to parse strings and things.
• Roritharr 9y ago
  I'm enthusiastic about Fuchsia, i really think there is a lot to gain by breaking with the old conventions, especially when you look at what is hindering true realtime computation approaches. As a nice byproduct Google has a hedge against Linus dying and his replacement being incompetent at managing the community.
  • hawski 9y ago
    Is Google actually good at community collaboration? I honestly don't know. But I would imagine that they require CLA and that would hinder the community. It may be a big problem when BDFL dies if there is no blessed successor, but what is a greater trade off?
    • endymi0n 9y ago
      I must admit I find the development of Kubernetes extremely well organized fir the sheer size of the project.
      • dankohn1 9y ago
        Google did a great job starting the Kubernetes community, but they then contributed the project to CNCF (which Google also helped launch). Google remains the top contributor to Kubernetes, but even as their contributions remain substantial, their % of the total contributions is going down, due to the large number of other organizations now backing Kubernetes. https://k8s.devstats.cncf.io/d/8/companies-statistics-repository-groups?orgId=1 https://k8s.devstats.cncf.io/d/8/companies-statistics-reposi... (Disclosure: I'm executive director of CNCF. We also build that DevStats tool.)
    • csours 9y ago
      I think the point is, they don't have to be.
    • jrockway 9y ago
      I think CLA is pretty standard for any open source project. I think the first one I ever signed was for Emacs. Emacs has done pretty well and the CLA doesn't seem to be putting many people off from contributing.
• newnewpdro 9y ago
  More importantly, Fuchsia is not GPL.
  • mankash666 9y ago
    WHY should everything be GPL-ed? Capitalism is an ethical, meritorious system rewarding hard-work and skill and GPL runs counter to everything capitalism stands for. Not to mention that the fat profits capitalism bestows on Google FUNDS fuchsia
    • tomc1985 9y ago
      > Capitalism is an ethical, meritorious system rewarding hard-work Um... no it isn't. Meritorious only for those on top. While I agree that Google doesn't need to GPL Fuschia, GPL was imagined as a direct response capitalism's very pro-owner and anti-customer approach to distribution and rightsholding.
    • _tulpa 9y ago
      > Capitalism is an ethical, meritorious system rewarding hard-work and skill Did you drop an /s or something? Captialism doesn't give a shit about eithics or merit either way. The only thing worth a damn is capital, which is a pretty good motivator for all kinds of unethical and corrupt practices. Not that GPL would necessarily be a good thing in this case.
    • SolarNet 9y ago
      > GPL runs counter to everything capitalism stands for. That's the point (or at least one of them). Though I personally don't care if it is GPL or not, as someone interested in perhaps using this OS for commercial purposes at some point it's not being GPL is a slight plus for me. However, one key point of the GPL is to create a commons (of software, hardware, protocols, etc.) that can't be exploited for gain by capitalists, that can't be exploited for economic rent, that can't be laden down with copyrights and patents. A system that is actually, truly free (as in freedom). Which is important to understand if you want to be intellectually honest.
    • msla 9y ago
• 0x0 9y ago
  I find it interesting to note that the core fuchsia OS comes with "magma", "escher" and "scenic", which seems to be core OS services for composing one 3D scene across multiple processes ("shadows can be cast on another process without it knowing about it") Is that a hint that Fuchsia is a VR-first operating system?
  • on_and_off 9y ago
    I would say it is more of an hint that the material design team was heavily consulted when Fuchsia was conceived.
  • wlesieutre 9y ago
    Drop shadows in 2D window managers are pretty common, is it not referring to that?
    • 0x0 9y ago
      From the sound of it, I assumed it was building up a 3d world scene graph composed by objects supplied by independent processes. Maybe I'm reading too much into it.
      • IshKebab 9y ago
        Yeah I think the "physically based 3D renderer" is a bit misleading because it makes you think "ah, like Blender or Unreal Engine 4", but actually I think they just mean they are doing window translucency and drop shadows in a physically correct way (e.g. there is an actual light source) rather than faking it. It is still used to render mostly-2D windows. (This is my assumption anyway - I haven't tried running it)
        • on_and_off 9y ago
          I think you assumption is spot on. Android already does physically correct soft shadows in real time. The initial design of material would have allowed way more space manipulations, like making a view rotate on any axis. So the shadow implementation allows to remain correct even in this kind of case. It is kinda sad that the final design forbids this, a simple raster shadow would have been enough to just signify the elevation.
• juhanima 9y ago
  Microkernel, huh? At least now we will have a chance to get some empirical evidence to resolve the famous Torvalds - Tanenbaum debacle. It's going to be interesting to see how Fuchsia pans out and in what kind of environments it can be used.
  • _fq4v 9y ago
    You have to be kidding right? Microkernels have been used in production for decades in situations where safety, accuracy, and robustness are key. QNX is a microkernel used in real-time systems to great avail and great stability. Unlike linux, it's the sort of kernel you could really trust to run important infrastructure, like automobiles, unmanned aircraft, high speed trains, and robotic surgery. Just because you don't consciously interact with them on a daily basis, does not mean they do not exist. My guess is that QNX and kernels like it are the reason you can take for granted such obvious things as your car braking correctly, your train not derailing, and your robot surgeon not crashing. In today's world, we're so used to software breaking that if it doesn't break, we oftentimes think it must not exist. But, there is a whole world of reliable software out there that can actually be trusted. You don't hear about it often, because they work so well.
    • BurningCycles 9y ago
      Well, one of the things I hope we get to see with projects like Fuchsia and Redox is what the performance difference is against a monolithic kernel like Linux, if/when they have been well optimized.
      • Karunamon 9y ago
        I don't think this will be a fair comparison, since most of Android's performance woes are at the feet of running on a JVM.
        • pjmlp 9y ago
          ART is a thing since Android 5.0 and it has become quite good. Even the parts written in straight C and C++ code have issues in performance woes on Android, as everyone that has wanted to do real time audio on Android painfully knows. The whole architecture has been a mess.
• nailer 9y ago
  UX folks: Raph Levine works on Fuschia. Here's some video, alas I couldn't find anything from this year. https://www.youtube.com/watch?v=HpBbbd8y2kM https://www.youtube.com/watch?v=HpBbbd8y2kM
  • berg01 9y ago
    Raph has a great and well-deserved reputation for excellence. .. but where do you find any reference to him in that video?
    • gman83 9y ago
      Probably referring to this: https://www.recurse.com/events/localhost-raph-levien https://www.recurse.com/events/localhost-raph-levien
      • berg01 9y ago
        Thanks!
• svag 9y ago
  As I can see, they use a microkernel architecture for the kernel[0]. I wonder why they need to create another microkernel OS and not re-use an existing one like MINIX 3 or QNX? What are the advantages of the Zircon Kernel compared to the MINIX 3 or QNX? [0] https://fuchsia.googlesource.com/docs/+/master/the-book/#Zircon-Kernel https://fuchsia.googlesource.com/docs/+/master/the-book/#Zir...
  • pjmlp 9y ago
    Google owns it.
  • kllrnohj 9y ago
    They did start with an existing one: "Zircon was born as a branch of LK" - https://fuchsia.googlesource.com/zircon/+/HEAD/docs/zx_and_lk.md https://fuchsia.googlesource.com/zircon/+/HEAD/docs/zx_and_l...
  • CodeArtisan 9y ago
    it seems to be closer to NTOS (handles based) than UNIX (everything is a file).
    • monocasa 9y ago
      Eh, the NT handle table and Unix file table are very nearly the same thing these days. I'd say it's more like using the per process FD table for everything, rather than having global tables like for PIDs. Which is really cool, IMO. Containerization is all about adding indirection to the global tables, but of there are no global tables, you get all of that for free.
      • dfox 9y ago
        NT is weird beast from this point of view because of how much of process state (in the sense of "on unix this is some kernel structure") is in fact implemented purely in userspace.
        • 9y ago
• alokitr 9y ago
  I can't wait for this to be a huge bloated system that nobody comprehends in its entirety. Oh, wait
• btilly 9y ago
  What do they mean by "capability based"? A lot of people say "capability based" and really mean some very fine grained access control system. (A confusion encouraged by POSIX "capabilities".) What I hope that they mean is the one that solves the https://en.wikipedia.org/wiki/Confused_deputy_problem https://en.wikipedia.org/wiki/Confused_deputy_problem There are two VERY different meanings of the phrase. The one that I'm hoping for can be thought of like this.
  • abecedarius 9y ago
    Sounds like the real deal: https://www.linkedin.com/pulse/capabilities-os-security-google-fuchsia-lorens-kockum https://www.linkedin.com/pulse/capabilities-os-security-goog... (I think this article made a small error in that an open-source KeyKOS release exists now, I think only for obsolete hardware.) OTOH the OP's table of contents gives me the impression that Fuchsia is more complex than the older capability OSes (KeyKOS family, seL4).
  • kps 9y ago
    Yes, see https://fuchsia.googlesource.com/zircon/+/master/docs/concepts.md https://fuchsia.googlesource.com/zircon/+/master/docs/concep...
  • navigaid 9y ago
    I think the term "capability based" is explained well enough in the talk "Dive into Magenta – fuzzing Google’s new kernel" (https://youtu.be/aYZCiLI-LZM?t=18m9s https://youtu.be/aYZCiLI-LZM?t=18m9s). Highly recommend it.
• jeremy_wiebe 9y ago
  Somewhat tangential to the topic but one really cool project related to Fuchsia is the Xi text editor project written in Rust. The author (Raph Levine) has a very interesting series of posts on data structures and algorithms used in the editor (like rope data structures) https://github.com/google/xi-editor/ https://github.com/google/xi-editor/
  • slx26 9y ago
    Recently covered here https://news.ycombinator.com/item?id=16267202 https://news.ycombinator.com/item?id=16267202
  • trishume 9y ago
    You may be interested in the Xi CRDT documentation I wrote as part of my work on integrating Xi into Fuchsia: http://google.github.io/xi-editor/docs/crdt-details.html http://google.github.io/xi-editor/docs/crdt-details.html
• markstos 9y ago
  Well, "GNU is Not Unix" and that worked out OK. On the page it says it is "POSIX lite", so it likely be recognized a rather Unix-like, and and a number of things may likely end being able to be compiled on it with few modifications due to the POSIX-like environment. The `brew` project on macOS would be a related example.
• fooker 9y ago
  There seems to be system calls to create and manage Virtual CPUs. What is this for? Is there a precedent?
  • gman83 9y ago
    Backwards compatibility with Android?
  • noselasd 9y ago
    For managing a hypervisor, e.g. creating a vcpu for a guest VM
    • fooker 9y ago
      How does Linux do this without having system calls like this?
      • tmzt 9y ago
        there's an interface that looks something like this (including vcpu) as part of KVM, accessed through the /dev/kvm device with ioctl's. You can see part of it here: https://github.com/torvalds/linux/blob/master/arch/x86/include/uapi/asm/kvm.h https://github.com/torvalds/linux/blob/master/arch/x86/inclu...
• s2g 9y ago
  Fuchsia would be pretty cool, if it wasn't being developed by Google. Not gonna use an OS from that company.
• Boulth 9y ago
  It's interesting that Google even registered fuchsia.com, used in examples.
• geijoenr 9y ago
  I really don't get this coming up with a new OS's thing every now and then. As I see it, is all about driver support; just because is the bigger effort. That is why vendors (and the community) focus in only one or two options (Windows/Linux). Anybody can come up with new fancy OSs, as a matter of fact many people does. Problem is, there is no incentive for vendors to produce specific drivers for those, and the communities are just to small to cope with the huge amount of hardware support to make them useful. I just don't see the point of coming up with new OSs as long as Windows/Linux just work as intended.
  • pm90 9y ago
    Just because you don't see it doesn't mean its not a good idea.
  • khedoros1 9y ago
    It's not clear where exactly Google intends Fuchsia to run, but wide hardware support would be best for a relatively open ecosystem like PC hardware. A non-general-purpose OS, or at least one designed to run on specific hardware, doesn't have the same requirement for a large body of drivers to be available. Imagine if they want it as an OS for a range of embedded devices, or something. Hardware support could be very limited. Especially at a smaller scale like that, Google's got the money and expertise to license hardware IP from another company and build their own drivers for it.
  • tracker1 9y ago
    A network host/container OS that is lighter than Linux/Docker, Solaris and FreeBSD.
    • pm90 9y ago
      One can dream ;). I do like the minimization that a lot of OS/Systems are undergoing though. I still remember when VMWare VM's came along and my mind was blown. Similar feeling on seeing Docker, but it was tempered somewhat until kubernetes came out. Very excited to see what comes next in the future.
• pm90 9y ago
  I see a lot of negative comments about this project here. Let me just say that: it doesn't need to be a POSIX compliant system, doesn't need to be user friendly or even provide something different from what can already be done with Linux or other OS's that we have today. Google spends a lot of money on research. One thing about research is that a lot of stuff you do ends up completely useless in the short term even if you cover all your bases initially. Even if this project fails, I hope something good can be learned from why it failed; maybe someone in the future can learn from those mistakes and try again. I'm certainly no fan of Google nor of the way they make money. But I am very happy they use that money for stuff like this.
  • flyingcircus3 9y ago
    Hacker News commenters are not the ones making baseless claims about how their product is better than the current market dominator. Hitchens Razor is working just fine in these comments. It reminds me of NFL fans. No one talks trash about the crappy quarterbacks of their opponents teams. Everyone talks trash about Tom Brady, and Peyton Manning, Cam Newton, etc. This is also a general negotiating tactic. Start with a bold initial offer, and then negotiate back to what you wanted in the first place.
    • lambda 9y ago
      > Hacker News commenters are not the ones making baseless claims about how their product is better than the current market dominator. Where did anyone say that Fuchsia was better than Linux? The title of this document, "Fuchsia is not Linux", is a play on the "GNU's not Unix" backronym for the GNU project, as well as being a way of pointing out that unlike Android, Fuchsia is an entirely different kernel. I mean, obviously they would write it because they thought it would be better for certain applications than Linux, or better for trying out new ideas, or the like, but I don't see anything claiming that Fuchsia is better. In fact, Fuchsia has been done as a pretty low-key project for a while, slowly opening up parts but without much fanfare, just repositories being available, and slowly posting more documentation like the link in the OP. I don't really see very much marketing about it, just low key releases of code and more technical information to give people a taste and show the direction they're trying to go in.
• mihaela 9y ago
  I don't have a problem with Google's resources to build something of that magnitude successfully. My problem is with their execution. All their products are in perpetual beta. And the users are forever testers. That's their business model, and it doesn't call for great UI/UX.
  • djsumdog 9y ago
    That was Windows 95 and most Microsoft software. It's pretty much the norm today for everyone.
  • jacksmith21006 9y ago
    Search is beta? Google WiFi? Gmail? Android? YouTube? Chromecast? Project zero? Maps? Photos?
    • mihaela 9y ago
      GMail was in beta for a long time. Search is not a product but a service. Maps was in beta for long as well.
      • dragonwriter 9y ago
        > GMail was in beta for a long time. Which doesn't justify the universal, present-tense claim upthread.
• _bxg1 9y ago
  It seems reasonable to want to build a modern OS from scratch; Linux has survived and adapted remarkably well, but it has many aspects that are rooted in the past and just can't be shaken off. The world has changed a lot. I just hope Fuchsia remains truly open-source and doesn't become a power-play by Google.
• cmollis 9y ago
  So it’s....Mac OS X?
• squarefoot 9y ago
  Soo, given that all important device drivers in the Linux kernel used in Android are closed, I'd be curious to hear from Google if their new Fuchsia is going to solve that problem. This may seem trivial, but closed device drivers make 100% impossible neither to update them to more modern versions once the Android version is declared obsolete, nor install natively a different operating system on the device. This practice, security concerns aside, is responsible for a huge load of old -otherwise perfectly usable- devices being scrapped in landfills. So, dear Google, will you keep the lowest, smallest but most important layers of the OS open or rather will prevent people to do what they want with the devices they purchased even at the cost of contributing to more pollution?
  • stonogo 9y ago
    Google does not regard closed drivers as a problem. With Fuchsia, all the important drivers will be closed, full stop. Google has no incentive to care about your landfills. The permissive license of Fuchsia will make its ecosystem more appealing to IVI and mobile OEMs, not less.
    • squarefoot 9y ago
      E-waste is just one of the problems, probably the only one most users could understand; but security is also a huge one. With apps requiring permission to essentially everything (and users surrendering them blindly) security on any mobile device as of today is a myth. Open Source apps could mitigate the problem by swapping an unreliable layer with a trustworthy one, but we still have closed device drivers which could contain whatever their manufacturer (or its government) wants without any chance of being audited.
  • Skylled 9y ago
    My understanding is that Fuchsia will have a stable ABI to avoid the driver issues of Android/Linux. That's not an answer to open source drivers of course. That falls on the OEMs.
  • salatschussel 9y ago
    I also don't approve of the wasteful short lifecycles, however I don't think they are only caused by device drivers being closed source. People want to buy new devices, not only because of the outdated software, but also because the hardware has improved so much in the last years, and because they enjoy buying.
• flyingcircus3 9y ago
  "Senator, while I agree in the general sense that Fuchsia is not Linux, It appears that in this specific case, its just Yet Another Linux." How is this not the latest iteration of not invented here syndrome? Any system like Linux or Python that has the "Benevolent Dictator For Life" holding the reins is inherently saying that they favor quality over quantity. Its almost like the US Senate, in that the very goal is to go only as fast as prudent.
• CodeArtisan 9y ago
  Looks like they are using Dart for developing applications. This seems to be the dart sdk for fuchsia https://fuchsia.googlesource.com/topaz/+/master https://fuchsia.googlesource.com/topaz/+/master There is no documentation at all but there is a few application examples in /app/. The bindings for fuchsia and zircon (kernel) are in /public/dart-pkg/
  • gman83 9y ago
    It's Flutter: https://flutter.io/ https://flutter.io/
  • afsina 9y ago
    AFAIK there is Rust and Swift support in OS but seems like high level UI is done with Flutter for the time being.
• linuxftw 9y ago
  I have yet to see anything useful come from Fuchsia. There are tons of 'press release' type blogs, but nothing functional. The bundled steps to run Fuchsia inside qemu didn't work (and even shipped their own version of qemu in the scripts!) I'm assuming the Fuchsia development is 100% about not having to use any GPL software. Look how hobbled the Android and ChromiumOS communities are compared to the Linux world at large. As soon as someone outside of Google produces anything of any novelty around Fuchsia, I might change my mind, but for now I'm viewing it as a going-nowhere software project that's all hype and will never be 100% Free and Open Source.
  • djsumdog 9y ago
    > I'm assuming the Fuchsia development is 100% about not having to use any GPL software. This. Everyone wants to distance themselves from the GPL. The reality is that the ideas the 90s open source movements were founded on are far from what we see today. We don't see OSS end user applications; at least not a lot in mainstream use. Instead, we just see OSS middleware. In the early 2000s, people though one day we'd see Gimp be on par with Photoshop and StarOffice/Libreoffice take on Word and Excel. We've come a long way, but those ideas were never realized.
    • zzzcpan 9y ago
      And by everyone you mean Google and other corporations, that explicitly disallow software with restrictive licenses, because opening up their own software, giving up lock in and actually competing is unthinkable to them. So not really about distancing themselves or the movement. Individual developers and small companies, on the other hand, can benefit from the most restrictive GPL licenses by selling commercial licenses to those corporations and not giving it away for free to them.
    • wiz21c 9y ago
      >>> the ideas the 90s open source movements were founded on are far from what we see today Are they ? GPL is about protecting users' freedom. It's still a valid aim to me, probably even more so. What has changed is that the web is much bigger than the desktop and so the GPL has less ground to grow on, so its effect may have been weakened. But only the effect, not the goal. (I 100% admit I am more an idealist than a pragmatic)
• ProAm 9y ago
  Why use a new OS from a company with historically bad customer support, will likely report everything you do back to google HQ for analytics and frequently abandons projects once developers get tired of it. Sounds like a computing nightmare, I'd be very hesitant to voluntarily use it.
  • thethimble 9y ago
    And yet, Android is the single most used operating system in the world and Chrome is the single most used browser...
    • ProAm 9y ago
      That's why I said voluntarily. Realistically there are 2 cell phone OS's to choose from, Android and iOS. Android is broken a lot of the time and people are forced to either find workarounds or do without functionality. I dont use Chrome but Firefox. But the masses will use it if its forced on them.
      • colemickens 9y ago
        >Android is broken a lot of the time and people are forced to either find workarounds or do without functionality Continuing to see this parroted is about as silly as the "Android OS includes ads" which is another comment that lets me know the author hasn't actually used the platform for themselves.
        • ProAm 9y ago
          Im speaking from personal experience. From not being able to write to the SD card with updates to the Gmail Outlook/Exchange Sync being broken in Oreo, to gmail messages being delivered hours or days late due to doze and GCM messaging. It's not parroting when its true.
    • throw2016 9y ago
      Allowing Google to stalk even more people and legitimize the world's largest surveillance operation. Not a good thing.
• naasking 9y ago
  Some problems I see from skimming the docs: > Calls which have no limitations, of which there are only a very few, for example zx_clock_get() and zx_nanosleep() may be called by any thread. Having the clock be an ambient authority leaves the system open to easy timing attacks via implicit covert channels. I'm glad these kinds of timing attacks have gotten more attention with Spectre and Meltdown. Capability security folks have been pointing these out for decades. > Calls which create new Objects but do not take a Handle, such as zx_event_create() and zx_channel_create(). Access to these (and limitations upon them) is controlled by the Job in which the calling Process is contained. I'm hesitant to endorse any system calls with ambient authority, even if it's scoped by context like these. It's far too easy to introduce subtle vulnerabilities. For instance, these calls seem to permit a Confused Deputy attack as long as two processes are running in the same Job. Other notes on the kernel: * The focus on handles overall is good though. Some capability security lessons have finally seeped into common knowledge! * I'm not sure why they went with C++. You shouldn't need dispatching or template metaprogramming in a microkernel, as code reuse is minimal since all primitives are supposed to be orthogonal to each other. That's the whole point of a microkernel. Shapiro learned this from building the the early versions of EROS in C++, then switching to C. C also has modelling and formal analysis tools, like Frama-C. * I don't see any reification of scheduling as a handle or an object. Perhaps they haven't gotten that far. Looks like they'll also support private namespacing ala Plan 9, which is great. I hope we can get a robust OS to replace existing antiquated systems with Google's resources. This looks like a good start.
  • tines 9y ago
    > You shouldn't need dispatching or template metaprogramming in a microkernel, as code reuse is minimal since all primitives are supposed to be orthogonal to each other. Orthogonality doesn’t obviate the need for metaprogramming though. For example, there are lots of places you might need a linked list structure, where the nodes store different types. You might use templates over intrusive structures to gain some type safety without duplicating code for each contained type.
    • ninkendo 9y ago
      More evidence IMO that when people think they need template metaprogramming, what they probably really need is basic collections primitives. Go is a good example of this. (Strings, maps, lists, slices are just done once by the language, you don't get to write your own implementation because there's no generics, but in practice nobody cares.)
• tyingq 9y ago
  Assuming you want to build things yourself only when it's a differentiator, not sure I get Fuchsia. Any "bloat" or slowness on Android seems more likely to be Java, or something other than the base OS. Maybe I'm missing something?
  • kiriakasis 9y ago
    Well, one of most serious problem with android has nothing to do with bloat, but with old non updated devices
• lambda 9y ago
  How about some discussion of Fuchsia itself, instead of "why reinvent the wheel" or "Linux is bloated"? From my reading so far, it looks like Fuchsia takes some of the better parts of the POSIX model, the way file descriptors can be uses as capabilities, and extends its usage more consistently over the API so that it is used in a lot more places. In Fuchsia they are handles, which are arbitrary 32 bit integers, but they act a lot like somewhat richer, more consistent file descriptors. You can clone them, possibly with limited rights like read only, you can send them over IPC channels, etc. There are some differences, in that there's no absolute path handling directly in the kernel; instead, you always open relative to some particular file handle. A process may be given two that can be used to emulate POSIX style path resolution, by being given a root directory handle and a current working directory handle, though there may not be a guarantee that one contains the other; it sounds like more commonly application will just be given handles for the files or directories they are supposed to access, rather than having everything go through path resolution. Signal handling is done consistently with waiting for data on handles; handles just have various states they can be in, like ready for reading, ready for writing (for file handles), running or stopped (for process handles), etc, and you can wait for changes of state on any of a variety of different handles. Memory mapping can be done by allocating a virtual memory object, which you could either not map (treat it as an anonymous temporary file), write to, and then pass to another process, or you could map it into your process, manipulate it, clone the handle, and pass that to another process. Basically seems like a cleaner design for shared memory handling than POSIX, though something a lot like it can be done in Linux these days with anonymous shared memory and sealing. Jobs, processes, and threads are also all handles. Jobs contain processes and other jobs, and processes contain threads. Jobs group together resource limitations (things like limits on numbers of handles, limits on total memory used, bandwidth limits, etc), processes are separate address spaces, and threads are separate threads of execution in one address space. The fact that jobs and processes are all handles, instead of IDs, means that you don't have to worry about all of the weird race conditions of trying to track things by PID when that PID may no longer exist and could be reused in the future. An interesting part is how program loading happens. In POSIX like OSes, you fork your process, which creates a clone of the process, and then exec, which asks the kernel to replace the running program with one loaded from another file. You give the kernel the path to a file, and the kernel calls the dynamic linker on that path to link the shared libraries together and then execute the result. In Fuchsia, you just build the new address space in the parent process, and then ask the kernel to start a new process in that address space, with execution starting at a particular point in it and some parameters loaded into particular registers. This basically means that the dynamic linker will now be done by a library call in the parent process; which could be really advantageous for those processes that fork the same executable as a subprocess many times, as they can link the executable once into some read only pages, and then very quickly spawn multiple processes from that same already linked program. I'm sure that ld.so and friends on Linux and other POSIX-like OSs have a lot of caching optimizations to make this faster, but it sounds to me that the Fuchsia model of just having the parent process do the linking as a library call could be a lot faster. (edit to add: hmm, upon further reading, it looks like they expect process creation to happen from a single central system process, rather than providing the dynamic linker API, "launchpad", as a supported API; but for now it looks like you can use the launchpad library) It basically looks a lot like what you would wish the POSIX API worked like with a lot of hindsight. A lot simpler and more consistent, and does a much better job of "everything is a file" than the POSIX API ever did (of course, it's "everything is a handle," but that's fine, the point is that there's one consistent way to work with everything).
• jacksmith21006 9y ago
  It is hard to imagine this kernel being anywhere near as efficient as Linux. What makes Chromebooks so great is peppy performance on cheap hardware that you just could never achieve with Windows.
  • tracker1 9y ago
    Linux isn't particularly efficient... That it's often better than Windows, doesn't make it the most efficient. And does that matter? ChromeOS' UI is driven by Chrome (a web browser).
    • Valmar 9y ago
      Well, if you're comparing Linux and Windows' kernel specifically, they seem about the same, if everything we know about Windows' kernel is true.
• akavel 9y ago
  Does anybody know how it compares to GenodeOS (https://genode.org https://genode.org)?
• aidenn0 9y ago
  Did they write a completely new microkernel for this? If so, I'm curious why.
• valarauca1 9y ago
  Zircon is very much in the legacy of linux. The biggest sin of Linux API remains ioctl (and its variants). Zircon commits the same mistake with its `object_get_prop` [1] and `object_get_info` [2]. If you pretend to be type safe (have different getters for different obj-types), you can in the long run replace these calls with in-userland static calls where possible to accelerate performance (like linux does for futex and time). Instead you get his "It does A if you give it B, it does C if you give it D" this is pretty bad API design as it NEEDS a void pointer. I'd rather see _a lot_ of simple with numbers related to the call. You have 4 million of them FFS (if you care about 32bit compatibility). It just leaves a bad taste in my mouth. The API design is extremely nice otherwise, and these methods feel like such an after thought. --- To be clear I really don't care about POSIX compatibility, its easy to shoe horn in after you have a solid OS. The Windows-NT kernel has done it twice now (NT4.0 and Windows10). [1] https://fuchsia.googlesource.com/zircon/+/master/docs/syscalls/object_get_property.md https://fuchsia.googlesource.com/zircon/+/master/docs/syscal... [2] https://fuchsia.googlesource.com/zircon/+/master/docs/syscalls/object_get_info.md https://fuchsia.googlesource.com/zircon/+/master/docs/syscal...
  • JdeBP 9y ago
    Actually, three times. There were two POSIX subsystems.
• mortdeus 9y ago
  whats wrong with linux?
• ryanlol 9y ago
  Tangentially related, has anyone tried using the netstack (https://github.com/google/netstack https://github.com/google/netstack) in their projects? Currently looking to see if this would be suitable for our high performance networking needs, haven't seen anyone else actually using it though.
  • 0xFFC 9y ago
    I am really curious this too. Anybody?
• deleted 9y ago
  [deleted]
• maawad10 9y ago
  I want earn money from any way
• Khaine 9y ago
  One thing I don't see addressed in the README is why? Why do we need Fuchsia? What problem are we trying to solve? Why should I use/develop for it instead of Windows/Linux/macOS? Or is this just a research operating system designed to test new ideas out?
  • akavel 9y ago
    The main keywords are "capability based" and "microkernel". Those ideas bring numerous advantages over monolithic kernels (including Linux, Windows, macOS), especially humongous boost to protection against vulnerabilities, also better reliability and modularity. They are quite well researched already AFAIU, and apparently the time has come for them to start breaking through to "mainstream" (besides Fuchsia, see e.g. https://genode.org https://genode.org, https://redox-os.org https://redox-os.org) Other than that, for Google this would obviously bring total control over the codebase, allowing them to do whatever they want, and super quickly, not needing to convince Linus or anybody else.
    • cm2187 9y ago
      And does a microkernel have anything to do with the ultimate capabilities of the machine or is it specifically targeted at embedded / smartphones / hypervisors, and not for running a regular server or desktop OS?
      • akavel 9y ago
        I'm afraid I don't fully understand the question; would you care to try rephrasing? Anyway, as to what I seem to understand: - "capabilities": ok, I think I get the misunderstanding. The "capabilities" here are completely unrelated to "hardware capabilities" or "machine capabilities", a.k.a "what features does my phone have". The word has a totally different meaning in the technical jargon of OS development. It's a security architecture concept; as a first approximation, I'd say "capabilities" are somewhat akin to "permissions" on Android/iOS. You could maybe call them "permission lease": as an app, if you got some permission ("capability token"), you can choose to sublease/share/extend it to another app you run. See: https://en.wikipedia.org/wiki/Capability-based_security https://en.wikipedia.org/wiki/Capability-based_security - microkernels are a general architecture approach; they can perfectly well be used for regular server/desktop OS. It's just that writing a new OS for an embedded system is easier as a "first step", because you can start smaller. A full-blown "general purpose" server/desktop OS is much more complex; enough to say that it must have very wide driver support for shitloads of different hardware existing in the world. (But there are also other challenges, like multiple user management.) Microkernels were long believed to have worse performance than monolithic kernels in popular perception, thus their historical unpopularity. However, this notion was challenged by the L4 kernel (https://en.wikipedia.org/wiki/L4_kernel https://en.wikipedia.org/wiki/L4_kernel), which was I believe the reason for the revived interest. L4 was apparently published ~1993, and there was QNX long before that; I'm not actually sure why it hasn't become more popular earlier. Maybe unfamliarity to programmers? I believe microkernels enforce somewhat stricter development standards than monolithic kernels (where it's probably easier to "just hack around" and duct-tape a new feature), thus probably raising the perceived development costs somewhat (I believe it's similar as if we compared e.g. Rust vs. C/C++). edit: ah, a good example could be the L4-based L4Linux (https://en.wikipedia.org/wiki/L4Linux https://en.wikipedia.org/wiki/L4Linux) kernel, which is said to be a more or less "drop-in" replacement for the "classical" monolithic Linux kernel, so you should be able to run any Linux distro on it. Though I personally never tried it (yet). The GenodeOS folks are also working towards building a usable "general purpose" desktop OS based on a microkernel, see e.g. chronologically: - https://github.com/genodelabs/genode/issues/1552 https://github.com/genodelabs/genode/issues/1552 - https://github.com/genodelabs/genode/issues/2018 https://github.com/genodelabs/genode/issues/2018 - https://genode.org/documentation/articles/sculpt-ea https://genode.org/documentation/articles/sculpt-ea
• peter_retief 9y ago
  It has taken decades to make linux stable and relatively bug free (Discounting systemd) As much as it would be great to have a new OS I wonder what is it based on and why?
  • lnx01 9y ago
    systemd =/= Linux -- systemd is an init system and is completely unrelated to the kernel.
    • peter_retief 9y ago
      I mentioned systemd as humour
  • naasking 9y ago
    > It has taken decades to make linux stable and relatively bug free This is due to the development practices and tools employed, not intrinsic to the construction of new operating systems. There are much better tools now. For instance, Google could have built this on seL4, a verified microkernel instead building their own from scratch and they would have hit the ground running instead of the slower build up they're now going to face.
    • peter_retief 9y ago
      It will be interesting to see how it works out, as you say better tools and knowledge, I am looking forward to use it
• netheril96 9y ago
  People here seem to be amazed that this project is in C++, rather than a simpler language (C) or a more modern language (Rust). But you must notice that this is a Google project, and Google writes many many projects, internal and external in C++. It almost never writes in plain C, and has no penchant for fancy new programming languages. You may disagree, but Google doesn't care.
  • neolefty 9y ago
    C++ is of course a Swiss Army Knife of a language. Important context is the Google C++ style guide: https://google.github.io/styleguide/cppguide.html https://google.github.io/styleguide/cppguide.html
  • _emacsomancer_ 9y ago
    What about Golang?
• Quequau 9y ago
  Has anyone found a how-to for installing this on something like an RPi or maybe a VM or whatever?
• lucasnichele 9y ago
  Obviously, this is the same compare banana with pineapple. As linus live, linux will never be microkernel.
• AndriyKunitsyn 9y ago
  So, this is a microkernel. Could anybody please explain me why microkernels are so great, when practically they do nothing more but push the overhead of switching threads to extreme? Basically, everything that program does requires waiting for scheduler to execute whatever service we send messages to. Disk, sockets, devices - everything. All of which is made in the name of memory safety. On the other hand, unikernels that execute nothing but managed code (e.g. not code of CPU, but code for some virtual machine such JVM or .Net, which is forbidden to read other processes' memory on the syntax level) solve the same problem of protecting system memory, while carrying much less overhead. I guess this approach would be more preferable for creating a new mobile-oriented OS that requires good performance and low power consumption, no?
• oldandtired 9y ago
  It has been an interesting read of the many different points of view in support of C or of C++. But there is an elephant in the room here. The problem with most languages, including the ubiquitous C, C++, Java et al, is that there are implementation defined behaviours and undefined behaviours that are specifically placed in these languages. A previous discussion, which I can't locate at the moment, did discuss this in detail. Most programmers have a serious flaw in that they do not document. They may produce documents but they do not document. Every assumption, every trick and why it is used, every implementation defined behaviour, every reasoning as to the use of specific algorithms should be documented and is not. I have seen incredibly detailed documents for programs that just miss some of the basic essential assumptions because "everyone knows them". In everyday communications, we use language in a dynamic way, meanings can be changed subtly and we get around the errors. With the programming of machines, there is no such leeway ever. Our languages should be defined completely so that we will know that what we have written has actual meaning. the reality, of course, is that this is a "pipe-dream" and won't happen. But as programmers, we could start calling for such completeness of definition of the languages we use.