Merken

Bazel

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
OK so you want to get loans Good afternoon here across the 12 of nice to have you all you're on the next lecture is from long calcitic about all by using the law of sea I enabled to from looking the sources some years ago I guess on I'm I'm really looking forward for his talk and and just more reminder of these everyone you all watch lectures year of this twice feedback it's quite easy just or go to the uh true so all lectures visited in the rating it's something like this rating with time comprising commons and no 1 to 5 star rating which really outsourced to of improved the quality of the of conference so yeah these only because some people could minimize so said no after uh and set is also yeah it's you should just started so please so it's a little some and solve for class k the 1st thank much and thank you for the opportunity to introduce their trust and so the 1st question is what is space as already mentioned it is a build tool that is it organizes solute compiler or create on artifacts libraries executable from source is open source since 2015 so appropriate for the Conference uh but it has a a quite long history as a gradient onto with all the implications that has an impact taken it means we know the 2 works the more interesting question is why do we want yet another look to so the historic motivation right with started but what is known as the is in the 1st place was tool madam that's gives well as good as the approach to have 1 big repository was and he's majority of all code that is developed at Google and everyone works at that the repository from head and so you get quite because this was all tendencies in that and conceptually you want to go on everything from source so that is the scenario with which favors stealing at start box is still dealing at today so the the line is really about recursively doing things in parallel at the quite oppressive was caching of operations but are you sure that we still keep correct in the sense that you get the artifacts as if we would use no catch at all until completely fresh from source right now and by the same not I mean by by by identical or not so that's and whether so fast correct social is comes from but I think you may have a smaller code base is can be quite interesting so 1 of the aspects I quite like about this is the declarative style of the files which had the advantage that you separate the concern of of writing code I want to write some libraries the and he with the code from the concern of what is the best
way to compile that to cross the bonded to a different architecture and so on and yet so that declarative studies in central mountains point for you but you only need to specify 1 point on that and not updated everything you find a better way to compile code of something which and announces generic tool that is you can provide your own rules in a declarative style to build things and I will go through an example to what's in the talk OK so what is the look and feel of
basal that's so that was a simple Hello World example written Cecily remained program simple programming and the library so you also provide a library which usually consists of some kind
of science and some implementation for some files so that simple scenario how what it is construct to both the so well the 1st thing is to provide a workspace file which is the training and the fire the idea of what's this thing on the 1 hand specified where the the scope of the source tree and so all possible relative to the directory with works this and this and the other but workspace file is defined external repositories or external sources which you might want to include in your built in that simple example that is literally in the file and then he would write with cause which in that example look as follows so you have a
library the library say OK survivor it has a name so that is the let's see that we found is that the nobles by the 1 parallel to the all to the to the library files as you give it the name you specify what are the source files and what I have found and that's case injustice crops and then you have the executable so you say there's a sissy binary it has a name it has a and it has a dependency on a library and a specified the it's good labeling of that library so you have the the past to the location of the books file and then I colon and then the name of the rule in that below 5 so said that C. binary depends on that library OK so let's just look and feel attractive style these online sources and that the language there is an and it's quite well not in what is not here so all the things about which architecture and compiling for they have to care workers composite which C components on is nothing you have to specify each time use it all right a library of binaries will focus on the coat and that is specified other places once for the whole project OK so now how do you build that i the library and binary from that description so the general
way Bayes rule is that you 1st multiple-file all plus the 1 that is specified from a target but then also all the ones recursively needed it as dependencies we analyze the dependencies between the targets and then you look at the rules among the tools to create a a plan what to do with the graph of actions and you execute them harmless if done so already and for example having you know to catch and you say yes for these inputs I already run that action that sales what on and subsequent rules the update just after the graph of the order of dependencies that you keep in memory so basically uses a client-server architecture on the local machine so when you start is the 1st time in a work space it starts some the background and then communicates to that over all the requests which have the advantage that you keep the constructed graph in memory and only update by watching the underlying file system and as set the they main use cases that you have always dependencies from source in the same repositories of that crop can be quite large and that which was not the computing time every time you want to build something OK so say we want to
build this hello all binary the passing OK it's is look the title what you find it's in the top-level directories we look at the top level that file yeah so look at the concept the package when that things so all all and directories below a file except those subdirectories that have a separate both of that is what we call that package a unit of sources described by common fight and then you read the rule and you'll find that while there 2 dependencies the source files and a and actually again there's an implicit depends on the true translated change the specification of which tools you want to use you notice that the cytosolic didn't have to read again but did draw the diagram so again with the same process you don't like because calling you just look at the next package mentioned regions that subdirectory and you look at the old file there are they find us dependencies to blocks so you look at the content of the directory find because pending matching files no discovered all the things you need for a vote and then you construct x graphs so from that library that call on a low you get the lower actions how to compile as well as to how to build a library so these uh 1 compilation born leader lie reaction and from the top of the column world target this see binary rule you get another actions to compile the source file and then link with the library to get an executable so this is the actual actions where you have to read the source was meant invoke a compiler but the tracking the whole graph with all these logical but is what keeps the bullet correct and the easiest way to see that is if you added 5 new fall into that libraries so none of the actions directly affected but you notice that the directory has changed so invalidate everything that depends on the director in the particular the cops and that forces you to real where you evaluate library rules and once you do that you see 0 no I need to generate an additional actions and then that recall that actions and so the final
output OK as mentioned in the
main part of the action what are called reflection so indications of a compiler linker whatever FIL take the
most resources for the vote different most time so if you etc. so it is particularly interesting to avoid unnecessary actions again into dependency graph which means if nothing has changed we don't have to review the action and in particular we all the inputs so we are sure we're not losing anything yeah so we can since each recording was not characteristic times about anything you can actually catch pictures by content of the file and that at every level so the fuzzy it for free using just common and you do the 1 combinations that you find the optic changed and can skip the rest but for that to work it's important that you know that all you have to all the inputs and outputs because if you missed something then while that assumption that you have the graph correct it doesn't work so if only you can only read the inputs it to be jettisoned at for rule and none of this kind of approach but fortunately based on the way to help you doing that correctly you can ask it to run in what we call center boxes these are a security future but they still provide some formal insulated environment we only have to declare inputs and where only copy of the declared out what's so depending on the operating system and amount of effort you want to work that can be more sophisticated you can say no sense to the just 1 ever since then along which then doesn't have a lot of what all this in the but already helps quite a lot is that you create a temporal directory copying what actually some and only that file that indicates and before that rule and then copy all of the the declared outputs that simple approach Hajime also basic kept all of the arrows of not specifying dependency and you can go for that is that implemented to candidate change shorter and that to appraise the tensions definitely implement and then you should not indicate only putting it but that's track of all the inputs has another advantage because now you know which files are actually needed so you don't have to compile on your local machine you can also do the combinations that remotely at a different machine so like you data center form and that enables yet another quite beneficial operation so the dual execute remotely then you can use the same compute center is the police and so on and then you can have a shared actually catch and remember I said that the main use case of the the main internal use case is not of engineers working the same code base so quite likely that someone will have compiled the same source of that you have in your work already and that way you just gonna catch it you get the answer but immediately and then continue
OK so much for the execution model and using Bayes rule you see some of the people in rules of Bayes rule in particular specialized on for the language that are the more important ones that lead to more what wants to the authors of this so in particular C Java and a couple other languages that's also generic rules of that generic rules 1 of the all including 1 will call a general mistrust specify a command to be executed on you have some fun like variables that it expounded in the way you would expect a mentioned that rule because that is basically the only rule you have when you use the traditional make and you see that it can compose everything from that show uh but still any
specialist knowledge for every language is something that small-scale definitely want to use in the open source with were the hundreds of languages and you can't get specialized knowledge of each level language into the photos tool so need a way to extend the language and that always has a domain-specific language quality skylarking in which you can describe your own literals the language has a all users prices syntax so all the syntax should be too scary 14 on but it is not full Tyson anymore it is restricted to simple subset of size and In particular don't know any reference to global state so that you can imagine tuple of locally without side effects and at the time domestic reproducible way I OK and to give you a feeling of how they can be extended and all that looks like it do a simple example of something that is not a mainstream programming language wants to develop rules still played said not mainstream but so too incomplete but for the purpose of this talk it's enough to know that they take generates PDF files like this letter music from textual description text text files and the state has for other files images diagrams but also in part of text files and there is a sequence of commands you might want to execute knowledgeable but this talk is about to build system and not OK so the 1st approach I took when I was faced with a problem this same OK 1st of all what to the lady who looked like while probably want an entry point which is what is the main document and a bunch of other files that you yes and many of us crypto at the time this so 1st of all cause the Data LaTeCH the correct number of times um take care of all the time stamps that are implicit in such a process especially you implicitly cannot falsifies into for each of them you get another timestamp and the man want and for producing builds also uh copy only input into a temporary actually do not rely on boxing to avoid polluting the internal workspace where I should mention that sounds and this fact it was building and so on but as every single system based on generates and executes the commands and write the output and find that is also the source tree with and what we don't which find than that for probable system OK so you have a script and well the interface and then the 1st approaches what we call a macro so you say yes I can but like can I express it in terms of rules that are already present in the system so wasn't the case we just have a general so this index is as you would expect for our eyes that language is to say Death and the name you provide named parameters and give some the foot Aquarius which probably is only useful for the additional sources because you can have a single file document and then he just compose your general was the the pages highest Monte due to name for the rule is this for the sources an and will book the string that is the command you want to run you get the outputs and you also get the implicit dependency on the 2 was so you just that whenever you and what that would you have a dependency that is vector based on your wall to in this case is all a script that does the correct locations but this means that if you change that then we know all of that histogram insult and have to be typeset again but you know it this this written your macro that just met to a general then you can note that new thinking about how you write a lot statement just defined relative to the workspace and a from that part I want to get into my both 1 command the you specified in this case I take and then you can use the rule in the same declarative style that you see father rules just main main sources that works quite well the but you have spent a lot of effort
now but yet and yet this again a bit curious central point they have maybe later want to change the rule and 1 place where to do it and you don't need to go through all limitations to can also helps symmetric and exp on more than 1 rule saying all given a general and then also had a rule that uh just a executed rule that prompts the presentation and also um always built kind of summary with many pages on on a single page and so on and yet next thing you
notice is that we're in the particular
conflated to start sinking into groups of files you that slide and the content of diagram so is basically a set of files that you want to declare and for that base said something building which is qualified it's name over clients that may be used falsified but also may be generated it's this case you get a dependency on the underlying target the names of the files so you maintain that said at 1 point and web it's used the dependencies that captured correctly and you can add 5 true internal argue group that is you would have the elements moving up the coats and implement in a slightly more memory efficient way that is quite useful concept when you think in groups of sources belong together and then
at some point to come to a the point where well you find out that Microsoft quite well and what the some 6 missing the 1st is you're missing type checking in the sense that you have to remember that the main part of the argument is a single father and that the source is the list and you do that wrong you get quite confusing error messages and the other thing you'll notice eventually is that there is a limit of how long command can be so the limit on Oct not terribly small on Linux but if you can it so you change script to say OK instead of providing all the arguments I provided was 1 file which contains all the parameters you need to know how to go the source files and you change your mark
to rule know what I'm still the only thing that changes that 1 file which contains the specification of what I want to build OK and then you say native peoples ruled that makes that name rule and specify the attributes of that rule together with the expected type so suspect made to be a single label I expect sources to be list of labels and also declare that implicit parameter on the book tour specify the outputs and you specify an infinite implementation of natural which
is a bit more surface compute all the files in need and then you have something called a file action which tells us there is yes I need to write a file all generate file with a given content that only depends on diversification of on the contents of the source files typically meant for parameter has think the same problem of not uh of exceeding the limit of a command line is something you with see and Java and song combinations also deals and the source tree gets big enough and that all the main compilers also no parameter 5 so that is a typical use case for a pilot action then you many computer command-line as you would want it as a list of strings appearance to compute the arguments you could say and there's an action we
specify inputs and outputs a list of files underspecified list of strings but that can be called basic and give additional bonus you can specify the progress message so that in the interface to see what is actually happening no exotic invocation at all executing general of our yes so have
additional benefits is that you know I just can't specify a list of arguments instead of a string that is been interpreted by national and you have to be bit couples quoting and the and the meaningful progress message that is additional Atlanta's on top of the already mentioned think that you get checking whether you have all needed parameters provided and 2 of the correct type and you can now get these to actually depending each other as to what the limitations of your command line length works nicely but
there's no additional saying that it's good for both OK so to the lactic example you start collecting markers that these ideas
and these are my annotations for mathematical things and these are all the fantasy so want to leave the slides and your organized but on a tight groups and then you would say just input that fight how would you do well the 1st since it's easy their
content of i and I wouldn't protest 1 file 1 statement and then the contents of the all the 5 that high group while that only depends on the names of the contents of that fire so you can easily specify of and find action right don't of the status in it except now we have a problem and whatever you do that generated 5 you implicitly also depend on these are the files that went into that specification I knew what they expected dependency and a similar problem we interested see already on and talk when at the end of the library and the library and not only depend on the generated library cause I implicitly also depend on manifolds but I want to use the library so there needs to be somewhere where 1 rule can pass on a rule that depends on its additional information and that is what is cause provide us so state lady info is provided that make the name available and what it intended so far that the rule can have a return value which was then a list of providing a surprise as basically a name when it dictionary so once you have that then the consuming
rules we've seen so far and compute the inputs and then you composite actions can go through sources and asked if that provide all that name is available in that file and if so then access use of the provider OK so these are with that example copper wire shoulder the main concepts that you can use and your Accenture language you main constant them more specialized and ready made uh the functions already that and I haven't seen that you can extend that you can also start and what I hope to make a sequence substantive start with simple macrobiotic Ponce just to what you know what my command and then later against the final specification at additional cooperation with other rules without changing the RIRs already existing uh because so that rule the OK so
to sum of I've shown that an of what is particular about this the year declarative loads fonts but is still a generic to that is a kind of thing 1 boat faults In a past select language and execution model based takes all the dependencies which allow which guarantees correctness of the results because we know when the output is outdated yes and boxing that helps us to make sure we declare all the inputs and outputs correctness correctly and that full knowledge of the book trough analysis and also for speed because we can more aggressively Karush there's content we can't execute remotely because we know which party have to send them we can do more things in parallel and this remote execution also culture check-cashing thing of the critical race composite and results and bases open source so you try itself
these are the contact information here the home picture of many lists there's the repositories Marilyn get and there's an issue tracker there is not very active IRC channel so many this is probably the better way to contact and I release artifacts assigned to that key and yeah that's an overview of the and and all 4 questions the belief I think it was a book that you all yeah OK so the question was who's currently working at Faisal and what circulation so from whom there are what's a roughly about 30 people working on Bayes or not all of them full-time some also on mean and said it's open source and also used internally there are some internal
extension that talk to the internal catching and the internal source control system smoothness some components which are not open source because they don't make sense in the open source but he also take that at the broader scope of space it's about so if people working internally at Basra and externally meet regularly get contributions for a fairly small number of persons but it is still a case the fast majority of whom itself from people with whom commented that out of and and the people and you and has and use the whole point you know this because of the so the question was in the traditional C project using other tools than at configure state you can't say which for example which is Scialabba you want to use and how that works the space and the answer is unfortunately and to some extent but not very well and and because the tradition is that you have your big political positive work I have quoted dependencies in there is some approach to that because they mention the work specified they can specify external repositories and give them a name and that all sink Q would seem so it's a lot of very similar to the same OK there's a pre-compiled library that's a binary the father and files um and they by changing your works this according you can switch to 1 of the other acts on dependency there is no such thing as the object was yet for of but uh and there are plans and discussion about how to best at such a sink to Bayes above that is still a work in progress on at that the the illustration of they do this of and was OK so the the question about where when the basis of some applications well and that yes and no so it's the technique used to select client architecture but that all wrong your looking machine so you basically started that for each works that keep the dependency graph memory so we set in the 1st in Europe and the pros and the background just that the other persistent process to keep the dependency graph a memory for some time because the typical thing is you work on the kobe thing new test something work again and don't want to compute the again so in that sense it's this phantom architecture but it's meant to run on the front cover interesting machine and just communicates over the to pick you must know this to keep some process as to keep the formation of system memory it is also client so in the sense that it supports remote execution as an optional feature so that then the wall what is the basis of the 1 that 1 the build and is in memory over multiple locations in the same workspace is then a client to a remote execution or more catch a project that's all up you can have a single single machine and
run it you you don't really notice or it's not disturbing that is then starts to process instead of 1 I don't mean it's not a local so there are many ways for compiler actions but just 1 process that survived the and to keep the pressure memory in case you needed to which it again but any other questions do and so on and so on and so that the question was whether and or will be providing enabled files of laser and another and gene but can the active few rules applications already provided was the basis of there is that of the plants but I'm not sure what kind of think that you have to ask the benefit of the project this sort of thing other questions for the basis to in the to the device in case and that I would run it on a mobile device no and bases supports building entered application that is then that the applications of and to be run on on on the device of the build that typically on on a different the and the and there's some issue with understand the question of whether pages on the end user device in the depends if you're developed yes this is open source you can use it on your desktop or whatever and not the application you build a a normal C find or whatever file you don't need a basis to run the the program that you compile the same way you don't need make run a problem that you put a snake so it is in that sense is the normal to the other but to you can use it on whatever machine you want to build something and that the artifact is independent of the tool used to create it yeah the time the yeah thank you for it to work it was all the rage all the OK so the question was about integration into an IDE there are they exist some integrations for for some ideas that we get practice so it definitely exists for intelligent and I think that's in so I'm person using either of them but they have activation and as far as I can tell the WikiLeaks that quite happy women there is also and a generic mechanism were basic and report that so you can enroll is a from whatever means and there's also machine report about what happened to uh during the built so the sequence of proteins that are serious about uniformity like so you can also your own then wraparound data that that has the information what would happen to think about a machine readable form but they are they exist I need for some ideas but this is what the heck out of what they this is the thing you should use them on a good question was about catching up OK that's else so stop at the 1st thing you have a dependency graph an anomaly in frustration and even considering that knowing then it is on this on your local machine a carriage that contents the the Hessian of the action that is the edge of all the inputs and the command and it's maps the output and you that output is still the latest result of that so for each action the makes execution is thought the hedge on this together with artifacts so you compute the catch here that is they are then you don't have rerun the action that has standard local caching was just 1 implication of this you can also specify wrote such which may or may not be on the same machine and we would then storm more such fish affection which of output a triple store you change and the trade fall back and run building between you can keep that some cash and there's your school's ability to get some confrontation toward photo of things and that can also be on the remote site typically also combined with the remote execution so this little than just under their a cash at and yeah no there's the protocol as well so in this domain levels of and yet it has all and the time the so the question was whether it's less trying Bayes lawmakers a cave universal project and so it's a small project and have you both have a may already that works then you happy with that then you don't have to change my personal space also for of new prior projects and that would happy with that mean is addicted to it but it doesn't mean I can't those small part of I mean you have to accept that business written many jobs that have job on each machine way want to run based on the that as a runtime dependency but for me personally find a sort of my desktop and work with that and I think it's definitely was for small projects that he's for somewhere you don't have all the infrastructure-based ready because of that declarative approach that makes it much easier to write both files and make sure that correct and it can change availability later at a single point we're making all the rules so I like that flexibility for small projects by me and if you have something which happy with then uses that if not and you can accept job a runtime dependency of rebuilt system than it seems that was trying is also for small so how do you do usage on OK the question was about resource usage compared to make and since you keep of full depends you got memory need a bit more memory also have a bit of all that just a little start of the JVM etc. but with nowadays there so that is not a problem but it's more and since you want to not recompute the dependency graph here that process and background which you don't have his leg of limitations no process lies and it is more but it's it's not terribly all means the ball sort of starting to again keeping that system and then it has on the size of the project of course if you would have a huge depends a graph memory then that is resource users with you don't have a snake but the make you pay the price of re reading all the make again once you room at the next location so basically treating type what memory it any further questions that this this sector protection yours and you and and you
Rückkopplung
Quader
Compiler
Klasse <Mathematik>
Gebäude <Mathematik>
Gesetz <Physik>
Raum-Zeit
Code
Computeranimation
Open Source
Quellcode
Freeware
Maßstab
Deklarative Programmiersprache
Parallelrechner
Programmbibliothek
Gerade
Schreib-Lese-Kopf
Caching
Nichtlinearer Operator
Elektronische Publikation
Dokumentenserver
Open Source
Güte der Anpassung
Quellcode
Bitrate
Elektronische Publikation
Rechter Winkel
Komplex <Algebra>
Surjektivität
Zentralisator
Punkt
Compiler
Ablöseblase
Gebäude <Mathematik>
Code
Computeranimation
Strategisches Spiel
Open Source
Maßstab
Parallelrechner
Deklarative Programmiersprache
Code
Softwarewartung
Programmbibliothek
Optimierung
Beobachtungsstudie
Caching
Elektronische Publikation
Schlussregel
Computervirus
Schlussregel
Generizität
Komplex <Algebra>
Deklarative Programmiersprache
Computerarchitektur
Programmbibliothek
Konfiguration <Informatik>
Wellenpaket
Formale Sprache
Implementierung
Gebäude <Mathematik>
E-Mail
Binärcode
Computeranimation
Deskriptive Statistik
Deklarative Programmiersprache
Programmbibliothek
Zusammenhängender Graph
Parallele Schnittstelle
Implementierung
Architektur <Informatik>
Elektronische Publikation
Dokumentenserver
Physikalischer Effekt
Schlussregel
Quellcode
Elektronische Publikation
Computervirus
Verschlingung
Projektive Ebene
URL
Computerarchitektur
Programmbibliothek
Verzeichnisdienst
Abstimmung <Frequenz>
Prozess <Physik>
Randwert
Compiler
Gruppenoperation
Mathematisierung
Automatische Handlungsplanung
Regulärer Ausdruck
Diagramm
Gebäude <Mathematik>
Ungerichteter Graph
Computerunterstütztes Verfahren
ROM <Informatik>
Raum-Zeit
Computeranimation
Eins
Übergang
Graph
Virtuelle Maschine
Einheit <Mathematik>
Deklarative Programmiersprache
Endlicher Graph
Programmbibliothek
Dateiverwaltung
Inhalt <Mathematik>
Kette <Mathematik>
Umwandlungsenthalpie
Architektur <Informatik>
Elektronische Publikation
Graph
Dokumentenserver
Schlussregel
Quellcode
p-Block
Binder <Informatik>
Ein-Ausgabe
Elektronische Publikation
Schlussregel
Gruppenoperation
Diagramm
Forcing
Festspeicher
Computerarchitektur
Ordnung <Mathematik>
Verzeichnisdienst
Lie-Gruppe
Abstimmung <Frequenz>
Spiegelung <Mathematik>
Quader
Compiler
Schaltnetz
Gruppenoperation
Mathematisierung
Gebäude <Mathematik>
Code
Computeranimation
Übergang
Rechenzentrum
Graph
Virtuelle Maschine
Weg <Topologie>
Datensatz
Bildschirmmaske
Code
Netzbetriebssystem
Zeitrichtung
Indexberechnung
Inhalt <Mathematik>
Funktion <Mathematik>
Caching
Nichtlinearer Operator
Elektronische Publikation
Graph
Computersicherheit
Temporale Logik
Schlussregel
Programmierumgebung
Elektronische Publikation
Ein-Ausgabe
Binder <Informatik>
Brennen <Datenverarbeitung>
Gruppenoperation
Funktion <Mathematik>
Ein-Ausgabe
Mereologie
Binäre Relation
Charakteristisches Polynom
Programmierumgebung
Verzeichnisdienst
Punkt
Prozess <Physik>
Leistungsbewertung
Applet
Formale Sprache
Computeranimation
Eins
Übergang
Homepage
Spezialrechner
Deskriptive Statistik
Maßstab
Gruppe <Mathematik>
Rechenschieber
Speicherabzug
Skript <Programm>
Flächeninhalt
Zeitstempel
Betriebsmittelverwaltung
Funktion <Mathematik>
Metropolitan area network
Schnittstelle
Befehl <Informatik>
Physikalischer Effekt
Applet
Quellcode
Ein-Ausgabe
Teilmenge
Histogramm
Automatische Indexierung
Ein-Ausgabe
URL
Programmbibliothek
Makrobefehl
Aggregatzustand
Zeichenkette
Folge <Mathematik>
n-Tupel
Diagramm
Zahlenbereich
Gebäude <Mathematik>
Term
Open Source
Informationsmodellierung
Variable
Digitale Photographie
Skript <Programm>
Bildgebendes Verfahren
Autorisierung
Programmiersprache
Soundverarbeitung
Binärcode
Elektronische Publikation
Open Source
Einfache Genauigkeit
Schlussregel
Physikalisches System
Vektorraum
Domänenspezifische Programmiersprache
Elektronische Publikation
Nabel <Mathematik>
Kreisbogen
Schlussregel
Diagramm
Formale Sprache
Mereologie
Makrobefehl
Zentralisator
Bit
Elektronische Publikation
Punkt
E-Funktion
Diagramm
Gebäude <Mathematik>
Schlussregel
Kombinatorische Gruppentheorie
Computeranimation
Kreisbogen
Homepage
Schlussregel
Gruppentheorie
Softwarewartung
Rechenschieber
Makrobefehl
Inverser Limes
Skript <Programm>
Punkt
Gruppenkeim
Diagramm
Implementierung
Element <Mathematik>
Computeranimation
Client
Benutzerbeteiligung
Gruppentheorie
Softwarewartung
Datentyp
Inverser Limes
Skript <Programm>
Skript <Programm>
Inhalt <Mathematik>
Oktaeder
Parametersystem
Elektronische Publikation
Gebäude <Mathematik>
Mailing-Liste
Quellcode
Elektronische Publikation
Brennen <Datenverarbeitung>
Inverser Limes
Schlussregel
Rechenschieber
Diagramm
Menge
Festspeicher
Parametersystem
Mereologie
Fehlermeldung
Compiler
Gruppenoperation
Schaltnetz
Applet
Computer
Computeranimation
Flächentheorie
Datentyp
Inverser Limes
Skript <Programm>
Inhalt <Mathematik>
Attributierte Grammatik
Funktion <Mathematik>
Implementierung
Umwandlungsenthalpie
Parametersystem
Elektronische Publikation
Default
Schlussregel
Mailing-Liste
Quellcode
Elektronische Publikation
Schlussregel
Funktion <Mathematik>
Ein-Ausgabe
Verbandstheorie
Zeichenkette
Parametersystem
Addition
Dicke
Elektronische Publikation
Mailing-Liste
Ein-Ausgabe
Elektronische Publikation
Brennen <Datenverarbeitung>
Computeranimation
Schlussregel
Gruppenoperation
Message-Passing
Mailing-Liste
Funktion <Mathematik>
Arithmetische Folge
Ein-Ausgabe
Datentyp
Inverser Limes
Skript <Programm>
Message-Passing
Schnittstelle
Zeichenkette
Gruppenoperation
Gruppenkeim
Information
Computeranimation
Service provider
Quellcode
Gruppentheorie
Programmbibliothek
Inhalt <Mathematik>
Topologische Mannigfaltigkeit
Umwandlungsenthalpie
Befehl <Informatik>
Elektronische Publikation
Mathematik
Physikalischer Effekt
Güte der Anpassung
Schlussregel
Mailing-Liste
Ein-Ausgabe
Elektronische Publikation
Gruppenoperation
Rechenschieber
Gruppenkeim
Funktion <Mathematik>
Rechter Winkel
Ein-Ausgabe
Makrobefehl
Information
Aggregatzustand
Resultante
Folge <Mathematik>
Gewichtete Summe
Formale Sprache
Gruppenoperation
Gebäude <Mathematik>
Maßerweiterung
Service provider
Computeranimation
Open Source
Informationsmodellierung
Font
Parallelrechner
Deklarative Programmiersprache
Gruppentheorie
Trennschärfe <Statistik>
Stützpunkt <Mathematik>
Inhalt <Mathematik>
Analysis
Funktion <Mathematik>
Umwandlungsenthalpie
Lineares Funktional
Addition
Elektronische Publikation
Open Source
Schlussregel
Quellcode
Ein-Ausgabe
Gruppenoperation
Schlussregel
Gruppenkeim
Formale Sprache
Last
Generizität
Ein-Ausgabe
Deklarative Programmiersprache
Punkt
Prozess <Physik>
Dokumentenserver
Versionsverwaltung
Automatische Handlungsplanung
Zahlenbereich
Kartesische Koordinaten
Gerichteter Graph
Raum-Zeit
Computeranimation
Homepage
Virtuelle Maschine
Mailing-Liste
Multiplikation
Client
Arithmetische Folge
Trennschärfe <Statistik>
Programmbibliothek
Versuchsplanung
Zusammenhängender Graph
Maßerweiterung
Konfigurationsraum
Softwaretest
Dokumentenserver
Graph
Open Source
Mailing-Liste
Physikalisches System
Elektronische Publikation
Objekt <Kategorie>
Arithmetisches Mittel
Zirkulation <Strömungsmechanik>
Festspeicher
Basisvektor
Elektronischer Fingerabdruck
Dateiformat
Projektive Ebene
URL
Information
Computerarchitektur
Aggregatzustand
Resultante
Bit
Prozess <Physik>
Punkt
Dokumentenserver
Compiler
Snake <Bildverarbeitung>
Kartesische Koordinaten
Raum-Zeit
Computeranimation
Homepage
Übergang
Prozess <Informatik>
Geometrische Frustration
Uniforme Struktur
Stützpunkt <Mathematik>
Versuchsplanung
Funktion <Mathematik>
Kraftfahrzeugmechatroniker
Gebäude <Mathematik>
Ein-Ausgabe
Arithmetisches Mittel
Druckverlauf
Festspeicher
Elektronischer Fingerabdruck
Projektive Ebene
Information
URL
Programmierumgebung
Folge <Mathematik>
Web Site
Gruppenoperation
Homepage
Virtuelle Maschine
Mailing-Liste
Bildschirmmaske
Domain-Name
Digitale Photographie
Datentyp
Inverser Limes
Inhalt <Mathematik>
Optimierung
Speicher <Informatik>
Grundraum
Graph
Protokoll <Datenverarbeitungssystem>
Open Source
Anwendungsspezifischer Prozessor
Rechenzeit
Schlussregel
Physikalisches System
Elektronische Publikation
Quick-Sort
Integral
Mapping <Computergraphik>
Caching
Basisvektor
Mereologie
Verkehrsinformation

Metadaten

Formale Metadaten

Titel Bazel
Serientitel FrOSCon 2017
Autor Aehlig, Klaus
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/32282
Herausgeber Free and Open Source software Conference (FrOSCon) e.V.
Erscheinungsjahr 2017
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Bazel is a build system open-sourced in 2015 after years of internal-only use at Google. It's main focus is efficiently building on large code bases achieving correctness by completely tracking all dependencies. BUILD files are written in a declarative style and new rules can be added via Bazel's extension language. The talk gives an overview of the basic concepts and design principles of Bazel, trying to explain why there is still room for yet another build system.
Schlagwörter Development

Zugehöriges Material

Folgende Ressource ist Begleitmaterial zum Video
Video wird in der folgenden Ressource zitiert

Ähnliche Filme

Loading...