General statistics
List of Youtube channels
Youtube commenter search
Distinguished comments
About

Brodie Robertson
comments

Comments by "" (@grokitall) on "Brodie Robertson" channel.

The fundamental issue here is that you have an important maintainer (linus) slightly advocating for rust for linux, and blocking c only code which breaks the rust build, and a less important maintainer (christoph) basically saying he wants to burn that whole project to the ground. This basic incompatibility affects the basic survival of not just the rust for linux project, but also those c coders who for reasons compile the kernel with the rust flag set to off. Calling for a definitive answer to what the truth is is a long overdue request, and the faliure of linus ang greg to address that issue will continue to cause problems until it is resolved. As was said in the thread, it is a basic survival issue for the rust for linux project, and for those getting their c code bounced for rust incompatibility. Stating that in the end, the only solution in the absence of such an answer from linus is to try and submit directly to linus and get the answer that way is basically just stating the truth about how to deal with a maintainer who is just obstructing code for personal reasons. Given that the maintainer has publically stated he would like to burn the entire project to the ground, when breaking code in the project is already getting c code patches bounced, it just strikes me that refering this to the code of conduct guys seems fairly obvious, as this level of hostility towards other contributers, the late nacking for non technical reasons, and so on seem like the sort of thing they should have an opinion on if they are to be of any relevance. While there are valid issues about the inclusion of rust code, that is not what is happening here. It is not about the quality of rust code in the kernel, but the existence of such code, which by now seems to at least have implicit support from linus. The technical question of not having the wrapper duplicated in every driver is basic programming, and the undesirability of this has been accepted practice for well over a decade. Having such code exist was responded to by christoph basically telling the contributer to go pound sand, rather than giving a constructive suggestion as to an alternative location which would be acceptable. Almost nobody came out of this looking good. The maintainer got away with being toxic about a decision which in theory at least seems to have already been made by linus. The code of conduct guys got away with ignoring at the very least a request as to if the behaviour of the maintainer was in scope for them to consider. Linus and greg got away with refusing to address the core question of what is the status of rust code in the kernel. Either it is a first class citizen, and christoph should not be blocking it, or it is not, and linus should not be blocking pure c code for breaking it. You can't have it both ways.
69
The biggest problem i have spotted is distribution managers who can't do the job, especially when package managers go off on their own thing. This happened on red hat when pottering decided to hijack the debugging flag from kernel developers. This is happening on debian with the idiot breaking userspace with package name choices. There are lots of other examples where the managers should step in an tell them off, but won't do it. I have yet to spot an example of maintainer overreach that has not been ignored by their managers.
16
@darukutsu what happened is that it is owned by Oracle, who like to sue, and do not like to change course. So you can't get them to put it under a compatible license, and even a complete rewrite from scratch is not safe from litigation, as seen by the drama over the Android usage of a subset of the java apis and register based jvm which is needed for mobile and Oracle still don't have. These were all written from scratch, and they still sued, so linus and the kernel lawyers basically say it is an out of tree fs until Oracle makes a move as they cannot take the risk.
12
this is the y2k / centos 8 mentality. in this scenario you get 3 choices. 1, start fixing your snowflake code early, and suffer low levels of pain for a long time. 2, leave it till the last minute, and scramble around with lots of pain and expense. 3, wait till the environment breaks, then have to fix it in panic mode when you might not be able to do it before it kills the company. too many places default towards 3 simply because they can delay it another quarter of a year, until they realise they can't.
11
looks a lot like rust in the kernel, not playing well with others. the solution for both is simple. do the work by themselves outside the mainline, and as bits stabilise or need to update other parts of the kernel you get someone who can play nice specifically to work on getting that code from where it works and is stable to where it is in a shape that upstream is happy with. thats how the real-time branch got upstreamed, so it can work just as well for rust and bcachefs.
10
Live patching has its uses, but most problems can be run as sharded clusters, where you take one shard out of service, update, and reboot, then do the same for the next one. This preserves system uptime, but not machine uptime. The problem with live patching is that you end up with long running code still running the old library version except when you patch the kernel.
10
@KoopstaKlicca they are two sides of the same coin. in the case of kent and his codevelopers it is exactly as you describe. in the case of rust in the kernel, there is a set of work to be done, and major disputes as to the cost and who is going to pay it, with the rust developers thinking it is minimal and wanting the maintainers to pay, while the maintainers think it is significant, and want the rust guys to do it. in both cases it is some project which on the kernel scale is relatively minor thinking that most of the playing well with others should be done by the kernel maintainers adapting to the needs of their project, with the maintainers resisting. note: i am not saying all the rust in the kernel developers are like this, just enough of them to be harming their own case.
9
obviously you did not watch the video you are commenting on, where it clearly stated that alma actively support an architecture not supported by red hat
5
one of the main reasons for the dislike of systemd is the mentality of the developers, starting with leonard and continuing through his fanboys. first, he identifies potentially valid problems. he did this with avahi, with pulseaudio and then with systemd. then he get the bit he is working on to be "dev complete", where it works on his machine (in a way that is deliberately incompatable with the alternatives) , and doesn't care if it works on anyone elses machine, and relies on his fanboys to get it to work on anything else, while he completely loses interest in it. this bit is then excused as being optional, and thus it doesn't matter that is incompatable, until one of the higher levels of stuff has a hard dependency on it, and suddenly the alternatives are squeezed out of the mainstream ecosystem, making it harder to remove it when it needs replacing. also, when they do something that causes problems for some other project, well that is ok, because we won't fix it because it in our code. these and other behaviours are just some of the reasons that people don't trust the systemd developers and the fact that redhat has not made any efforts to tone down these bad behaviours is why people don't trust redhat about systemd
4
@tfemby just because it is working c code, does not make it good code, and even good code is possibly not done in the best way to be compatible. i can think of a number of patch sets written in c which had further work done on top of them out of tree, where it took up to 20 reworks to get to the point where it was right and good enough to merge, and even then they had to then start working to get the extra stuff they built on top upstreamed. just because you wrote something that you think is great (and you might even be right) does not give you the automatic right to have it merged into someone else's project. the real time kernel work was out of tree for 20 years, working to move code from their patched fork into the main line, and every small patch that made it in made the fork easier to maintain. but it did take time and rework to get it in. this is a point kent at bcachefs does not seem to get, and he expects every change to just be accepted right away, turning main line into an experimental kernel, which is why he has the current problems.
4
python 2 to python 3 has the issue that it makes breaking changes, so the old code won't work anymore. most language updates just release a new version which is a superset of the old version, so they don't have this problem the other way this is avoided is how adding oop to c did it, where there were enough differences to make it a new language, but with minor code tweaks for the compiler, it could still use the old code. this is how we got c, c++ and objective c. python did neither, hence the mess. add to that big monolithic codebases, and the usual y2k ish procrastination, and we get to where we are today.
4
@guiorgy yes they could do it tomorrow, but the point is that they have not done so. Also, remember that a lot of these companies are now run by accountants, who upon seeing the money signs from the lawyers, do not bother looking at the costs if it goes wrong. Mostly it is not about making a balanced judgement call, if it was the sgi vs the world case would not have gone ahead, and neither would the Oracle vs Google case.
3
This is the actual reason for the regulation. Unlike the us, the EU recognises that climate change is a thing, and that most power is currently generated from fossil fuels. The best way and the cheapest is to not waste the power in the first place. Using a TV as an example, cheap tvs used to just turn off the tube when you put it on standby, wheras expensive ones did it properly, leaving just the remote control unit turned on, so it could turn the TV back on. The difference in power usage could sometimes be as high as 80% of the peak usage when using the TV, which is a lot of wasted power you have to generate. The same types of mistake were made with multiple generations of devices, including satellite TV boxes, fridges, home automation tech, etc, and to fix this they made this series of regulations basically saying that when you don't need to be wasting power, you should not do it if you do not need to. The issue with the kde and gnome suspend flag seems to come from conflating 2 different use cases under the same flag. The first case is the one relating to power usage and sleep, hibernate and power off. The default should be to reduce power usage when it is not needed, but is currently used as a flag to turn autosuspend on and off. The second use case is where no matter what you are doing, you need to force power off due to running low on battery power. This applies both to laptops and to any desktop or server running with a decent ups, and gradually degrading functionality can extend the time needed until forced shutdown is needed. An example would be to disable windows whole drive indexing on battery power, thus extending battery life. This second use case should have the default be forced shutdown for laptops and for desktops and servers on battery power, and is irrelevant to both on mains power. By conflating the 2 different use cases, you just end up with the currently broken understanding of what the flag should do, and the related arguments about the defaults.
3
@kuhluhOG yes lifetimes exist in every language, but rust seems to need them to be known at api definition time for every variable mentioned in those apis, unlike just about every other language. when you put this constraint on another language just to get your type system to work, it does not come for free. i do not doubt that it is possible to write kernel code in rust, nor do the c maintainers, in fact some people are writing a kernel in rust, and good luck to them. people are also writing code for the kernel, but when you can't even get a stable compiler to work and need to download the nightly builds to get the code to even compile (according to one of the compiler devs st a rust conference), and you need an unspecified amount of extra work to even be able to start doing work on the unstable internal apis, there naturally arises the question of how much work and who has to do it. as to the problem with the drm subsystem, i've not seen the thread, so i don't know if it was done as a discussion around "this variable is used this way here and an incompatible way there", or if they just went and fixed the more problematical one for them to work in the way that made it easier for the rust developers, and then did a big code dump with little prior discussion. if it is the second case, it is the same issue of not playing well with others except on your own terms, and the resulting problems are deserved. if it is the first, then the issue should be raised on the usual channels, and initial patches proposed, with ongoing work to figure out if those patches are the best fix to the identified problems, just like with any other c developer. i just don't have enough context to determine if it was the rust devs, the c maintainers, or both talking past each other, and thus do not have a right to an opinion on the details i do not know.
3
it should not make a major difference, as it is basically being set up to return us to the situation before the dissolution of centos. as far as i know, all significant enterprise linux offerings are based of rhel, as this was the position of red hat until recently, and why reinvent the wheel when you do not have to. as to the involvement of oracle, they are just one of the companies getting hosed by the actions of red hat, so this idea makes perfect sense for them to restore a proper upstream.
3
@flamingscar5263 microsoft did backwards compatibility because they had to, not because they chose to. when the new version won't run the majority of existing code, or is a pain to use, you are stuck maintaining the old version. this is why xp hung around for so long, the replacement was both worse, and incompatible, so people just stuck with xp. the same issue is going to hit with 11 and 12, because they are full of anti features people don't want, and the increased cost of the base hardware is just not worth the antifeatures that are being forced on you.
2
@Pentium100MHz if your car is relatively modern, it it is already computerised. The engine has a computer managing it, and most after market and a lot of built in entertainment systems run on android based embedded computers. As to your set top box shutting down during recordings, the word for that is broken. It should wake up when the recording is due to start, and stay awake during the recording, because it is doing something. However a lot of people here in the UK leave their tvs on in multiple rooms even when there is nobody there, or when they go out, and if the prompt comes up asking to verify you want to keep the TV on is not responded to, it goes into standby.
2
this is a non trivial task, as all major enterprise distributions have been rhel derived, so all software for enterprise uses the rhel assumption set. it does not matter if this is just assuming being rpm based, or lots more of the rhel options, every source of divergence needs to be addressed to make the code debian compatible. from a simple point of engineering, this takes both time, and actually being bothered about debian compatibility, and we currently have a bunch of rhel alternatives which do not need such major work, so third party suppliers will address those first.
2
it is worse than that, statements from the eula and red hat employees make it clear that even if you have a valid reason for having a developer license, they reserve the right to decide that even using one of the machines as a print server as part of that purpose gives the authority to decide you do not qualify, and come in and audit you for how many licenses they think they deserve paying for. this makes the value of the dev license almost zero due to future liability risks.
2
all that needs to happen for zfs to be ok in the kernel is for the other members of open ela to ship it in open ela. at that point you have an oracle backed organisation releasing the code under the gpl. this was what tripped up sco, as they were still shipping caldera linux gpl while trying to sue people for stuff in the kernel.
2
the point is that you use fedora if you want red hat tooling in a non enterprise distro so you can use the same it staff to support both. the problem with red hat and their scorched earth policies towards existing classes of customers that they do not see the value of is that not only does it diminish the value of rhel, but also of non enterprise upstream.
2
@marcogenovesi8570 no, i mean the subset of rust developers who think that searching for things like lifetimes and other things not a part of c is trivial, but are unwilling to do it themselves, then want to throw the code over the wall into the kernel and then want the kernel maintainers to do the work maintaining it (even th9se who don't know rust). very like the way that the kdbus people could not be bothered to do the work to speed up dbus, and just expected to throw the existing api into the kernel and hand the problem over to the kernel folks. this is not just about kent, but is a bigger problem of relatively minor developers thinking that they can work in their sandbox, and when they think the code 8s ready, just dump it on the kernel maintainers, who also have to do the work to make the kernel ready for their code dump and maintain it later.
2
@roundduckkira kent is a major problem for kent, but not all code that works gets accepted. what is the reason for rejections? not accepting that there is a problem. not liking the proposed solution? a large set of patches all dropping in o e big merge? the patches arriving late in the merge cycle? none of these is the maintainer being deliberately awkward, and all can have valid reasons for not accepting the merge. they all have responses which can be made to get them merged eventually. not having seen the threads, i can't tell if it is problems with the maintainers, if the developers are just feeling entitled and then butthurt because their code was not just immediately taken without comment, or if it is members of the two communities talking past each other.
2
@VoicesInDark i would strongly disagree with the idea that kernel developers are replaceable, as most of the are doing critical work in important but obscure areas of development. as for them getting paid, so what if some company wants to pay them, with the idea of basically putting bug bounties on problems affecting their company. you still have a number of kernel contributors who are not tied to big companies. as to it being a community or not, i don't see any way you can define that word which would not cover 15,000 people trying to not get in each others way for years. if you mean the kernel project not being community driven like centos used to be and rocky is now, very few large projects or distributions fit that model. it certainly does not fit how systemd is developed, nor the kernel, and not gnome either.
2
@MikkoRantalainen kent obviously has an out of tree fork of the kernel where he does the development work, which is fine, and is where his current behaviour is heading. what he needs is someone else to work on upstreaming the code in small patches, doing rework to make the working code compatible with the rest of the code in the kernel. if he runs it like the real time patches project did, improvements can be made on his tree, while someone else manages reducing the delta between his tree and upstream, eventually getting his code into mainline. note: linus did not say no more bcachefs, only no more kent, and whoever takes over upstreaming needs to play well with the rest of the kernel developers..
2
because ken thomson's paper "on trusting trust" was the first to highlight a new way of hacking the supply chain, and fixing it is hard and expensive. the purpose is to make it so that you not only believe linus can be trusted when you get your kernel from him, but you know that you got the same kernel as you got from him. in his tech talk at google, he talked about how due to using cryptographic hashes, as long as he knows the hash, he can download the repository from anyone, and verify it is an exact copy of the one he put up which they copied. that verifies the audit trail for the sourde code. the way nixos uses semantically versioned bill of materials verifies the audit trail for the dependencies. reproducible builds verify the audit trail from source to binary files. different tools for different parts of the job.
1
@Silver-eb7zm yes, canonical consulted their lawyers and decided it was a risk worth taking. This was based upon the benefits they could receive from shipping it, the low likelyhood of being sued, and the odds of being able to settle or fund fighting it. This does not make it license compatible, which a lot of other top lawyers say it is not. Canonical is largely a newbie distro, which is not where the money is. Both the linux foundation and redhat are well funded, so the return from sueing and winning is high, so the risk for them shipping it is also high, which is why they don't.
1
no, the major question is can they do anything about it without shooting themselves in the head. all a backup checker needs to do is checksum every file, and export that audit report to a non rhel machine. this is a good idea for security auditing anyway, so banning it would be very difficult. so would banning any non rhel machine from the network. once you have this audit database, you can do the same for any other distribution, and instantly flag up any differences, which from a technical viewpoint is no different from comparing todays and yesterdays reports, so they cannot easily ban that either. once you have the list of files which is different, you can decide if it matters, and just tweak your patch list until you get the same checksum. as this bit is not being done on rhel, they have no say in the matter.
1
@LuluTheCorgi because the reason oracle linux exists in the first place was that red hat did not want to support their needs, so just paying them does not get them support, and requires them to sign the dodgy eula which stops them from getting support any other way. in this case using the lawyers would actually cost less.
1
An example of the difference would be to keep the screen turned on when playing a movie, but turning it off if doing computation or drive indexing without the need for a display. This lets the monitor go into standby, and also stops the graphics card from burning energy it does not need to use. Screensavers used to be about avoiding screen burn on tube based displays, but are now either about inactivity wallpaper or power saving depending on your option settings. Similarly, cpus have different power levels, depending on what level of usage is needed. You can step those levels down if you are barely doing anything, stepping things back up if you start a cpu intensive task. This means you could walk away from the computer when it started to do a task which was a cpu hog, but did not need the screen, and after a wait, it would blank the screen and let the monitor go into standby, and then when the task finishes, it can move the processor into a lower power mode. When you come back and move the mouse, it can turn the screen back on, waking up the monitor, and you can check if it is finished. You could even have it automatically power off when it is done.
1
 @Haydatsanime boxed distros were killed by being able to ask Ubuntu to send you a free cd.
1
there are some minor misunderstandings of somethings in the threads which need to be a little clearer, so here goes. to produce an operating system from scratch, you need to either 1, write everything yourself, or 2, go online and download a bunch of stuff from people you don't know and hope you can trust the code. 1 does not work very well, apple and microsoft did not do it, neither did google or steam. it is slow and expensive. look at how long it took reactos to get to the point where people who were not kernel developers could work on it. (not criticising them, this stuff is hard). this only leaves you with the second option, which you solve by going to conferences and establishing a network of trust through key signing parties. as this requires the person to show the other person id, it is moderately secure against everyone but state actors who can just issue an id, and id thieves. all the network of trust does is produce a lot of people who can assert that the person you just met has been verified to them as being the person they say they are (for a certain level of verified). these people then commit code to version control, and once you get to centralised and distributed version control, you also have the person signing that they produced the work. this means if it later turns out that they were a problem, you can easily go back, and track what they touched and audit it if needed. it does not stop a bad actor like the xz maintainer, you need other processes for that. this gets you to the point were you can confirm the code you got was the same as the code they distributed (at least if it does cryptographic hashing like git) and the network of trust identifies all of the contributers. then you need to link the code together with libraries it depends on. the original paper that started the nix package manager, which lead to nixos, described the purpose to be to declaratively manage the exact version dependencies so that you could be confident that what you used to build it last time is the same as what you used to build it this time. effectively semantically versioning the build dependencies. it appears that the people behind nixos have extended this a bit, but the principle remains the same. if the dependencies change, then the key for the dependent packages will also change. guix did not like the nonclomenture, and thus decided to declare it using scheme, but otherwise they do the same thing. this gets you to the point where you can compile stuff and be confident where all the code came from, as you have a complete audit trail. reproducible builds go one step further, validating that the stuff you then compile will always produce the same patterns of bits in storage. this is non trivial for various reasons mentioned by others, and many others. declarative dependency management systems might also give you reproducible builds, but it is not what they were designed for. then you take the output of the reproducible build, put it in a package, and sign it. this gets you to the point where you as the person installing it can be confident that the binary packages you just installed are exactly the same as the stuff the original upstream contributers intended with a few tweaks from your distribution maintainers to make it work better together. and you can audit this all the way back to the original contributer to the upstream project if needed. none of this says anything about the quality of the code, or about the character of the contributers, you need other steps for that. as the sysadmin for your business, you can go one step further, and create versioned ansible install scripts to do infrastructure as code, but it does not add to the model, as your ansible scripts are just another repository you use. i hope this clarifies things a bit.
1
if as intended it is bit compatible, not only the build dependencies can be hashed like in nixos, but so can the output binaries.
1
@fuseteam no, the distributors are not just just rebrands, they are supporting customers who red hat have decided they do not want to support, and thus are not costing red hat anything. it is the same broken argument that every customer not paying us for stuff that we do not do would just start paying us if only we could find a way of forcing them. also, when these companies produce a fix for a problem red hat does not support, it gets pushed upstream, either to stream, or the original project, or both.
1
@fuseteam you seem very set on the idea that every provider downstream of redhat is just a rebrand, which just is not true. there were whole classes of people who were only using redhat and their derivatives because redhat as part of their marketing said that if you need enterprise timescales, then use us as your stable base and do respins and derivatives based on us. that is what centos was. people are annoyed because redhat promissed 10 year support for centos 8, then ended it after only 1 year, while people were still migrating to it. even worse, they gave almost no warning. as to the derivatives, each exists for a specific reason, and supports customers redhat no longer wishes to support. clear linux is for an all intel hardware stack. rocky linux is for centos users where the move to rhel is not an option. scientific linux was a cantos derivative with extra software which was needed mainly in places like fermilab and cern. oracle linux needed specific optimisations which made running their databases better. others were used for embedded systems and infrastructure, or for alternative architectures. pretty much all of these use cases were at one time actively supported by redhat or centos, and are now prohibited under their dodgy eula. even the case where the city of Munich needed to create a respin specifically for their 15000 seat council rollout to include extra software only they needed is now banned. redhat used an opencore approach in order to grow, and a use us as upstream approach to enter markets that were not otherwise open to them. it had the added benefit of not fragmenting the enterprise linux market much. unfortunately for them, not everyone can suddenly switch to paying them lots of money on short notice, and even more cannot afford the rat on your boss tactic made disreputable by microsoft and their enforcement arm the business software alliance. when you run a business, you make a profit, and then decide how much of it to invest in research and innovation. the current management at redhat seems to think that it should work the other way around, where they decide what needs doing and how fast, and then tries to force people who never needed to pay with their blessing to make up the shortfall. the current fracturing of the enterprise market is a direct consequence of this attitude, as is the percentage of redhat customers looking for ways not to be held hostage by the next silly move they make. these people who have forked rhel had a total right to do so as redhat had encouraged them to do it. lots of them do testing for scenarios redhat does not support, and then pushes those changes both to stream, and to the primary upstream developers so that they do not have to keep large patchsets supported out of tree. these patches and extra bug finding are then made available to rhel from either upstream directly, through fedora, centos, or derectly as patches to redhat. this is fundamentally how open source works, someone finds a problem, develops a fix, and sends it upstream, and then the downstream users get to us it without necessarily having a need for support. when support is needed, then they find a company who is responsive to their support needs, which redhat increasingly is not. redhat has now become just another entitled proprietary software company who happens to use lots of open source software to try and keep the costs down, while the management has forgotten this fact and decided to stop playing well with others. this has already come back to bite them, and will continue to do so.
1
 @Fractal_32 yes, there is a reason why "may you live in interesting times" was regarded as a nasty curse. just look how interesting cloudstrike just made things.
1
by definition you cannot be bug compatible with rhel when working from stream. that is the entire point about the problem. centos used rhel sources minus branding. stream is rhel-next, which might be up to 1.5 years from being ready.
1
@Pentium100MHz we have this rule because EU citizens care about climate change, but have not yet got the mindset of actively looking at power usage, and if things are actually required to be using the levels they are now. There is also the issue that people on low incomes have to buy the cheap tech, where the search for sensible defaults has not been done, and are thus a lot more wasteful. As an example a free view box last time I looked could be bought for £15 or £40, with the more expensive one using 20% of the power in standby mode, which is often triggered by default after a few hours in the EU. The only way to force manufacturers to get a clue was to introduce these regulations and make these considerations mandatory. Similar regulations for emissions is why EU cars use half the fuel of American ones.
1
@audiolatroushearetic1822 as famously noted, common sense is not that common, especially if someone else is paying the bill.
1
what would be really interesting is if intel joins, and bases clear linux on it, as this would then make all intel contributions either upstream first or open ela first, instead of rhel first, and that could cause big problems for red hat.
1
 @knghtbrd but it is exactly his decision to break functionality silently and then double down on it that should trigger a process that should take weeks and require trying to work with upstream.
1
@travisSimon365 hurd would not have won if history was different. i was around at the rime, and everyone was looking to work from bsd code, but the at&t vs berkley case had a chilling effect. the other possibility was that lots of people wanted to extend minix to be more useful, but andrew tenenbaum not only wanted to keep it simple as a teaching tool, but also refused to allow others to maintain a set of patches in the same way as was done for the ntsc mosaic server, wjh8ch was h9w we got apache, literally a patchy servrr due the sequence of patches on patches on patches which were maintained at the time. also remember that it was not until someone wanted to support a third architecture that the default changed from forking the codebase, then getting it to work on the new architecture and instead got the code needed for arch architecture to be brought into the mainline kernel, managed with configuration flags. so you had 386bsd being slowed down by at&t, minix expansi9n being actively opposed by tenenbaum, gnu's kernel being delayed by indecisiveness over how it should work, and multiple commercial unixes just being too expensive for students. then along comes linus, who like a lot of students wanted a unix workalike and happened to be going to university 8n a country with a funding model that did not exist anywhere else. he even used the monolithic design which he thought was worse, for speed. it was not that linus was cleverer, withmsomemgrand plan, just that everyone else could not stop shooting themselves in the foot. also your alternatives at the time were either a primitive version if dos, or cpm.
1
that is basically the xz hack, and other steps caught that. however you can mitigate that one by having multiple tools from different providers to do the same job. gcc got hacked? switch to llvm and recompile everything.😊 it is all about auditability, and not having single points of failure.
1
@RoelandJansen you are mistaken. while it is true that sles is not a modern fork of rhel, the fact remains that in the same way clear linux forked to optimise for intel hardware, and oracle linux forked to be better optimised for database workloads, suse originally forked from red hat linux to optimise for german language speakers. while it was a long time ago, and they use a different installer and config system, they still maintain compatability with a lot more of the red hat choices than the debian choices, and that is before you add in the new red hat derivative and any convergence that happens between it and suse linux. this means that it is much easier to support software developed for red hat on suse than it is to do the same on debian.
1
@RoelandJansen you are right about it being slackware derived, but even the wikipedia entry says that it scoops up lots of red hat features, so the point about it being a lot closer to red hat than debian still applies, especially as regards red hat assumptions being baked into various code. the point about potential convergence between sles and their new red hat compatible system is also still valid.
1
no it would not. it solves a different issue. think of it as creating a bill of materials which contains the semantic version number of every dependency, and then hash it. that hash is unique, and says that this version of the package uses these exact versions of the dependencies. this is how nixos works. as soon as you change from the default upstream configuration, at the very least the patch number changes, and this happens for every package in the system which deviates from upstream. if it is a fairly core package like gcc, the bill of materials for most packages will have changed, meaning they almost all have completely different keys. so your semantically versioned dependency list says that it has these exact versions all the way down the dependency tree, and the reproducible build says that it always generates the same binaries for the given dependency list. different tools to verify different aspects of the job. to go further and audit across distributions, you would need some way to determine every code and configuration patch for every upstream package applied in every distribution, which is even more work.
1
@jamesross3939 by its nature, diverse software stacks have some level of source incompatibility. just look at the problems in making the same program work across multiple versions of windows. as regards multiple distributions, we don't live in a world where everyone has identical needs so naturally at some point you start to get divergence. this even applies with windows where you have different releases for servers, desktops, oems, embedded, and others. these divergences naturally make it so that you cannot guarantee that a given program will work the same way, or at all on the different platforms, and the only way to deal with that is lots of testing. true binary compatibility requires a level of control by the vendor which results in large groups of people being ignored (causing divergence through making new systems which address their needs), or severe levels of bloat (to accommodate needs most users do not have). often it does both. in particular, you would need every variant to use exactly the same versions of every library on exactly the same compiler, all the way down. good luck getting blind people to move to wayland which currently has no support for them. the best mitigation we have at the moment is flatpacks, which package non interacting code with their needed library versions to produce cross distribution packages of user space applications. most distributions get created because their users have a need not covered by the mainstream ones, and a lot of them are extremely niche. their use case often will never become part of mainstream distributions, and their effect on the ecosystem as a whole is negligible. for others, the minority use case gradually becomes more important getting mainstream adoption as the work by these niche distributions becomes available in software used outside those distributions, and the niche distribution either becomes irrelevant, or remains as a testbed which feeds back into the wider ecosystem. this is what happened with the real time linux distroibutions, and as more of their work made it upstream, less of their users needed the full real time systems.
1
@darukutsu the zfs story is simple. the people writing it for linux are doing a from scratch reimplimentation, so from that point of view the oracle licence only matters if those people have seen the original source code. where the issue comes for the kernel is that oracle has a history of suing people for look and feel and for work a likes, so the kernel people will not include it without a statement from oracle that they won't sue. for reiser fs, yhe issue is that it is version 3 in the kernel, it is barely used, and has some fundamental bugs around the 2038 date problem. as most of the developers moved on to other things, and the remaining ones have moved on to version 4 which has not been upstreamed, and version 5 which is a wor, i progress, the bugs in version 3 wi.l not be fixed, leaving the only choice being to remove it. as for kent, and bcachfs, he does not play well with others, so he needs someone else handling upstreaminb the code.
1
@qwesx sorry, but that is just wrong. the licence gives you the right to modify, distribute, and run the code. what compiling locally does is moves the legal liability from the distribution to individual user, who is usually not worth going after. as regards testing in court, the options are relatively few, and apply the same no matter what the license is. if you claim not to agree to the license, then the code defaults back to proprietary, and you just admitted in court to using proprietary code without a license. if the licences are incompatible, your only choice is to get one side or the other to relicense their code under a compatible license for your usage, which us usually somewhere between unlikely and nearly impossible with most projects, meaning that again you do not have a valid license for the derivative work, and you just admitted to it in court. with zfs, the problem is even worse, as you have oracle who sued google for having a compatible api, which was then resolved to be fair use, but only after costing millions to defend, and taking many years. because of this the linux kernel community will not take code providing any oracle apis without a signed statement from oracle that they will not sue, not because they do not think they will win, but because they cannot afford the problems that will occur if they do sue. individual distributions shipping zfs would face the same potential consequences, which is why most do not ship it. this leaves you back at moving the liability from the kernel, to the distribution, to the end user, where the benefits to suing most of them are just not worth it. as to trying it in court, there are lots of licenses, and lots of people either being too silly to check the licenses properly, or trying clever things to skirt the edges of legality because they think they have found a loophole. there are also lots of places to sue, and as floss is a worldwide effort, you have to consider all of them at once, which is why it is a really bad idea to try and write your own license. in america, people have tried the trick of not accepting the license, and have failed every time. the same is true in germany under a mix of european and german law. this covers the two biggest markets, and can thus be considered settled. what happens in every case, is that the license forms a contract for you to use the otherwise proprietary code under more liberal terms, and when you reject it it reverts back to the proprietary case, where you then have to prove why you are not using the software without a license. trying to be clever has also been tried, and while the law is less settled than for rejecting the license, you need every judge in every venue to agree with your interpretation of the license, which normally does not happen, so you are back at being in breach of the license, and hoping to get a friendly judge who does not look to give punitive damages for trying to be too clever. the insurance risk usually is not worth it. the only other option is to try and comply with the license, but when you have multiple incompatible licenses this is not a valid option.
1
@marcogenovesi8570 if you mean the rust developers expecting the maintainers to go and hunt up a lot of extra semantic information not neded in c just to comply with rusts expensive typing system, and calling it documentation, that is one aspect of it. when you choose to work in a different language, which has tighter requirements, you make building the language api bindings harder. that is fine, but then you have to be prepared to do the work to find that estraminformation, and only after you think you have got it right do you get to call requesting confirmation documentation. this happened with the ssl project in debian, where the person who initially wrote the code was not the person who provided the clarification, resulting in a major security hole, but the patch developers did the work and asked is it case a or case b, and got the wrong answer back because the answer is not always obvious. this is why the c maintainers push back at the claims that it is just documenting the api, and it is cheap, when it is neither. like with kent, and some of the systemd developers, the issue is not the language the code is being developed in, but the semantic mismatch between the information needed by the existing work, and potential ambiguities relating to how people want to use the existing apis in a different way to how they are currently being used, which might require disambiguation, which might require digging around in the code base and mailing lists to see if a close enough use case came up in potentially thousands of posts in the discussion to clarify the new semantics for the previously unconsidered use case. the time for them to do this is at merge time if there is an issue, not all upfront because it is just documentatiron. the general principal in most code bases is that if you want to create new code, go for it, but when you want to merge it with the existing mainline code base, do it in small separate chunks and be prepared to do the extra work to not just get it working, but to move it to a shape that is compatible with the main code base, and if it is more than a drive by bug fix, expect to stick around and be prepared to do a lot of the maintainance yourself. this goes double if you are working in a different language than the maintainers. otherwise, it eventually gets treated as unmaintained code, and deprecated prior to removal. again, it comes down to respecting the existing development process, being willing to work within it, and if you need minor changes to that process to make the work easier for both sides, working within the existing change process to gradually move the standard way of doing things in the desired direction, while bearing in mind that in the kernel there are 15000 other people whose direction does not necessarily match yours. kent does not get this, so i see his code getting booted unless someone who does steps up to maintain it. the systemd guys did not get it either, which is why kdbus went nowhere, after getting a lot of push back from lots of kernel maintainers. a significant subset of the rust in the kernel developers don't seem to get it either, harming their case and making things harder for their codevelopers. this problem is not confined to the kernel. middleware developers like systemd, gtk, wayland, and others seem to forget that it is not just their pet project, and that in the case of middleware they not only have the same problems as the kernel, with new developers having to play nice with their rules, but as someone with other communities involved, they also need to play nice with those below them, and not cause too many problems for those above them in the stack.
1
@alexisdumas84 i am not suggesting that every rust dev wants the maintainers to do everything, only that those who don't are being conspicuous in their absense with dissenting opinions or are failing to see how their additional semantic requirements to get the type system to work cause a semantic mismatch between what information is needed to do the work, and when. for c, it comes when the patch is finished and you try and upstream it, at which time any such problems result in considerable rework to get from working code to compatible code. this is why the real time patch set took nearly 20 years to get fully integrated into the mainline. for rust, all this work seems to need to be done upfront to get the type system to work in the first place. this is a major mismatch, and the language is too new and unstable for the true costs of this to be well known and understood. rust might indeed be as great as the early adopters think, with minimal costs for doing everything through the type system as some suggest, but there is an element of jumping the gun in the claims due to how new the language is. python 3 did not become good enough for a lot of people until the .4 release, and for others until the .6 release. as you maintain your out of tree rust kernel, with any c patches needed to make it work, have fun, just make sure that when it comes time to upstream the maintainers need to be able to turn on a fresh install of whatever distro they use, do the equivalent of apt get install kernel tools, and then just build the kernel with your patches applied. it is not there yet, and thus some code will stay in your out of tree branch until it is.
1
@marcogenovesi8570 they do document them to the extent needed to do development work in c (in most cases), but the rust developers need even more information which the c developers don't need until it is time to upstream a patch, and an actual problem occurs, not just the potential problems the rust compiler finds. its like having ai find bugs. yes it can do it, but it cannot work out if it is a bug, a threat, or an exploit.
1
 @mikechappell4156 because it was obvious from the announcement of python 3 that 2 was on life support as far as the developers were concerned.
1
@mikechappell4156 totally agree, but once it was clear that the developers were going to treat it the way x11 is now being treated, it should immediately stop people from starting new big projects in it, and should have them start getting proactive about splitting the big code up so it can become less of a roadblock later when you cannot replace any code without replacing all of the code.
1
@sylviam6535 as they get closer to the core, not only will the existing costs increase, due to the larger interface between the two languages, but more and more code can only be extended in the second language, so as it moves closer to the core the risk of having to duplicate the code in the original language so the rest of the kernel can use it goes up a lot, making the benefits of those patches more doubtful, and increasing the push back against the encroachment into core kernel space.
1
the point is that in an enterprise setting, just moving away is not a question of just reinstalling one machine, it can be a multi year job covering thousands of machines. this is why rocky came into existence, to support centos 8 customers screwed over by red hat deciding to cut short the support period. be assured that a lot of rhel customers are saying internally that given the failures of trustworthiness and predictability, can we afford to use red hat for our next project rollout.
1
 @Mooooov0815 the sort of people this is targeted at will definitely be doing incremental development with continuous integration, where unit tests are not just good, but are essential.
1
 @pauldunecat if it is 19 years old, why does it need the nightly buildm9f the compiler to work with the rust in linux code?
1
there are a number of use cases where some form of automatic update is an anti feature. the classic example is the medical specialist remote working, who opened up his laptop to review a diagnostic image which needed immediate feedback, only to have windows trigger an immediate automatic update blocking use of the system for over half an hour. having systems where downloads are slow or expensive also need the option to defer downloading until you have a better connection. then you have laptops, where you might have to defer installation until you can plug it in to prevent partial updates from breaking things. finally, you need the update system to be pull based, as push based update systems add a whole extra set of problems if the push did not work. and all of that assumes that the update itself is not broken.
1
@monad_tcp micro kernels are clearly a better design, apart from one small problem, the message passing model is painfully slow in practice. numerous tricks were tried to find ways to speed up micro kernels, unfortunately the same tricks also seem to work just as well with monolithic kernels, so soon after a speedup occurs in micro kernels, the same speedup is also applied to the monolithic kernels, meaning that the gains were quickly negated. almost all kernels now are modularised monolithic kernels.
1
because the term predates the ideas behind the nix package manager, which tries to solve a different problem. its like saying lets just rename the make program to be called fred. yes you can do it, but the amount of issues it would cause is just not worth it.
1
If you watched the video, when you download it from upstream, everything is compiled in but turned off, so just recompile the upgrade and don't turn anything on.
1
No, the problem is that dispite a number of user complaints, it was ever promoted out of sid, which raises wider concerns as to what sid is for if not to stop this sort of breakage getting though to unstable.
1
the point is that it is not about you trusting your distribution, but them being able to audit the trust for everyone upstream of them so they know that the stuff they built has identical source and output as what was got from upstream. it does not stop the xz hack, you need other methods for that.
1
@Vegemeister1 restarting a cluster is a solved problem. You can use wake on lan to wake up a machine from powered down, and doing update and reboot works if the kernel or core libraries change. If they don't, you can just shut down the service and restart it. Bearing in mind the only time it makes sense to live patch is for high throughput systems, sharding gives much better scalability. In this sort of throughput scenario, you are basically talking about high availability systems, so having multiple machines as part of the system is already a given for reliability and resilience reasons, so sharing does not add much load at all. Tools like ansible even make this whole process relatively easy. I think it was Netflix who intended to reboot a specific machine and accidentally rebooted their entire data center instead, which only took a couple of minutes to come back up.
1
only the first time when the build does not match, and you can automate some of that. you are basically having to debug what is different in the builds. once it builds reproducibly, the tooling stops you having to do all of the work again.
1
@MaxusR which is the entire point of reproducible builds. if you cross compile gcc using llvm, and then use that on a machine with another architecture to cross compile llvm using gcc, you can be fairly sure that your new llvm install has not been hacked by the compiler. if i can then do the same thing, and get a bit perfect copy, we can both be sure that the same source code produces the same output. it does not stop the xz attack, but there are other parts of the supply chain testing which help catch that.
1
@warpedgeoid black box statistical ai has the issue that while it might give you the same results, you have a lot of trouble knowing how it got those results. this is due to the fact that it does not model the problem space, so is inherently about plausible results, not correct results. there is an example from early usage where they took photos of a forest, and later took photos of the same forest with tanks in it, and trained the system. it perfectly managed to split the two sets. then they took some more photos with tanks, and it failed miserably. it turned out it had learned to tell the difference between photos taken on a cloudy day, and photos taken on a sunny day. while this story is old, the point still applies. the nature of this sort of ai is inherently black box, so you by definition don't know how it gets its results, which makes all such systems not suitable for man rated and safety critical systems. symbolic ai like expert systems on the other hand have a fully auditable model of the problem space as part of how they work. this makes them just as checkable as any other software where you can access the source code. this is referred to as white box ai, as you can actually look inside and determine not just that it produces the right result, but why and how it does it. this sort of system should be compatible with aviation standards.
1
@klafbang what they are admitting is looking for ways to get the code without signing the eula, and this not breaching the rules of the eula. every business big enough to need a legal department looks for the cheapest way to do this sort of thing, and then looks for alternatives, and that is legal.
1
@MarkusEicher70 people have different needs, which leads to different choices. red hat built it's business on the basis of always open, and base yourself on us. later the accountants started to complain, and instead of reducing the developer headcount through natural churn, they decided to go on a money hunt, closing source access to a lot of people who believed them, thus causing the current problems. rocky, alma, parts of suse, oracle linux and clear linux exist to provide support to people left high and dry after red hat decided not to support the needs of those customers. as red hat is an enterprise platform, the support needs can be up to 10 years if you get a problem at the right part of the cycle. third party software is often only tested against red hat, so you either have to pay them the money and sign up to their dodgy eula, or use one of the derivatives. the open source mentality views access restrictions as damage and looks for ways around it. moving to other non derived distributions comes with added costs, as not all the choices are the same and the software you need might not be tested against those choices, so you have to do a lot of testing to make sure it works, then either fix it if you can get the source, or find alternatives. this adds costs, hence people getting annoyed.
1
ibm have a history of dumb moves, and still have corporate memory of the debacle of giving the pc market to microsoft. however it is clear from statements from red hat employees that the decisions are coming from the current management whose every action and statement shows that despite being in the linux ecosystem for over a decade, they have no idea how it works, or what it means to be an enterprise distro. talk about failing upwards.
1
@aheendwhz1 about halfway through the thread, he said that he was not only opposed to rust in his part of the kernel, even though by this point it had been made clear that he literally had to nothing but get out of the way, but that he was going to do everything he could to kill the whole project. That sounds like wanting to burn it to the ground to me.
1
people depended on python 2 because it wasn't perl 6, and it was the new and shiny. then they built huge monolithic apps in it in a way that was hard to split up, requiring a major rewrite of the entire application to move to the new version. really bad design, but that is the history, and they are making the same mistakes with ruby as well.
1
Windows is already dying, as Linux has already killed it. A lot of tasks that used to be done on only windows have moved to new platforms not run by Microsoft. The only place windows is not dead is the desktop, but most things are either moving down the tech stack to smartphones and tablets using apps, up the stack to be web apps, or are open source and open standards cross platform programs. In all of these cases the underlying os is either not windows, or not relevant. This process is accelerating, and once it has gone far enough windows will go the way of the horse and cart, only a lot faster.
1