Incremental package builds

Video thumbnail (Frame 0) Video thumbnail (Frame 920) Video thumbnail (Frame 1916) Video thumbnail (Frame 5011) Video thumbnail (Frame 13311) Video thumbnail (Frame 17114) Video thumbnail (Frame 29553) Video thumbnail (Frame 42343) Video thumbnail (Frame 55133) Video thumbnail (Frame 57423)
Video in TIB AV-Portal: Incremental package builds

Formal Metadata

Title
Incremental package builds
Title of Series
Author
License
CC Attribution 3.0 Unported:
You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor.
Identifiers
Publisher
Release Date
2017
Language
English
Production Year
2017

Content Metadata

Subject Area
Abstract
The current CI infrastructure around nixpkgs has difficulties to build the whole package set in due time. While there were attempts to build every pull requests, these are not enabled by default because it requires even more resources. We will explore how to optimize even more the build process to meet the size of nixpkgs. We will survey with state-of-the-art build systems like scons, bazel and tup to see how we could improve incremental builds in nix. Based on nix-make, we will describe how nix could cooperate with the build tool of a given package to bring incremental builds at a finer granularity. In particular, we will explore how the intensional store model (as used by bazel for example) could help avoiding some mass rebuilds.
Ferry Corsten Near-ring
Word Presentation of a group Event horizon Different (Kate Ryan album) Right angle Event horizon Speech synthesis
Scripting language Presentation of a group Presentation of a group Computer file Patch (Unix) Feedback Building Multiplication sign Real number Data storage device Planning Product (business) Degree (graph theory) Data management Mathematics Personal digital assistant Phase transition System programming Video game Right angle Configuration space Window Physical system
Point (geometry) Building Clique-width Wrapper (data mining) GUI widget Link (knot theory) Computer file Code Multiplication sign Virtual machine Client (computing) Mereology Neuroinformatik Timestamp Derivation (linguistics) Cache (computing) Phase transition Object (grammar) Feasibility study Software Energy level output Compilation album Physical system Link (knot theory) Computer virus Wrapper (data mining) Building Projective plane Moment (mathematics) Data storage device Interactive television Code Computer network Timestamp Compiler Derivation (linguistics) Cache (computing) Software Network topology Mixed reality Phase transition System programming output Speech synthesis Right angle Resultant
Building Randomization Overlay-Netz Digital electronics Hoax Ferry Corsten Code Direction (geometry) Multiplication sign Correspondence (mathematics) Function (mathematics) Parameter (computer programming) Mereology Software bug Medical imaging Derivation (linguistics) Different (Kate Ryan album) Videoconferencing Cuboid Endliche Modelltheorie Local ring Physical system Overlay-Netz Service (economics) Simulation Building Moment (mathematics) Data storage device Rollback (data management) Bit Control flow Virtual machine Data management Process (computing) Computer configuration System programming output Configuration space Right angle Arithmetic progression Physical system Resultant Laptop Point (geometry) Game controller Server (computing) Service (economics) Computer file Link (knot theory) Patch (Unix) Online help Branch (computer science) Revision control Programmschleife Cache (computing) Gastropod shell Energy level Integrated development environment Software testing Configuration space Compilation album Quantum state Patch (Unix) Interface (computing) Projective plane Usability Directory service Cache (computing) Word Loop (music) Integrated development environment Personal digital assistant Mixed reality Network topology Revision control Statement (computer science) Gastropod shell Table (information) Window Flag
Presentation of a group Building Multiplication sign Correspondence (mathematics) Source code 1 (number) Set (mathematics) Mereology Total S.A. Virtual memory Formal language Software bug Substitute good Derivation (linguistics) Mathematics Different (Kate Ryan album) Computer configuration Hash function Flag Damping Physical system Exception handling Graphics tablet Scripting language State diagram Trail Real number Binary code Data storage device Drop (liquid) Mass Bit Demoscene Substitute good Derivation (linguistics) Band matrix Arithmetic mean Hash function output MiniDisc Configuration space Right angle Information security Spacetime Point (geometry) Bytecode Slide rule Computer file Link (knot theory) Codierung <Programmierung> Virtual machine Control flow Branch (computer science) Dreizehn Data storage device Content (media) Revision control Moore's law Differenz <Mathematik> Cache (computing) Band matrix Hierarchy Operator (mathematics) Gastropod shell Spacetime Software testing Implementation Mathematical optimization Address space Alpha (investment) Execution unit Distribution (mathematics) Patch (Unix) Interface (computing) Projective plane Mathematical analysis Content (media) Computer network Directory service Binary file System call Cache (computing) Word Uniform resource locator Integrated development environment Software Personal digital assistant Function (mathematics) Network topology Revision control Gastropod shell Musical ensemble
Point (geometry) Information View (database) Real number Data storage device Content (media) Mereology Sturm's theorem Mathematics Uniform resource locator Integrated development environment Algebraic closure Revision control Code refactoring Code refactoring Library (computing) Default (computer science)
Complex (psychology) Multiplication sign Data storage device Interactive television Content (media) Division (mathematics) Bit Content (media) Mathematics Cache (computing) Operator (mathematics) Right angle Musical ensemble Communications protocol Physical system
next speaker is a gilma do you so know him as Laius on github he started using an exit Mozilla a few years ago now he's working on a PhD on incremental builds yes thank you okay so let's start with a small background on me so I do my PhD in Louisville on dev near Brussels and just for the story Luverne enough I was a
huge biking event which is also the second biggest drinking event in Europe after the one in Vinick so you know everything about my user name okay it's
it's like a pan with a French word but yeah it's not very good as an introduction to this presentation so please mind with one little difference and that's very important right I contribute tunics packages of course and my github picture is a stone like that this stone is a stone from that castle
which are also contributed to build so now you already know that I like
building stuff right so I started my PhD on incremental builds and I want to feedback on this presentation so this is very important to me do not easy to interrupt the presentation if something if you want to ask a question in the meantime so let's start the presentation incremental package built what is incremental I went to dictionary which is always a good way to start except that in this case it doesn't mean I think of incremental is something that occurs in increments okay come on so what is increments it's the amount of degree by which something changes okay we cannot do anything with the definition so I just came with mine an incremental build system is something that works with very small steps we can do eat them separately and work with them we can use all the build projects and we use them so we do not have to do things that's already done and we also of course need the ability to detect what needs to be done so this is the plan of this presentation where I will take three examples from real life one with Firefox one which I train the window manager and one with the store the file for example shows why it's important to have small steps if you ever try to build Firefox then the build phase takes one hour and everything else is basically negligible compared to the huge builds time I was playing with that package and I had to change the fix up phase and of course I made a typo in the bash script and then what everything was lost okay so we really need checkpoints I mean it's just like when you are doing
rock climbing your client being okay and then at some points there is a problem
and then if there is no checkpoint in
WoW you have back 2.0 right so we really
need that kind of stuff just not to lose everything all the time so how can we do that a very simple idea
just okay we already have parts in every build we have different phases so we could split them in different packages so that we once one phase is finished I mean it's done we can work with you on the next one you know it doesn't always work for Firefox is good but if the failure occurs in the build phase then basically you have a still the same problem that you lose one hour of build phase it's not good for a store because you will have every phase in the store and what does it mean can that even work but these ideas are already been implemented in some places with wrappers Firefox for example as an external wrapper which is another package that just writes the wrapper that's where you can change the wrapper easily without changing Firefox all the time okay so incremental width abouts small steps and in fact Nix is incremental in some way it's just that it's incremental at the level of package okay and just more step phonics is a package at the other hand we have build systems they already manage incremental builds of package like Firefox as its own build system and it's also incremental but we are not able to use that now in mix because we want things to be very pure so there is no interaction with the external world but so the idea here is to use existing build systems and to make them interoperate with NYX so that we can achieve incremental builds within its first build system that everyone knows is make and well I will not speak too much about make because it works but there is nothing you can do that's correct or in the sense that we like it we make will never be pure that's not in the design basically it use timestamps and we do it one time Sam's in the store for example it requires to have the previous builds in the same tree or as file in the tree so you need to add that as an input to the package and everything gets early but there doors that are quite interesting like see cash we know see cash which people okay tsukishima is compilers invocation so you can wrap a compiler code with that and if the same compiler code has been made before it will fetch the widget from the cache even better Mozilla developed the shared seek a while this sketch of previously builds stuff is shared on the network so you can reuse a build that someone else did and well this is a very good and robust design because I mean it's the design behind Nix right there is a shirt cache a binary cage that you can use and we can that we are sharing and this is used to replace building of some packages if they were already built before so caching is very good idea that we will reuse later but I want to show a small project by alcohol which is Nix Meg and Nix Meg basically allows you to it's a build system at the moment it only works with very simple stuffs like that you see that it's 15 commits okay so it's not very active but you can still do things like that there is one derivation come by the C producer derivation and the derivation just generates dot o file and then there is the link derivation that just takes all the file and produce the binary so we can use Nick's to do incremental computation at a finer level than just packages bats okay is you can do very small steps it's compatible with Nick's of course but I mean it's even worse than before every single dot o files end up in ends up in the store and you also need to pause every project to Nick's make okay so if you're using whatever before like basil then you need to write another layer to port it to a next medic this is not feasible speaking about basil this is an amazing a tremendous project from Google look like they are very proud of the stuff fast or correct b2 and it's a project that as most of things right they managed to build every command they can basically cache every command and put that in a shared cache they can even ask another machine to compile that step and then get the result so this is something that we would like to have it's also
really really correct there is sandboxing going in there but you know it's so good that it does exactly the same stuff as Nick's so we are when you try to make both of them work together they're fighting to take the control be the one that manages sundogs and do not let the others do other stuff so it's quite difficult to use it in fact it's used at Google and at Google everything use basil so it's quite easy but with Nick's and Nick's packages we have something that's much more a taraji news I mean the package with make package with SBT packages image and we cannot use just one build system to rule them all so is it possible to do something intermediates and my solution is okay we want caching we want to be able to cache smaller steps than just packages can we somehow allow the build system to access an external cache while remaining correct and to do that we may need the help of mix built to provide the same interface but in the first attempt if you do not care too much about correctness then it's very easy to implement basically you making you build not so pure allow access to an external store and allow for example ckh to access that store it looks like that you call make I mean next build stylist and box next works in de Courcey cache for example and then CK's shrubs in the environments a circuit to discuss with the external store as simple as that if you trust CK Street to do things correctly then you will have correct builds of course you cannot always trust the cache so we will have to implement some checking on top of it but this is the basic idea and if you start with something simple like that then you can port one package at a time try to make it work start maybe with big package like Firefox and yes this is my master plant this is something that I went to do for my PhD the ability to use incremental builds from the build system within these and to be able to go both direction to make them cooperate so at the end we should be able to rule over the world right with the system but still a work in progress okay any question about that maybe
before the next part I mean you can see us questioning normally you have a does it do you have tends to work like this stuff by check output but do you have like one or two words how okay I can say two things yes the intention store would help I will speak about that later and what can I say basil or really does something like that much more advanced that was ckh does X ability there's a lot of other stuff that we do not want so we may need to import that part of the code and then know if it works for them it should work for us to write in if you want more correctness than what they achieve which is already quite AI then we may still work on it implemented the the interface here may not be just Rev access to files it may be okay I want to build to call that comment with these files with dis environments and then we let NICs build build run the command and produce a case result so if everything is in the ends of Nick's buildin should be clean okay but this is more strict and this needs more I mean it needs to change a bit of C cache works at the moment so the more cognizant want and the more work used to do of course okay I was just wondering if very results instead of putting them in okay so yeah the idea about this turf is that this is this is not defined this may be the next or this may not be it depends on what you want to do if this is the first time that I use something like that the out of you that want to have like yaki Celtic stores when you have one next door for the packages then one next door for other stuff that are less important that can be garbage collected more fun and maybe another nick store for custom projects I'm not sure that this idea of the Nick store is the perfect way of doing caching the idea of Nick storage to have when you need the directory because you need to access the files but it may may be more efficient to cache compressed versions of the files for example so you may not want to you may not want exactly a next door but you need some way to catch stuff okay let's continue anywhere you can ask questions later so I know the use case I had I was I had a problem which I tree which is my window manager and being the window manager is something that you need every all the time but to reproduce the bug I had to use it on my main laptop because basically the bug a pen when I unlocked it and docked it again so I mean this was the only way I found to reproduce that bag and so to test new versions of I tree I had to propagate them tunak tunak configuration I'm you all already had something like that's why you want to test something and it's very complex because it needs to go into the mixers configuration and how do I do that my typical Dybbuk session looks like that I use Nick's shell I try to patch see if it compiles etc if I can do that then I extracted this and then I generate an overlay to build a new package and I check that it builds with Nick's build then I insert that package in exercise and just I rebuild Nick service and then I will start I test and if it works I mean that's fine if I can reproduce the bug it's not that good and if it crashed everything that I need to rollback of course and then back again because it's a loop I mean when you are trying to debug something you have to insert the back statements then maybe it starts EVP stuff like that so it's quite complex I mean and it would be so simple if I could just you know compile ice ray and say okay put it in the store and use that I know it's not clean but then it would be easy right and there are solutions to do that should maybe not say that maybe we'll need to cut the video at some points but it is possible to among the next or with right but yeah okay you should do it more clean but very rocky solution is to insert a SIM link into the next or make a fake derivation that justice evening to somewhere else you are your own directory or you project the return then there are some technicalities which you know self loops and stuff like that but spasibo and yeah you can go straight to the solution say okay this service use that package okay I can override the service the necks of service and say okay use the package in my home environment that works too but then I mean it's not what we want we are used to something that's pure that's clean and then we are trying to achieve everything so this is indeed very active so I went to look for tools that allowed to do that and one of them is git rebase interactive when you do git rebase interactive it tries to apply all the commits and so on and when there is a conflict you are dropped in an environment that looks like it's a normal get repo but it's not really if you try to push that on a branch it will be strange etc but you can commit behave like you are normal commit environments and when you are done you suggest continue and it just continuous job integrating your modification that's something we would like with Nik shell basic Linux shell set up the right environment to build the stuff you can build it you can go to the end but when you are doing making style it doesn't install because you cannot access the next or why it would be interesting to you know be able to write in the next hour that point and produce a package and if you are annoyed about purity then just make Nick shell accept a high corruption and the Egyptian produce a derivation with a random input parameter so it doesn't conflict with the normal one the pure one and this random input says okay it represents the fact that a human can just tamper with the build so the human can add random stuff into the build but that would be very very nice because then we could insert basically anything in the store in way that's quite clean and corresponds to the Nick's model to explain that differently I have defined the Nick's OSI model which is not to be taken too seriously okay but we have layers and each of these layers are related to different tools so if you use Nick's build then you know nothing about Nick sauce basically if you use Nick sauce then you know nothing about serve about different servers like Nick's table does and if you use meg and then you know nothing about everything that's in Nick's right nowadays it's nearly impossible to just run make on a project you need an excel to get the right environments so basically what you do is you start at the next Shell level you open the zipper okay and then you enter an environment where you can just play with ITRI and you project and when you are done yeah when you're done you're gonna do that package but it would be nice if you could just close the zipper and say okay I have a package now I enter it and I can exit it of course there is you can go further
and say okay let's add the hack comment to Nick's rebuild to an accessory build and then you would start higher in the hierarchy zip inside it and then go outside of so you could it would drop me for example in a shell where I can just edit a tree and then it would use that version of I tree only for that build of Nyx's okay it's not that clean but in the end it's correct because it's a diversion with a random input which correspond to the fact that I've shared something and I can easily enter and get back of the tree okay now for the extra step if you remember caching then we can still use caching in that okay if what I did in the nick shell was corresponds to what will be done by the next build then there is no reason annex build could not we use that okay if I was using correctly the API to the cache and that Nix build cached my bills then it could be reused so this is very efficient because we never never compile the same thing twice if you compile it twice then what what happened oh no crap [Music] if we compile the same thing twice then there was a bug you shouldn't this should never happen right okay so this is the the part about you know being a nicer interface strick is good but some time to strike is just I mean it gets in the way okay so I think we can go a bit further and improve the interface of Nyx to play nicely with users yes and this is the second part of my presentation so if you have questions on that parts precisely I will be able to take them the Navy question for you would you use a tool like that and I even know the question do you think it's easy to implement Wilco any ID okay I just some way there are already some hacky ways how you can roughly what you already mentioned so for example some larger Haskell birds problem that building them from scratch every time with a couple hundred packages each going so one way to work around it for example is to usually you're supposed to add build inputs like SRC right yours actually add only your sources but standard or you could claim a standard way in get this kind of caching concept as you have shown is that instead of just adding the sources you also just add build directory as well right because if you have a correct bit system for your language for example tht haskell and you have built directory present and it will resume from where left of last times you're basically taking your way in by saying your sources are not just the sources but actually the sources plus the build directory so that already works but of course it's pretty happy enough they're built directly here the directory can be Roger Lodge every time you do this kind of build you create lots of stuff in the next door so it would be really nice to have an official way to do that as you suggest such that you have same benefits but without the drawbacks of that kind of idea that in this concept extra data that is like source input but also like cash in zooming that the yes that's but if you are if you want to build a local project then more often than not every time you call Nick's build then it will fetch the sources and put them in the store and depending on your disk is maybe a very quite long operation already and then you still need to build it from scratch and this is stupid so one solution is to add the extra input like you say but then I mean you do it Nick's build will never acknowledge that it was the same thing that you built before so there is no way to make this work efficiently for building and you will never be able to share what you did but okay I think you're doing this yes yes exactly okay I will add that to my do not do that slide yeah there is a question or so in that environment would you be allowed to access the network or not and I guess we could have different versions of your and okay so next user story and this may be a bit more technical and I have a problem with the Knicks store it's not a big problem but it annoys me most of the time is that in my niche store there are so many package that are just basically the same okay if you take for example two popular data and you dip them the only difference is in the package config file okay and the yeah package config file and there is only the popular that idea and see flags and why are the difference because they reference the demo version itself okay so this is the out ash of the derivation here is not something no it's not an input that changed okay it's only the out ash that has changed that was written in the derivation what does that mean it means that because we gave two different out as to this derivation they end up being different but if they had the same out hash they would be the same these are exactly the same derivation except that this one is stored in a different location and this one and I mean this must be written into the file sir okay so this is what it looks like when there is no optimization right oh yeah sorry it's ITRI but could be any package you have this derivation file and then there is a various mole difference may be an input change but it's not important to the derivation doesn't change what gets built in the end and so you end up with two package two different package in the binary cage you will need to download this package two times if use both and then you end up with two package in your store and there are nearly identical so the first optimization and I was using an optimized store okay quite quite a lot of people though there is this nifty tool that's called disk usage and for a long time I did not understand why that very word where it reserved like that let's in fact the tool is very smart so an accounts the space that he does not counted yet okay so what happens here I asked for the space of three popular data derivation and the first one oops wels megabytes and the others are only 60 K all right this is because the optimization of the store are links every file the files are the same together so all the files that were already counted for this derivation are not counted anymore for these ones okay this means that basically there is nothing in a it corresponds to our intuition that there is only one file that changes and in these derivations is 3d revisions you have folders which cannot be are linked and are links to the same files okay so this is only counted in the first one what does it look like on my picture it looks like this right you are able to optimize use a little store usage but you only know that in the end when you have downloaded twice build it twice so
it's not very efficient except for disk space on your machine and yes network usage is important every week or so we merged the unstable branch the unstable branch into master and unstable branch is the branch for us must reveal stuff must rebuild means that's mostly I at least alpha the package are impacted there is a huge impact if you have twitches like that you can be sure that you can download everything so if you are like me and that you update once amounts then every time you update you need to download a fully new distribution you need to download all the package and I think we can do better than that I mean we do not need to download everything most probably there is not a big change like a small change like we saw before to do that it's an idea that I would not implement but apparently existed at some point we could invent this idea of binary diff right say okay this derivation it looks like the previous one okay so be different but let's just only ship the diff and keep the diff into the binary cash I'd like to do that it's just a difference substitute that will be provided and it needs to be understand by NYX but it looks quite easy to do one question is okay what do you differ with which is the old package but this would help a lot to save bandwidth and space on I draw but there another option that I prefer and that's I will call content address storage ok because we all call it's intentional store and it's exactly not intentional it's exactly the opposite of that so let's keep its content address storage ok what merchants made a RFC for that and is not here I think so I'm bit sad because I wanted to work on that with him but anyway the idea is that if you can detect that's you build exactly the same package up to the self links then you can just use the same package and you're done it is very nice because when you are when you query I draw about okay what's the substitute for that I always say it is that one and then you will check in your store and say ok I receive it that's done there is nearly no network no bandwidth and there is a lot of space that is saved on either so [Music] yes what was the situation before if you have these standout environment and then okay from that you can build the X packages and then you build a tree okay you end up with three different packages in the end and then there is a very small change to the standard environments maybe it's not significant so he just I added an S in a comment in a bash script I nobody does that because we know that we will break a lot of stuff but it's not that important so I do the small change and I end up with a different set of packages with the content address storage I could do something like that okay I realize that okay STD end is exactly the same so I can deduce that all the package should be the same because they will be built from the from the same package all right there is no way they can change the real the actual input to this package is the same you build it and you look at the bytes and you say okay these are the same bytes it's the same package yep you needs to build it so there is no way I want that you need to build the package but once it built yeah I'm not changing the revision times you know basically changing the the built command or something like that but you may be surprised a lot of cases where this offense for example if you change DCC for example then GCC will rebuild your project but it may happen that's its exact same project that is built okay it's a new version of GCC but there is not much change in the bytecode is produced right so you may if that's kind of if you're more fun than you think but I must admit that I do not know now what's the actual impact of that so it would be nice to do some kind of impact analysis yes I'm happy that you asked the question because our you went to first of all that's the idea that's for the out pat yourself you need to strip that from the produced binary before asking them and this is the ash in which you will store your derivation okay then you can reinsert the out link yeah yes of course you need to do that and it's more complex than it looks like because often the out pads ends up in very strange location for example in a man page and that man page may be zipped so it may not be discovered by Nix build will it strip stuff and reinsert them so there is technicalities there that we need to think about yes it's linked to that of course so I mean it's interesting to see that okay let's let me change the derivation you know in some way that I'm sure cannot change the build some for example I could add a random variable to the environment that nobody should use right and if I'm not able to reproduce the exam say the exact same build there is a problem either which contain data storage detection or which reproducibility so it will maybe I helped to I lies yeah not stable package you okay so the main advantage is that you do not propagate change to the package you are able to better detect when the package is really the same as before so it means that you can do less compiling you do not need to compile all the dependent packets yes faster of this you don't need to download from I draw it is not too difficult to implement yeah not too difficult but I mean everything is in there we could do that with existing tools the real difficulty is with you know forward and backward compatibility if we do that then yes of course will change NICs in a major way so we need to investigate oh we can do that without breaking everything if we need if we break everything maybe we need to say okay this is very important yes you just went ages so okay let's break xn started getting over but I don't know yet so this is really a problem now with this ID that it's quite difficult to know what would be the real gain I would like to set up my own I draw and try to do tests with that but I mean it ask a huge computing power which I do not have yet maybe in two years for next next gun yes the reason why I was really
interested in that is because I have this pull request that is now completely bit rotten but never mind I wanted to make standout environments that just trips everywhere everything everything that looks like an L F strip it's okay because we had issues like for exampie HP was storing libraries in very strange location we did not see that and so PHP was basically depending on DCC and I mean this was blowing the closure size for the story this was I mean this was there for so long that at some point Elco fixed the PHP stuff before I even merged this one it was easier to fix by hand that effective global the interesting part about this pull request is that for most packages it changes nothing okay and if the package changes then there was something that was not stripped before and the twist trip after so it's interesting to look into that package okay and even the ability to detect when package are exactly the same would help with refactorings okay you refactor something you build everything and you see what has changed this gives you some information about did I do something wrong is something that I really intended in the refactoring even though the refactoring should just listening as this okay so now we want to bridge the gap
between all the ideas if we do this contain data storage and caching inside a build system that becomes quite complex [Music] if you cash buildin it becomes much less it may become less stable or it may become more stable so you have a lot of interactions in there that needs to be investigated and I think it would be fun that's maybe a bit complex so let's do one step at a time and it would help like we said before to to catch unstable bills right if the content the content ash changes who were friend and there is something that's not stable in the builds okay so I presented these three ideas of improvement UNIX I when I started I D feeling that you could not change Nix but it's not true there are a lot of things that we can improve and we can make it more user-friendly about kissing builds that's something that I'm working on for my PhD the content that we storage is something for which division RC so if you want to work on that you're welcome to contact what mountains and we can do it together the Nick shellacque with the zipper is something that's not being implemented all but I mean I would be happy to start that with someone and that's it [Applause] the behind the pillar over there over there ha [Music] the Philly thing is that I have been compiling build system to other build systems for two months now but not tunics I guess what I want to do is basically the same right because I asked the build system to just say what he wants to build and pass it to NYX build so he is basically exposing all he wants to do so I would like the build system to not compile tunics but to compile to a standard protocol that could be used for interpreting their operation with any other tools all right I would like something that's more global than just okay these tunics these two these two that etc I wants just one common protocol to build stuff [Applause]
Feedback