Nixpkgs Overlays – A place for all excluded packages

Video thumbnail (Frame 0) Video thumbnail (Frame 1986) Video thumbnail (Frame 11660) Video thumbnail (Frame 12531) Video thumbnail (Frame 18581) Video thumbnail (Frame 20501) Video thumbnail (Frame 23206) Video thumbnail (Frame 25251) Video thumbnail (Frame 29369) Video thumbnail (Frame 30675) Video thumbnail (Frame 42416) Video thumbnail (Frame 47466) Video thumbnail (Frame 49426)
Video in TIB AV-Portal: Nixpkgs Overlays – A place for all excluded packages

Formal Metadata

Nixpkgs Overlays – A place for all excluded packages
Title of Series
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.
Release Date
Production Year

Content Metadata

Subject Area
For many reasons, Nixpkgs cannot accept every package ever created. Things have to change, let's make sure we can at least include every package, even if they are not part of our central repository! Since December 25th 2016, we are now able to use Overlays. Overlays gives us the ability to change the way Nixpkgs see the world, while providing most of the benefits that we can get from it. This presentation will address the following questions: Why overlays are useful, across a community, across an organization, or across the world? How to write an overlay with a few good and bad examples, and digging in the internals of Nixpkgs to understand how overlays are working? What can we do to improve the usage of overlay even more? What parts of Nixpkgs should be converted into overlays?
Overlay-Netz Point (geometry) Presentation of a group Just-in-Time-Compiler Prisoner's dilemma Projective plane Letterpress printing Bit Modulare Programmierung
Suspension (chemistry) Point (geometry) Slide rule Functional (mathematics) Presentation of a group Inheritance (object-oriented programming) Overlay-Netz Google Chrome Proxy server Computer file Ferry Corsten Set (mathematics) Control flow Electronic mailing list Modulare Programmierung Parameter (computer programming) Function (mathematics) Revision control Web 2.0 Internet forum Root Different (Kate Ryan album) Term (mathematics) Internetworking Intrusion detection system Computer network Compiler Energy level Extension (kinesiology) Proxy server Physical system Overlay-Netz Module (mathematics) Presentation of a group Projective plane Shared memory Directory service 8 (number) Declarative programming Connected space Mixed reality Configuration space
Point (geometry) Web page Functional (mathematics) Overlay-Netz Inheritance (object-oriented programming) Control flow Function (mathematics) Parameter (computer programming) Attribute grammar Derivation (linguistics) Latent heat Programmschleife Algebraic closure Configuration space output Overlay-Netz Time zone Inheritance (object-oriented programming) Key (cryptography) Cellular automaton Bit Derivation (linguistics) Loop (music) Algebraic closure Personal digital assistant Function (mathematics) output Video game Videoconferencing Writing Library (computing)
Overlay-Netz Default (computer science) Overlay-Netz Inheritance (object-oriented programming) Computer file Inheritance (object-oriented programming) Code Set (mathematics) Parameter (computer programming) Revision control Heegaard splitting Term (mathematics) Mixed reality Circle Physical system Default (computer science)
Point (geometry) Functional (mathematics) Overlay-Netz Inheritance (object-oriented programming) Similarity (geometry) Set (mathematics) Electronic mailing list Parameter (computer programming) Mereology Rule of inference Derivation (linguistics) Operator (mathematics) Extension (kinesiology) Overlay-Netz Mapping Weight Electronic mailing list Bit Proof theory Logic Personal digital assistant Function (mathematics) Mixed reality Right angle Library (computing)
Revision control Overlay-Netz Beta function Functional (mathematics) Inheritance (object-oriented programming) Overlay-Netz Operator (mathematics) Library (computing) Attribute grammar
Presentation of a group Context awareness Overlay-Netz Source code Parsing Fluid statics Computer network Physical system Recursive descent parser Rotation Electronic mailing list Sequence Product (business) Derivation (linguistics) Root Sample (statistics) Hash function Order (biology) Phase transition Quicksort Spacetime Slide rule Computer file Similarity (geometry) Number Element (mathematics) Stiff equation Term (mathematics) Energy level Address space Default (computer science) Matching (graph theory) Key (cryptography) Information Computer network Basis <Mathematik> Directory service Line (geometry) Limit (category theory) Compiler Uniform resource locator Error message Integrated development environment Personal digital assistant Function (mathematics) String (computer science) Network topology Revision control Utility software Library (computing) Beta function Euclidean vector State of matter Multiplication sign 1 (number) Set (mathematics) Design by contract Mereology 10 (number) Formal language Heegaard splitting Derivation (linguistics) Positional notation Hash function Data conversion Recursion Overlay-Netz Parsing Email File format Token ring Fitness function Parsing Repository (publishing) Right angle Freeware Physical system Pole (complex analysis) Reverse engineering Row (database) Digital filter Functional (mathematics) Server (computing) Implementation Token ring Moisture Electronic mailing list Content (media) Metadata Attribute grammar 2 (number) Revision control String (computer science) Operator (mathematics) Gastropod shell Integrated development environment Software testing Utility software Boolean algebra Poisson-Klammer Forcing (mathematics) Expression Bellman equation
Overlay-Netz Point (geometry) Parsing Beta function Functional (mathematics) Inheritance (object-oriented programming) Operator (mathematics) Computer network Insertion loss Parameter (computer programming) Function (mathematics) Derivation (linguistics) Derivation (linguistics) Strategy game Strategy game Endliche Modelltheorie Library (computing) Data type
Complex (psychology) Musical ensemble Building Code State of matter Multiplication sign 1 (number) Set (mathematics) Numbering scheme Parameter (computer programming) Function (mathematics) Fault-tolerant system Mereology Derivation (linguistics) Strategy game Computer configuration Endliche Modelltheorie Recursion Physical system Social class Overlay-Netz Bit Regulärer Ausdruck <Textverarbeitung> Flow separation Process (computing) Order (biology) Lipschitz-Stetigkeit Right angle Quicksort Resultant Point (geometry) Functional (mathematics) Inheritance (object-oriented programming) Control flow Modulare Programmierung Attribute grammar Revision control Latent heat Root Term (mathematics) Module (mathematics) Default (computer science) Cellular automaton Weight Projective plane Expression Dirac delta function Performance appraisal Subject indexing Word Loop (music) Function (mathematics) Mixed reality Network topology Iteration Library (computing)
our next speaker is Nicola who you probably know from the module system the one thing I definitely know about Nicola is something annoys him strong enough he'll do something like implemented module system he works day to day at Mozilla recently working on a new project called holy JIT which is a just-in-time compiler for JavaScript written in rust so one thing I I was looking for a logo for is this prison for the first like was this presentation and I was trying something with overlays and I figure out that we already add overlays we just need a bit of transparency to see them and adding transparency in the logo you can see that we already have overlays and we also had a fixed point we had to saleh goes either way to fix the it's a death of of printing it's and if you recall some old t-shirts is not always easy can this understand fixed point especially if you are a printer so the goal of this
presentation is to make sure you understand overlays and make sure you understand them correctly I gave season eights community a gift for Christmas I give you overlays and almost a year after I come back to and went to the web and look for things where people used overlays and realize that hello crap people have used it but there are things that are in the documentation which might be not well explained and I of this presentation will verify that so I will go and describe what they are how they work and what you can do with them so Nick sauce is awesome we have a module system which gives us the ability to be decorative and this module system also give us the ability to compose different modules from all place and make that into one set it said that okay that's nice but not everything is awesome sorry for the lego movie but next packages is like you have suspensions and to return something it's not that much of declarative and it's not completely it was not compatible before overlays and we will see how overlays make that composable so before going into overlays let's look at how we use to extend mix packages before that before that we add these three functions and these three functions were like okay so respect over exit everybody almost everybody using config dot nix and it's nice you can extend things you can change the sources okay great but you cannot share that easily because you have some cues some stuff and it's like there is this one file and if you want to share that you have to share portion of it and we're back to the problems that I had before making the nexus modules which were okay how do we avoid getting into forums when we want to have a solution and how can I just share a file and just pull that down then we have this other function which I'm glad I removed it which is override package this is and if you don't know about it don't go dig don't dig further it's like awful and it's no longer there it's not not even try to use it it won't work then there is this other side which is like okay I'm from an external file in an another project and I want to import mix packages and extends these versions that I imported and as this new package is inside it that works well unless until the point where you want to add multiple and then you realize ok and I want to import something else that makes packages which already it stands it and it's becoming hell so all of this all of these methods are replaced by overlays and resting on one no longer exists right soon maybe I hope to break all of you if you are still using that so composable we can compose overlays in the way where we have the same same ties for all of them we have a simple syntax which is made to copy and paste and that's basically all and then you can do all the things that you could do with the overlays before which is like you can add packages you can replace some of them by tuning them you can change the recipe and you can remove some of them which for example say oh it's Leeds equal no yep no more its leaves which will break tons of sets such as in Knights I guess and the way overlay works is that you have one directory or an option in unique to s or a single file which don't have every something and this one directory lets you add files at the coarse-grained granularity and you add files into the directory and is called the overlays which will be use one after the other and will be combined into next packages so I will go through multiple examples and after while I will ask you to solve some of them so I will go with this easy one so this is the simplest overlays that you can make it takes two arguments one itself the other is super and you give it an empty set and you extended mix packages with nothing great so overlays are not just some things that are made of it's actually the internal of mix packages these packages is using the overlay system it says that it's doing a mess which is currently alighted in this slide and it's using the overlay system to basically stage the different levels of next packages that we currently add so this basically has the things that I did was like I was trying to do the grafting work again yeah if your recalls us it's a presentation from two years ago and I realize that huh there is this function override packages which gives me tons of trouble and I can replace it and just add overlays add Zn and that's basically all it is overlays are just adding something to Z intimal of next packages and you get to its end all of Nyx packages and I can remove one of the side features that was there and was awful in terms of performances and hey no one you're here so no we have overlays yes so a simple examples that I pronounced the Internet's it's quite - for its resourceful the Internet's find tons of things and sometimes are you find good examples and this one is just adding a command line to a command line argument to Google Chrome which is saying a use this proxy to redirect all my network connections through this proxy which is really nice especially you can set it on the command line and get all the nice feature protections that you get with a proxy so okay so that's a good way to get an overlay and you need to recompile once more so while
we are discussing about recompilation as some other people wanted to to get to get Nix but in their different directory and basically this is interesting if you are stuck in your home and you have no root access for adding the next directory at the top level so this is a simplified example but this as the same IDs which is that you want to configure nigs to have its mix or at the different directory and that's an interesting one as well so then you have other example
where you just have ordinary packages as we do even in neat packages and just one of the tools that we use within Mozilla for discussing so we saw this self and super and it's not clear when you see them so self is basically in the expect it is you have the fixed point you have all these stages and you have a fixed point which basically takes the output and give it back at the input of all of them and super is you have all these pages and it's the previous one you take the next stage is the previous one and so on so that's out that's basically all it is but that doesn't tell you how to use them self is made to you to physically find all the dependencies so if you have a package and your package depends on said on by Zone on Firefox then you will use self you all say self dot said self dot baizen self dot Firefox and that's all if you want to use self or anything else that's wrong that's the only bullet point your sudsy bullet super is basically all the rest is if you have functions called packages or library functions or write text or recommend if you have functions it comes from super if you want to override the recipe it comes from super it comes from super for the following reason let's say I have said I want to override something instead or and I want to after overriding something and said I want to define it that cell you get an infinite loop because you say I wants a recipe of the things that I just defined and that's why you have to look for recipes for making packages in the previous once until you find one and that's why also overlays are ordered as opposed to unique to s modules so ok we sue cell phone super no I will ask you to raise your end as soon as you find the issues in this examples so if you find one if you raise your ends that way if you find two issues raise your ends that with and if you are watching this talk remotely then you have the end key to see the answers okay I see a few ends so the first issue is like write text right X is basically you it's a function they generate the derivation but it's a function as a function it comes from super loud cell and the other one is a bit subtle to see it's the fake closure so fake closure is coming from above because of the right keyword and it's not nice to make an overlay which is using the right keyword because if you are using the right keyword basically that means that you're looping within your overlay and not from the self from the next packages fixed point which means that an overlay which comes after has no opportunity to change that so if a closure loops inside instead of looping around and if you want to give more opportunities to your users you shall use self instead of break so let's look at another and this
is the one that is one issue in something raise your hand as soon as you see it's just above the question was where this Python come from so you're almost on the thing so this is not an overlay and the problem with this one is that there is a spite an argument and despite an argument is you don't it has to come and if you want to make an overlay does it come from self or super in this case you are using the override derivation so it shall probably confirm super and this Python is like if you want to make something which depend on a specific name or specific attribute within the other life then you shall probably use it as a name of the attribute and make it that way instead of using Python as a package
okay another example yeah where is he by the way so if you are watching remotely Garber's I hope that you'll be circle so this car has multiple issues one of the issues is like why do we important it's packages twice you first imported at the argument and then use the path which is inside it to import it again which is terrible for people who are want to do for example crush some foundations because then you got a different system and if you were to import package set which was configured for a different system then you import it again and you watch all this and all this system Houston ization with this one the other thing is that you have this overlay which is deploying with things is fine and within this fine you have like in Erie packages which is the one which is that argument and that's completely wrong you're basically you have three versions of packages that just and if you are custom findings as even worse you might even get the wrong one so what you want here is basically first split it into files and then you want to remove the package and probably use self
or super so that's how it'll look like you have one file which is okay yet is the path of mix packages and only important expect it is once if you want to do that then you have this overlay which is probably a default mix or whatever and this overlay this in depends on packages it depends on cell for super and gives that user requirements that makes and that's all read the files it will be nicer and smaller in terms of code so I have an
example and I am same thing raise your hand if you see issues so here's the issue is basically you have packages that you depend on and you want derivation out of them so cool package is functions that you get from super okay but the things that you give as argument which are dependencies such as the VTE package or rule of five are derivation and you want to get them from self such as somebody else can override them so let's look at how overlays work
and how we compose them some logic of the composition is this update operators that is in mix so we have two sets and we will make this example a bit more complex these two sets we use the update operators and for ends that's fine it returns a set then we go one step further we add super super is a previous one so we gave as argument of bar the super argument and the super argument will be the left-hand side of the update operator which is the proof even a super argument which is an empty set so in this case we have that very missing part here but that just for simplification it does not give anything then we generalize it's then we generalize the update operator and give that the name extent which is not exactly the same as one which is in the library but probably we shall rewrite the one in the library so the weight course is exactly the same thing is like you have the left on side and you have the right hand side and you call the right hand side with the left hand side as argument and then you have the update operator and with that you can use them and compose them already with starting okay I have who which take the empty set and the result of that I gave it a bar and then so on and so on so we can make that for list and we can pull that and saying okay use this expand function you have the empty set and so on and you iterate over the list that's basically how an expected his work and you can go even further because you want to have a fix point and your fixed point is basically saying okay no I have this self argument to all of them so you have all your overlays in the list and you have the fixed point which is basically giving the self argument to all of them so this is what does a fixed function is doing and the map function is doing here is a map function is here to for the self argue the self argument provided by fix to all of them so here we can almost take the previously example and make that into a I have this overlay which takes self and super and compose all those other overlay which are in the same territory such as food that overlay the plates and bar dot overlay that needs and that's really great and we have a similar example in mixed packages Mozilla so let's see if
you can spot the issue here notice that you know how it works it's supposed to it's supposed to add packages and be friendly overlay so I see a few ends and the issue here is that you have lima and you have lightest and these two are attributes and the ways you have data operator works is basically it will erase the previous one with the new value so basically what you're doing here is raising all the library functions by this Firefox version one and that's not friendly
that's you're raising all the work for others so you want to make sure that what with whatever you do you at least extend what was already in this attribute before so all right it's not
yet settled but we are trying to go into making a convention which is like if you have if you are making an overlay which has reproducible packages and that's wine you go to the top level if you have utility functions such as oh I want to parse some things then you're going to Lib if you have packages which are updated automatically without doing in doing anything in terms of changing the sources then please don't go as a reproducible packages because that won't do help for anybody who wants to make a reproducible environment so going to latest and add your stuff into that and if you want to make a shell environment which is not dedicated for building anything then probably going to dip and or some similar names so is this our convention it's not enforce yet but that's just play nicely and think of everybody having the same conventions on the same side it might be nice if we had a similar naming for Goodling or searching this this set of packages so currently at MIT and Mozilla we have neat packages Mozilla which is Firefox rust and some other tools and if you are making an overlay for some specific package then you broadly named after the name of the program and say - you overlay that makes this way somebody can say oh I want to pick only this one and symlink it - as a dot-com Fitness packages or overlay directory and if you are making a repository which is containing only overlays then go find the deformed ethnics which aggregates all of them if you have multiple ones so what can we do with overlays overlays I are quite powerful in terms of yeah we can compose and that's nice and we can do something such as right from the network because we have the new built in Spore right URL and as soon as you fix something you have another problem which is parsing it then you have to generate the relations so I will go for example sorry if it's a tiny phone so fetching from the network is simple you have the picture I like will take a URL and put that into some high somewhere and then you can go and parse okay I have a JSON file so in case of Firefox we have a JSON file which give us a version number of the various branches such as the nightly is 58 beta is 57 and stable is 56 this version gives us basically we can derive from this version the rotation of some checks and why and this checksum file as a specific layout which is the hash then some bizarre information and the name of the binary so you can use as a built-in match function to basically use the brackets and filter the parts that you are interested in and get for example I know what is the finance that I'm looking for give me the hash and then I can I can generate the derivation for that so the ways of Firefox that overlay works is basically looking at this while extracting the hash and and the binary name and then generating a derivation which is like okay knows your sources are from FHA Uriel with Asha and the name and that's all so I got to remark from the slides that you cannot for it's not these free languages from records businesses yes but very clever guys so if you look at the rest of the lay it's a bit more complex oh sorry first a fake part which is basically reverse engineering rest up which is a common coding the rest community which is like okay I want to update server C compiler to this version Poor's the Knights that for everything which comes next so this basically is a reverse engineer of Presta which is okay how do you get the address of the two ml file which is depending on the channel watch and preacher are worse a date and the location of where the files are distributed and that basically cause the fetching of the metadata is made and it goes through HTTP such as at least we know and trust the static rest line that org and that's how we fetch no let's look at what we get so we get some nice language which is order to pass with ragged please and this language is too mo it's basically a hinny file which has the same syntax as we have in next work having the dot notation for attributes which are under multiple layers and then it gives us like okay you have this package which has this ash and bunch of stuff and it's even as moist if you have two braces on both sides so okay that's nice format to look at and we can make a parser for that so for making a parser it might be nice to split the phases t-too and first naked tokenizer so how do you go and parse this to ml5 you basically make one big red racket which basically Express the list of tokens that you expect and you also Express the layout and that's give you not yet recognized err but it's a basis for it then you have a tokenizer function which is using a new feature of nick's 1.12 you can look at the old version which is in its packages does not survive for Nick's 1.11 its before a key and not as stable as this one but it's more challenging to understand as well so this one is working by using the split function this blip function is basically taking a string huge string and looking at the talkin and split your string with okay I have something which is not like a token I have something which is a talking I have something which is not an alternating between the two then as we go an alternate between token and non tokens and we have to filter out all the things that we are not interested in and it's very sort of thing which is not playable test parts of the non token part then we want to throw saying something okay I don't understand your three ml file and it's basically what the filter layout function is doing so no we took tokenized as we isolated things which are tokens and the thing which are not talking it said that we still have dates but that's
good enough for us so we know let's make a parser so a parser is kind of simple you basically got some text and you're in the state so instead of making your parser when were you go and do a recursive descent through your the information that you got we have to mutate to state mutate is the reason why we cannot do a recursive descent into a parser is because Nix has some recursion limits which are not directly tied mailing techniques but made into the binary which isn't it which is interpreting Nicks and we cannot use a recursive descent because of that and because it will be way too huge as soon as you go deeper into this level so the trick here is basically if you think of it as an LR parser where you have state and each time you move from one node to another you change your state then you have to remember what is the state so we want to have one operation which is apply every time in a sequence and which does not consume style there is a built-in which is pool del and with hypertrophy this is a built-in which is kind of special that converts is a pole nel implementation in the library its exhibit default tree now this basically avoid consuming stack it will call every time the tension that will not increase this tight space for every element in the list so we have an initial force an initial state this state is like okay we are in state zero and we have some context when we iterate through the tokens we basically okay we're in state zeros and do is much for example the name and doors may choose a state where we are in and we increase the state contract so we are probably in state one and in state one we respect the token to be always equal so that what we are at in Cisco and so we say okay no we eats a token equal so let's go to state two and in state two we match for example a value which is the string or a boolean or whatever and we have this token to value function which won't give us the value at the next value interpreted from the two ml five and we've all set it to the name so that's really simple honestly and it's just going through state and saying when I heat this talking and I mean this take then I go to this other state so we made a parser and know we got to deal with the fact that the system is not represented the same way as the systems that we have in the manifest pipe and so we implement a switch which is like if you give me the system inmates I can give you the system for Setar balls that you are looking for and the switch and make stiffness and attribute set and at the end you say oh I want this attribute and if it does not exist then you complain about it so we went through the
overlay we so that we can make it compost wise insert it into the fixed points that's very nice it's not yet declarative and we can take that but that will be the subject qualify those are taught probably because there is an RFC which is in the pipe which is simple of right strategies which give us the ability to have the ability to have the simple single syntax for all the override functions like override derivation override and whatever you can think of it's basically shall be expressed with a single syntax with this model so is that basically the end of my talk and if you have any question please raise an ibop - sir thank you I have a question about the one to use the self and the super argument in your overlay basically you're saying when you want to use a library function you should use super right yes
what if you have an overlay you want to
extend lip with your own library functions and in the same overlay you want to use these library functions inside your packages is that shouldn't you do that should you then have to overlays or should you because you come to yourself in in your your when you're a library function you're supposed to do super when you are defining the functions that you have already access to it so you can we make it to I won't recommend it because you can just use the ones that you have so just use the ones that you have it won't matter isn't it oh yeah if you have to mean a lot binding then you call them directly right but exposing them is nicer because that means that order can work on top of the words that you did one quick follow-up question so in mix OS you also have this lip argument that that your module gets I found that when you override the lip from package from next packages those overrides are not accessible in the lip arguments of the next class module so I always use packages the lip in my modules but I've read somewhere that that is that's not the right thing to do you should call but how do you basically how do I make it so that my own functions are accessible from lip from our next West module so package is that they hold on to you indeed yes it's a problem that you have is that the lips that is given as argument is basically used for the evaluation of modules so unless you're modify is invoked as a model system yourself then you shall be to use packages of late and it's the separation of the two words basically make deposit to split the module system apart from others and the problem is that people tend to use packages that clean to get make options and make default and ulcers yeah and this is where we had to say no usual not cheese packages that will so if you have Houston functions like the Firefox versions that I saw before yeah yes safe that's a sort of a safe that's as long as you make sure that you don't use model system functions from another libraries and the ones that you have uh ladies okay okay okay yeah we don't do that's right you sure that's that's fine okay um following up on that I do self dot call package all the time and it works great so I won't be happy to break your code soon challenge accepted so when you use self aides in its one iteration slower because you have to go through is a fixed point it's not a big deal in terms of performance it's a big deal in terms of concepts because my goal is aiming for graphing and for as a simple of right strategies and the problems that you got by using not using this super for the whole package is basically that you are adding in an external up green screw spruce a fix point so code package if you use self for code package you won't say okay I'm here I mean you're in specifics point to find code package and then code package itself is using the fixed point to go to the dependencies that you have or the dependencies that yeah and we are going twice crucifix point and this is a problem for implementing grafting later because the weight grafting words is by peeling off the fixed point and making sure we can have another version of pecks packages to make the deltas and you make sure that we can do the grafting I just wanted to make a quick warning the the Reg syntax index 112 has changed and so so be very careful and also in next 111 there was there were two projects in Texas depending on which plan you yes I adds this problem to I could show you I think patron also requires a sha-256 not as buildings doesn't Mike's going is it done to respond so um do you think that um well one I've sometimes had had issues with overriding packages because also using override actors because they rather than having some sort of fix point they just use rec and I'd like to be able to override stuff like the version which is then refer to by the by the expression itself is do you think an overlays like system would be helpful that for that as well reasonable or possible you mean within each of the packet yes so the simple of right strategy show provides the answer to that because it's basically giving you a decorative way of writing packages and you no longer a function which is like STM make derivation so you get just an attribute set and no break and you basically can get all the information out of it it it might be a bit complex in terms of concepts but the syntax is still to be discussed and so we shall aim for making simple to read any should solve the problem of having subversion because the version will just be one filled in in the sense that you can override without going through override derivation one first people question is why is it called themself and super you could call them packages and functions that would be much more simple so there is one thing which is called legacy and yes we shall probably rename them at one point but anyway it's in my face so I can name them like that yes it totally makes sense and if it's so easy to things up and use the wrong one isn't possible to enforce that's I mean that we are using the wrong one the right one why are packages available in gold if you should not use packages from Supra then just disable the packages that you cannot DC both the packages because they are is a result of to make derivation function but can you which you can disable the pensions from grace through the fix point by putting no on them that could be one solution to avoid adding using pension from self really have you have just never ordering out city okay look what is the other one so it is possible for functions it's order for packages unless we are going to use a state word on you can only get there evasions if you goes through the fixed point which is like we will have to have a post process adds in of your delays and orders stages which phone basically converts that and convert every recipe into its derivation from the part that's something that you could implement in like two days just maybe it will break some code alright last question and so you go through a fixed point of cell and what what is it you do super will it just descend until the the empty attribute set is reached and check for our attributes inside like like the inner most loop yes and do you have we have like like have you read into recursion schemes maybe because because the this reminds me of recursion schemes overall and my maybe maybe just like a term already for that because you have different kinds of so we don't have a recursion problem when you going through super because super will just go back and tell you find basically the attribute with Jo emts when you find the empty set which is that's root or it does not go back but you make the trees which are they becoming larger and booking fees in some is the last one you have recursion issues when you go screw yourself because self is basically you can define yourself yeah you're going through your own definition [Music]