Bestand wählen
Merken

library operating systems

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
can occur it is
and the the it it a wonderful good morning to all of you and therefore I hope you made from last nite halfway into it or next speaker mean depressing news the cord off on the team for neuroscientists and release miniature for its latest release we'll be talking to you about the library operating systems the solution for well if you're doubling in microservices and contrast is to trap thinking before World also would thank you thank you if I if you can't read this now is the time to shout but it seems like it's fine so today I'm going to talk to you about ways that we can now use library operating systems in unit kernels to reject the default reality more abstractions and substitute or the and a quick little roadmap of what I'm going to talk today uh talk about today the stock is in the resiliency track which is new in CCC this year and I wanted to talk about why I think that the concept of resiliency is very relevant to the work that we're doing in library operative systems in unit kernels I the and I talk about some of the fact that some of the things the properties that a project might have that we need to be resilient and especially as how that relates to whether a project is understandable and I'm going to talk about what I think of as the ultimate bad dependency in your project which is a traditional monolithic operating system and all talk about how you can replace that that dependency with maybe a dependency that fits better and the way that you usually handle your dependencies and I'll talk about how we can do and how we can actually implement increased resiliency when we take this approach and the by using good software using this offer tools that we use in applications for the libraries that we make the source of so to me a really important concept in whether I given project i is resilient is how many humans can disappear before the project grinds to a halt we have a name for this which you've probably heard is boss number and euphemistically I defined by Wikipedia as a sudden disappearance and if we want to increase the bus number of our projects and the simple answer as well OK if I what where humans effect that 1 had like a higher number of humans who could go away in the project would still go I should get more humans involved in the project and the possible will go up and I'll be fine and but in fact it's not a simple thing to just say a human is exposed to my projects and there is a knowledgeable or competent person and in the context of this project and the way that we can help people be knowledgeable and competent people in the context of our project is to make a product easier to understand the but our project isn't just are code so we can go and we can do a ton a refactoring and we can say OK written use the best practices that we know of and document the hell out of everything in use nice language features and all that stuff but we also have to think about the language the code is written in on the how we uh how we actually interact with our code them from day-to-day like we build it and at word we run it and what things do we need in order to actually use are code in some kind of meaningful way I'm our project isn't just like this the code that is in our repository it's also the list of all the things that it depends on and you might be saying OK well my projects doesn't have any dependencies are has a really small list of dependencies I understand all of them really well they're all really simple and ICT that's probably not true it's very likely that you have in fact a really heavy dependency and for your project which is a conventional operating system and so I've made a nicer last year diagram of how I sort of of how I think about applications the dependencies and model the collapse in this sort of a holistic view where you think it where you put all these things in the same category of stuff that I actually need and in this diagram I have 2 a little the purchasing at dependencies don't worry about them but this one's really big but in fact it is really big and the operating system is really huge on it's and you almost always got more stuff than you need and then the way we interact with it is different from the way that you interact with the rest of the dependencies the documentation is probably not where you normally look for documentation and you probably if you have a problem with that you probably can't debug it in the way that you normally debug code of and when you're writing code that deals with it you're likely accessing it with an API that doesn't look very much like the API is that you like to use and when you're doing applicational code so to give you a concrete example of what I mean by that this is a selection from on into in Linux and the yes signature for the function is here so this is socket from which we would call the move to do the 1st thing that we call of 1 and never communication and socket once a magic number and another magic number another magic number and it'll give us back a magic number or another magic number to tell us that we get an error and we should look somewhere else for another magic the magic number to find out what the error was and if you program in languages other than C. this is probably not what you're used to seeing for a nice interface for a doing some external kind of kind of stuff and worse so that magic number that we got back from socket and we have another function that we need to call it that which is also doing well into stuff magic numbers giving us this weird a out of band errors of their communication and you might say well OK but like if you're doing application development in a complaining that the interfaces that that's because of the C interface like that's probably not what you're actually dealing with in your it nice and you're higher-level language but in fact often you are so this is on the language that I usually working as a camel it's a functional programming language that a lot of nice features from its but considered to be a higher-level language than C is by most people and I'm gonna give you a quick tour of how to read homo camel type signatures so this is the equivalent of socket it's also named socket so that's helpful and this is a function it's going to take and summarize some arguments and these are the types the type socket domain is also a magic number of least restricted to a small to a small subset of possible things and same thing for socket types we have a magic number for the particle type um which in the uh which in the documentation we at least are told as you over default and then let number for other stuff and then we get this we get this type file-descriptor back which again is an under the covers a magic number and on failure we get an exception and if you've dealt with the exception if you've I ever program in a language that has exceptions and you are usually not very pleased to see that there is something that's going to be throwing them as a matter of course when you're trying to do normal stuff and connect is even worse and connects is going to take this file descriptor that we got back from socket it's going to try to map a socket address to it and it doesn't even give us any other the return type is unit which means which is basically a which is kind of equivalent to avoid like and I just went off and did something it was site affecting don't worry about it look somewhere else for errors in this case we may get an exception and which will wrap wishful and just wrap the information from air no from Unix so this is really not very fun to program against in O'Connell either on then we can see why this why this API is the way it is it's just a wrapper for the CAP I it's got a few nice language features from a camel but not very many and that's really all you can do when you're in this situation trying to i trying to interface with the operating system like this is you can write a higher-level API on top of this you can build more and more and more abstractions to get to
something that looks nice to work with them as an application developer in the context of a language but somewhere down on the bottom you always have to talk like this but what if you don't want to the so if work in open source universe can say OK many if you really don't like that API so much go changes to self and I would say that that is non trivial for us and for most people who are trying to write code that they just wanna run somewhere so if I want to make a change to high interface the kernel in 1 do something I 1st have to learn a programming language of the kernel which is probably not the language I used they have to learn how to on do that do that kind of programming in the kernel which is another skill set that I probably don't have and I have to make a test to make it easier uh sorry make a patch make a decent patch and then somehow get that patch accepted on Bikini that have to talk to do that is a different community that I normally talk to it's not the community of my project it's not the community of my language it has different norms that has different processes on and it's probably not very excited about my patch that's for me that's 40 the my application or my language like the kernel doesn't care about whatever stupid space thing I wanna make easier for myself generally speaking and if you think that I'm just whining about logreg doing kernel development is hard I would say that it's not just me that things like doing kernel development Saad and you may have heard of the you did to a challenge which was a a series of programming exercises for the Linux kernel was found was done entirely by mail on started from a base from my writing of basic kernel module on and the challenges would be gated by a few pay you would basically sending the patch on that said OK I solve this challenge please give you the next 1 and then some scripts would sit and think about it for a little while and salient OK I think you did a good job his next challenge so there 20 steps to the until a challenge and there were around 19 thousand people who started I was 1 of them out of the 160 finished I was not 1 of them and and I would argue that a 1 per cent success rate of people who start out specifically wanting to do this 1 thing is probably indicative that it is in fact difficult but this and up since the since you're talking about resilience I wanted to bring up another topic around this so members of your projects and might want limit their exposure to communities that are known for their hostility and toxicity right like they've decided to be in your community they haven't decided to be in every community that's touched by the dependencies of your project a way that we can protect each other is to limit our exposure to these communities that we know might not be safe for people to be an and as projects that are famous for their toxicity do include some very famous monolithic kernel projects the so OK that all seems really bad in kind of a bummer so let's think a little bit more about what operating systems are actually doing for us and of kind of of zoomed out from the eye view that I gave you before of ma applications dependencies and operating system I certain little bit more detail in here on about how we're doing this communication and how we're doing is communication with the things that are sort of below us in the way that we normally think about the stack and crucially I've put in this last little block here usually when we're deploying applications and In this context where we have where we have some operating system that were running on with the operating system is actually not usually running on what we consider bare-metal or hardware it's normally virtualized so there's a thing underneath it the hypervisor that is doing on so that uh the depending on how you look at it in then this view of the stack it would be a lower level management of system resources and informing these things out to individual virtual machines so all of the view that the application has is that the OS is taking care of memory management scheduling in doing all the networks stuff and file systems clock video all of that it's actually the hypervisor and that's responsible for most of us in this in our when you deployed in this in this sort of environment so with the operating system is actually doing a lot of times is just a passing passing calls to the hypervisor for a lot of these things or getting more coarse-grained resources and then doling them out in a more fine-grained manner to its individual applications to so what if we can talk to the hypervisor directly for the but the 4 and and get the same sort of easy virtualized interface that the operating system is getting when it's sound when starting in this virtual machine context I'm and then use libraries to take care of the things that I believe that the kernel code would be taking care of forests that are at a higher level than just interacting with the device so things like and working isn't just I need to push this data into a network card it's I need to assemble TC people TCP flows I need to know how to do DNS lookups on storage and just take all of this data and right to the sector over here there's a and there's of the entire file system where that we're usually interested in there the logic of how we do timekeeping isn't just OK good at the time I but we can implement these things in libraries that are written in the language that we're used to dealing with
that we know how to deal with the and should not be of that so that that's the way that we think are complicated in a traditional operating system because we've been told operating systems have lots of drivers but in fact in this hypervisor context or not we can have the language runtime we can rights motions for and then have the language runtime take care of forest in this by the way this year girl so initially some examples of what these libraries actually look like and what it sort of feels like to interact with the system like this I'm in Roger us which is the library operating system that I work on and we have a common set of interface definitions for EI for these libraries so we have a set of model types that does that tell us OK if you are a type if you're timekeeping device you should have these functions that people can call and if you're if you're level not device I should be able send a packet so if you're t if you're on a TCP module I should be able to interact with you in terms of flows and then we have a whole bunch of implementations of those interfaces so some specific examples of system specific examples of networks and this is also where we have specific ways of handling i networks in different hypervisors on so that we can the general when we are writing a code and then just apply to the target that we actually and the on so let's take a look at what this function that I've been complaining about in i in this in the men in our eyes see API and in the Alamo camel interface to the CIA guy looks like and in Roger as we have a model type TCQ it says OK I am going to give to you and exposed to you this function create connection it takes on the so this text signature is quite a bit more idiomatic camel addition Fortuyn makes a little bit more difficult to read if you're not new camel programmer from but I will try to make it a culture and make it a little bit clearer so I'm in a camel we usually carry around some context some state for a thing in our I think that we often call so this is the current state of with the way that we're going to send stuff over TCP we're going to take an IP address and port and we're going to try to make a connection the return type is either of flow that you can then I to with other functions that are provided by some some implementation of this model type TCP or it's some error which is returned in band some In dies so the detector this is the this whole thing this flow where result is saying OK you either get a flow or I will tell you what what went wrong and and we have this so I decided is parameterized over I which is a concurrency type since this might block of we expose some stuff for doing on light weight as lightweight cooperative multitasking and this particular type signature also uses on something that was a fairly I just recently merged into and there's a camel on standard library this particular result type was something that you had to implement yourself of until fairly recently and in no camel 403 it was pulled in to be useful in the main compiler which means that sorry let me back up we were able to change all of these model types signatures which we had and it's like that like customary types for all of them all over Russia was we're able to unify them with this result type within an with I think about and 8 months or so of that being released and in the minimum standard library which is a term time that I think you probably won't see with most larger operating systems projects the implementations also look like idiomatic OCaml so if we look under the hood of what create connection is actually doing and it's it's not making any weird buffers it's not done it's not digging around in on in global state and it is just taking OK give me a TCP connection give me your destination address and port on I'll make a PC before it if it failed or log that and I'll send you the error and otherwise you'll get the before that I got so the way we actually assemble these into things that you can really use we have some so what I've shown you so far was so far is conceptually how we deal with and these are these and these lists of implantations and what they are and those of dependencies in what they are but what we can do what we do in Roger less is we take the application the application that the user wants to run the list of dependencies a list of implementations which they can pick up and when they're actually when they're actually building the thing and then compose those into either of them process that runs on a traditional operating system so we have a whole Egyptian layers in these libraries that mean that when you're trying to develop your application is 1 or locally you can do that it's fine and more you can have a minimal virtual machine and that will run the hypervisor context that I showed you i in the diagram just a few slides ago um which can run on several different it so I'm show you a quick demo of what it's like to interact with that and I
have the web page and well I have a as a web application actually it is a modulus kernel and it has a list of things that it needs this is a this is the configuration document for the unit kernel which includes a whole bunch of information about how and how i wanna get my networking so this a generic stack before is just give me some IPV for stack item the user can decide when they're building application how they wanna get it and where my content is going to be that I wanna build in HTTP server I wanna use last unlike I some customization stuff reports and well get my certificates from philatelists connection some more customization for the HDP ports and these are my application-level package dependencies so these are the things that you might have been a manifest another language the
and on some composition that says OK get all this stuff together and I also need from the
library operating system I need oppose clock I needed to places for data 1st 1st off the the actual data that you only to serve and then something with the certificates and then you give me a something that knows how to deal the GDP
an inverted up end the actual logic
for my application is in this dispatch file here and which I which because it's a whole bunch of OCaml
that do I this sort of beside the point is I wanna show you the but so often when I invoke Mirage configure it says OK I'm going to look at that that that configuration document ends the list of things that you said you wanted and I'll figure out how to make that so part of what it does is it makes me Make file so now I can decide make it's going to go off make
that application they'll make a binary called main . I can
run it the enter their webpage the goal of this
whole thing is and the city of phenomena so this is some of the thing that I
just showed you are when I deployed on my set off to
Google Cloud from Google Cloud once by the
hypervisor and Google Cloud want something that knows how to talk to real devices so I'm going to save mirage please make me a unit kernel that will thrive in this
environment making 1 of those and know what I
have is this HSPs severed IO
which I should show you more fully
so I have 16 megabytes I which
represents the entire virtual machine that I need to run that
same website and you might say are 16 megabytes is
kind of a lot for like all you're really doing is serving
web stuff and I have all of the content for that page uh rolled up in an in-memory file system there which is part of the reason that it's large and I should mention for
fairness that the binary that we built
for Unix which is actually assembling sorry let me show you the I'll initially the size of
the operating system Add the binary that runs on top of the US it's actually bigger so I hope that
I've maybe I'm convinced you at least to look into whether library operating systems make it easier to do systems development and I hope that you will have a language that you like enough that you think that it might be nice to be able to talk to you to be able to build some of these operating systems and things in it and I would like to convince you that the newly use your language tools makes it easier to do a good job of building these models that you may wanna use found for these systems the sorts of tasks so lover operating systems and uh there's a really interesting implementation of the ideas behind by reordering systems in the wrong kernel project which was 1 of projects and in that BST to take the I take the kernel drivers of basically to making that BST be more like a library operating system and the person to put the time for doing this as i tweeted and fairly recently that his original motivation for doing this was to make it possible actually to debugging and testing for these kernel drivers because once you have these devices in isolation and many can maybe run them in user space or even run them just by themselves in some other kind space it's much easier to and make conclusions about how the behaves in the presence of certain kinds of uh certain kinds of input so the test that we write from Araujo as they look just like really boring unit tests for any other bit of OCaml code that we might write this is on this is a test of something that I get so is that it is wrong in a lot of implementations of TCP which is options padding and it is very very boring a bits that you want us a lot of them and not screw up especially if you're a memory unsafe language which luckily enough camel were not if feature of this code is that it is boring man and the environment in which you run it is also very boring we just run as normal in a normal test framework the way that we normally run tests we monitor so the special test harness and we just execute testing then execute them no drama another thing that we can do when all of these implementations are just individual libraries is we can decide OK and there is the normal library for doing some specific thing that is going to do its best to implement spec or whatever but for my testing purposes I want 1 that's kind of broken I once I want that does something unexpected so I can see all my application dies when an unexpected thing happens the so in modulus we've had come up with a several sort of fun I guess if you like to break stuff custom implementations of various things like network interfaces that always have new packets waiting on a day and they were really nice thing to be able to do is always be able to serve us about the random number generator that something might be looking at so all your tests can be deterministic and even if they're not cooperating with you and they wanna go read from a read from some source that you haven't set up In the same vein you can imagine that having entropy sources that always block is interesting and the code of the application code often fails in lots of situations like when the file system is full or block devices busy or on the you gets short reads from the network or maybe you have maybe a DNS has been hijacked and you wanna make sure that you don't do something stupid in that situation when you do when on the implementation so you have for these things are just modules it's really easy to drop in 1 that's broken in a way that you think school in some more stuff that we can do that is maybe a little bit less obvious so in a conventional operating system you have a whole bunch of global states on and the way that were used to interacting with this whole bunch of global state about how the system is running is we open up the shell and we say OK let me poke around in here and see what's going on in the context of a unit kernel we can now we do we have access to the state that these modules are keeping track of we have access to have that status surface so instead of us having to go in and like try to think of what a look at what can we figure out the the application is doing something weird in this way water all of the things that we can think of the massive set of global state in the operating system that might be affecting how the application is behaving we can has we know the operating system tell us what state it's in and more even more interestingly why it's in that state and we did some experiments I'm putting up using this library ermine which is a distributed data store and that presents interfaces that look a lot like get out of it too is sort of see OK 1 of every change we made to the library to the operating system state had a commit message so everything I wanted to change anything about anything about the state would have to tell us why and we get a log of Y and if we wanted to change ourselves we could commit to it and say why we did it and then see what changes in the running us and a running application another interesting thing is I so I mentioned that we have that we have schedule is that we can swap out well what if our schedule left a traces of what it was doing and we had someone in a project and Thomas Leonard wrote a really nice visualizer of on all of the decisions that the scheduler that the cooperative on multitasking titular makes an entomologist applications is it you I shared memory buffer and then you can examine it interactively in 2 dimensions to see OK this thread failed y and a couple more things so you might say OK in you've convinced me that I don't need the operating system anymore but it's only a hypervisor this thing at a high is also not a tiny bit of code like that's a pretty big dependency as well so we think about that smart guy and I say well we can discover hypervisors to there's a really interesting project called so 5 of which has a has a component you KVM which takes the device requirement information that we surface when writing his configuration documents from Roger assumed kernels and says I OK he said you don't need a network device I'm not surfacing anything about network devices to you as far as you know this hypervisor doesn't know in workers ultimately of there's a link to that project on slide I think it's a it's a very interesting project in very cool and that we have a little bit more ongoing work and we have a lot more ongoing work for opening up more hypervisors so that you can run it more unit kernels on more desktops and some work on taking these libraries and using them outside of the context of library systems there's nothing that says that you have to use them only in this context in use them where you want to do whatever you want and within doing a lot of interesting work with cubes OS and Q to us is a desktop operating system running on my laptop right now is powering the slides before you on where the conceit is that you want you have a whole bunch of different virtual machines to the I for separation of concerns between the different things that you're doing and a problem in cubes OS is that if you do all this with conventional operating systems and you need a lot of a lot of hard drive space which they solve in part by doing some sharing and you need a lot of memory as the ends so it's really nice to be able to have something smaller both in terms of science and in terms of memory consumption so we've had a whole bunch of small projects to replace small bits of other things in gives us that run on a big fat Linux extends with real tiny unit kernels the most I was widely used and successful 1 has been cues Mirage firewall which I'm using right now and I replaced of tariff listed Fedora the and that needed like I think I get to days memory or something no not that much like 5 gigs 500 bag of memory with unit kernel that needed 32 we have a lot of other projects that are ongoing right now but if you're if you're interested anyone see this slide later on I can pull back up for you but you idiot know here there is plenty of interesting stuff to do with Open systems in new kernels there's plenty of space here and I'm I'm interested in hearing your ideas I think we have like maybe enough time for a question but I think a lot for your time if thank you very much indeed uh we actually have time for 1 question and we're going to pick the 1 from the signaling July the Internet because those guys can't catch up with you later all no question from you don't know that we can have 1 question of microphone 1 if you click if I'm happy explored using capability based languages for example and there's a project called Emily which is the capability based on version of a camel and that provides more isolation between and processes so you can reason more easily about arms of what parts of your application and can use what state the and I personally haven't l I'd I had heard of Emily but I didn't realize that it had that interesting features so I should for sure look at thinking if that's all the time we have we're moving more questions please catch up with mean old sites delictual um thank you Delaney and give a real world of people's have
fans thank you for the past ftx disease the top 10
Formale Sprache
Schreiben <Datenverarbeitung>
Kartesische Koordinaten
Eins
Einheit <Mathematik>
Gruppe <Mathematik>
Trennschärfe <Statistik>
Funktionale Programmierung
Kontrast <Statistik>
Substitution
Default
Schnittstelle
Parametersystem
Lineares Funktional
Sichtenkonzept
Dokumentenserver
Kategorie <Mathematik>
Abstraktionsebene
Softwareentwicklung
Ausnahmebehandlung
Quellcode
Biprodukt
Kontextbezogenes System
Elektronische Unterschrift
Kugelkappe
Arithmetisches Mittel
Teilmenge
Benutzerschnittstellenverwaltungssystem
Projektive Ebene
Socket
Information
Programmbibliothek
Refactoring
Ordnung <Mathematik>
Lesen <Datenverarbeitung>
Fehlermeldung
Telekommunikation
Web Site
Zahlenbereich
Äquivalenzklasse
Code
Socket-Schnittstelle
Systemprogrammierung
Weg <Topologie>
Domain-Name
Software
Netzbetriebssystem
Datentyp
Wrapper <Programmierung>
Programmbibliothek
Delisches Problem
Modelltheorie
Operations Research
Softwareentwickler
Hilfesystem
Soundverarbeitung
Mailing-Liste
Physikalisches System
Elektronische Publikation
EINKAUF <Programm>
Quick-Sort
Diagramm
Bus <Informatik>
Wort <Informatik>
Partikelsystem
Kernel <Informatik>
Demo <Programm>
Domain <Netzwerk>
Virtualisierung
Compiler
Nebenbedingung
Schreiben <Datenverarbeitung>
Raum-Zeit
Typentheorie
Gruppe <Mathematik>
Protokoll <Datenverarbeitungssystem>
Skript <Programm>
Dateiverwaltung
E-Mail
Schnittstelle
Softwaretest
Addition
Hardware
Sichtenkonzept
Datennetz
Softwareentwicklung
Bitrate
Kontextbezogenes System
Multitasking
Reihe
Scheduling
Menge
Rechter Winkel
Einheit <Mathematik>
Programmbibliothek
Programmierumgebung
Fehlermeldung
Schnittstelle
Subtraktion
Softwareentwicklung
Mathematisierung
Patch <Software>
Mathematische Logik
Open Source
Virtuelle Maschine
Modul <Datentyp>
Datennetz
Netzbetriebssystem
Direkte numerische Simulation
Datentyp
Programmbibliothek
Ganze Funktion
Modul
Open Source
Default
Rechenzeit
Modul
Datenfluss
Chipkarte
Netzwerktopologie
Patch <Software>
Rückkopplung
Speicherverwaltung
Data Mining
Resultante
Bit
Programmiergerät
Reihenfolgeproblem
Prozess <Physik>
Datenparallelität
Formale Sprache
Adressraum
HIP <Kommunikationsprotokoll>
Kartesische Koordinaten
Übergang
Kernel <Informatik>
Videokonferenz
Datenmanagement
Prozess <Informatik>
Minimum
Umwandlungsenthalpie
Lineares Funktional
Netzwerkschicht
Assembler
Reihe
Speicher <Informatik>
Systemaufruf
p-Block
Elektronische Unterschrift
Systemaufruf
Rechenschieber
Funktion <Mathematik>
Projektive Ebene
Speicherverwaltung
Aggregatzustand
Standardabweichung
Telekommunikation
Gewicht <Mathematik>
Ausnahmebehandlung
Implementierung
Kolmogorov-Komplexität
Term
Code
Netzadresse
Physikalisches System
Systemprogrammierung
Puffer <Netzplantechnik>
Socket
Adressraum
Socket-Schnittstelle
Modelltheorie
Operations Research
Softwareentwickler
Speicher <Informatik>
Grundraum
Hardware
Implementierung
Programmiersprache
Einfach zusammenhängender Raum
Fehlermeldung
Wald <Graphentheorie>
Rechenzeit
Mailing-Liste
Physikalisches System
Quick-Sort
Inverser Limes
Videokonferenz
Diagramm
Druckertreiber
Formale Sprache
Normalvektor
Einfach zusammenhängender Raum
Digitales Zertifikat
Datennetz
Web-Applikation
Formale Sprache
Gebäude <Mathematik>
Keller <Informatik>
TLS
Web Site
Gebäude <Mathematik>
Kartesische Koordinaten
Mailing-Liste
Information
Web-Seite
Keller <Informatik>
Web log
Kernel <Informatik>
Einheit <Mathematik>
Server
Inhalt <Mathematik>
Information
Konfigurationsraum
Verkehrsinformation
Demo <Programm>
Mailing-Liste
Digitales Zertifikat
Schlüsselverwaltung
Netzbetriebssystem
Default
Programmbibliothek
Abstraktionsebene
Mathematische Logik
Web log
Server
Fehlermeldung
Punkt
Funktion <Mathematik>
Elektronische Unterschrift
Konfigurationsraum
Mereologie
Strebe
Mailing-Liste
Kartesische Koordinaten
Elektronische Publikation
Konfigurationsraum
Folge <Mathematik>
Prädikat <Logik>
Hydrostatik
Hauptideal
Softwareentwicklung
Rechenzeit
Konfigurationsraum
Kartesische Koordinaten
Twitter <Softwareplattform>
Web-Seite
Web log
Keller <Informatik>
Homepage
Unendlichkeit
Zeichenkette
Zufallszahlen
Verzeichnisdienst
Socket
Verschlingung
Datennetz
Typentheorie
Funktor
Hydrostatik
Homepage
Kernel <Informatik>
Unendlichkeit
Zufallszahlen
Einheit <Mathematik>
Socket
Typentheorie
Booten
Funktor
Folge <Mathematik>
Prädikat <Logik>
Hauptideal
Gerichtete Menge
Gruppe <Mathematik>
Rechenzeit
Konfigurationsraum
Kryptologie
Variable
Keller <Informatik>
Web log
Zeichenkette
Dynamic Host Configuration Protocol
Funktion <Mathematik>
Thread
Client
Programmierumgebung
Streuungsdiagramm
Prädikat <Logik>
Web Site
Gerichtete Menge
Gruppe <Mathematik>
Web log
Homepage
Keller <Informatik>
Homepage
Virtuelle Maschine
Benutzerbeteiligung
Zufallszahlen
Typentheorie
Mereologie
Client
Dateiverwaltung
Booten
Inhalt <Mathematik>
Funktor
Offene Menge
Kernel <Informatik>
Mereologie
Komponententest
Nabel <Mathematik>
Flächentheorie
Information
Raum-Zeit
Festplattenlaufwerk
Softwaretest
Typentheorie
Entropie
Dateiverwaltung
Kontrollstruktur
Schnittstelle
Metropolitan area network
Softwaretest
Datennetz
Gruppe <Mathematik>
Ruhmasse
Kontextbezogenes System
Mechanismus-Design-Theorie
Entscheidungstheorie
Web log
Scheduling
Menge
Würfel
Festspeicher
Hypercube
Ablöseblase
Client
Ablaufverfolgung
Programmbibliothek
Programmierumgebung
Pufferspeicher
Lesen <Datenverarbeitung>
Schnittstelle
Subtraktion
Teilmenge
Firewall
Wasserdampftafel
Mathematisierung
Homepage
Quellcode
Virtuelle Maschine
Weg <Topologie>
Zufallszahlen
Reelle Zahl
Flächentheorie
Datennetz
Netzbetriebssystem
Direkte numerische Simulation
Widget
Programmbibliothek
Thread
Generator <Informatik>
Konfigurationsraum
Raum-Zeit
Binder <Informatik>
Modul
Nabel <Mathematik>
Zufallsgenerator
Auswahlaxiom
Komponente <Software>
Firewall
Bit
Reihenfolgeproblem
Konfiguration <Informatik>
Formale Sprache
Versionsverwaltung
Kartesische Koordinaten
Binärcode
Kernel <Informatik>
Internetworking
Einheit <Mathematik>
Prozess <Informatik>
Kontrollfluss
Druckertreiber
Inklusion <Mathematik>
Quellcode
p-Block
Ein-Ausgabe
Konfiguration <Informatik>
Rechenschieber
Arithmetisches Mittel
Framework <Informatik>
Funktion <Mathematik>
Verschlingung
Systementwicklung
Projektive Ebene
Information
p-Block
Message-Passing
Aggregatzustand
Web Site
Hausdorff-Dimension
Implementierung
Term
ROM <Informatik>
Code
Framework <Informatik>
Task
Physikalisches System
Systemprogrammierung
Message-Passing
Notebook-Computer
Modelltheorie
Booten
Speicher <Informatik>
Softwareentwickler
Graphiktablett
Implementierung
Trennungsaxiom
Prädikat <Logik>
Physikalisches System
Quick-Sort
Keller <Informatik>
Druckertreiber
Offenes Kommunikationssystem
Formale Sprache
Mereologie
Mini-Disc
Normalvektor
Hypermedia
Medianwert
Systemprogrammierung
Fächer <Mathematik>

Metadaten

Formale Metadaten

Titel library operating systems
Untertitel reject the default reality^W abstractions and substitute your own
Serientitel 34th Chaos Communication Congress
Autor Preston, Mindy
Lizenz CC-Namensnennung 4.0 International:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen.
DOI 10.5446/34818
Herausgeber Chaos Computer Club e.V.
Erscheinungsjahr 2017
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Traditional models of application development involve talking to an underlying operating system through abstractions of its choosing. These abstractions may or may not be a good fit for your language or application, but you have no choice but to use them - you can only layer more abstractions on top of them, to try to lessen the pain of a bad match. Library operating systems let you write applications that use better abstractions in your own language - either someone else's abstractions, or your own.
Schlagwörter Resilience

Zugehöriges Material

Video wird in der folgenden Ressource zitiert

Ähnliche Filme

Loading...
Feedback