IRC channel logs

2022-05-29.log

back to list of logs

<stikonas[m]>mihi: thanks coreutils 6 is probably fine but 8.34 would also have these issues
<mihi>stikonas[m], ah ok, I haven't looked past sysa at all :)
<fossy>stikonas[m]: yeah, sometimes shellcheck makes solutions that don't actually work
<oriansj>or introduce security vulnerabilities
<oriansj>see the Debian/Valgrid incident as an example: https://research.swtch.com/openssl
<fossy> https://github.com/fosslinux/live-bootstrap/issues/177 -- thoughts appreciated
<oriansj>fossy: that is a really hard problem to solve in automation
<fossy>oriansj: how do you mean?
<oriansj>fossy: well not everyone labels their generated files as generated
<oriansj>if they did, this would be a simple grep and done
<oriansj>literally grep -iR "generated file" $package/
<fossy>oh right
<fossy>yeah i'm trying to minimise the existance of them to try to not have them in the first place
<fossy>it is almost impossible to automate finding generated files
<pabs3>we need a proper tool to find generated files. there is suspicious-source in Debian's devscripts, but it isn't well maintained and doesn't have a lot of coverage nor a good design really
<pabs3>"A dependently-typed proof language intended to make provably correct bare metal code possible for working software engineers" https://github.com/magmide/magmide https://news.ycombinator.com/item?id=31543953
<pabs3>"Magmide is purely a research project at this point"
***ChanServ sets mode: +o janneke
<oriansj>fossy: perhaps patches upstream that will result in predictable tags in generated files
<oriansj>unfortunately, I don't see a way to keep the code free of generated files without people putting in work, especially now that AI's trained on source code are now being used to generate "code"
<oriansj> https://www.fsf.org/licensing/copilot/on-the-nature-of-ai-code-copilots
<Irvise_>pabs3: if you like proofs and low level, there is Ada/SPARK :)
<Irvise_>Ada being the Ada programming language with all of its wonders and SPARK being the subset that can actually proves correctness before compilation.
<unmatched-paren>Irvise_: ...which has not yet been bootstrapped :P
<Irvise_>It mostly uses the Ada type-system and its contracts :P
<Irvise_>unmatched-paren: theruran and I are on it ;)
<Irvise_>It will take years however.
<Irvise_>We have basically settled with Chibi Scheme as the platform to bootstrap Ada/GNAT.
<unmatched-paren>interesting! I wish you luck, despite the fact that Ada.Does_Not_Particularly_Appeal_To_Me
<unmatched-paren>But -.o.- people can use whatever language they want to :) unless it's cobol.
<Irvise_>Hehehe, I understand what you mean. But once I saw it being used to abstract away a PWM controller... I just fell in love. And it has been an ever giving language, the more I learn it, the more it gives back.
<unmatched-paren>Ada.Text_IO.Put_Line ("Well, I might take a look. Worth learning as many as possible :P")
<unmatched-paren>Languages, that is.
<unmatched-paren>But really, the overly verbose names are quite offputting. Ada.Text_IO.Put_Line could be reduced to just io.putln.
<unmatched-paren>Also the Fortran-like `if ... end if` thing. The trailing if could easily be dropped. But to each their own :)
<furrymcgee>a tool to find generated files? do generated files even exist?
<oriansj>Irvise: I am glad to hear that you are one that problem, I wish you would share your progress more
<oriansj>unmatched-paren: Bootstrapping cobol will be a billion dollar support contract for financial institutions and it is going to be a boatload of hard work. I actively encourage anyone who wants to get paid to look into getting good at cobol and converting legacy cobol to modern cobol
<oriansj>furrymcgee: based on your question, I think you might have an alternate understanding of what the phrase generated files means. Will you please clarify what you mean when you say that term?
<furrymcgee>ai generated files
<oriansj>furrymcgee: have you not heard of copilot?
<oriansj> https://www.fsf.org/licensing/copilot
<furrymcgee>yes a lot of hype
<oriansj>and here when we say generated files, we mean any text file that isn't written by a human that could based on the FSF standards be called source code
<unmatched-paren>oriansj: Whoever bootstraps first will get a lifetime pass to visit a professional psychiatrist any time they like for the rest of their life.
<unmatched-paren>*bootstraps Cobol.
<oriansj>unmatched-paren: well that usually comes with a good benefits package
<oriansj>if you are willing and able to do the work that other people are not willing or able to do; you can ask for what other people can't
<Irvise_>oriansj: well... Current progress was deciding on a Scheme implementation to use... Here is what came out of it: https://irvise.xyz/Blog/scheme-implementation-comparison.html
<Irvise_>Obviously, all that work was aimed with the #bootstrappable:libera.chat criteria :)
<oriansj>Irvise: nicely done and looks rather complete of a search
<Irvise_>After all that work (which was quite a bit). I went on to talk to the S7 and Chibi people to ask them questions regarding some "in-depth" testing. Mainly "Is it easy to compile and bootstrap?" "Is it easy to run on RISC-V?" "How complete they are?" and some quality-of-live questions.
<Irvise_>oriansj: that was my aim :)
<furrymcgee>I suspect copilot wont tell you if and how a file was generated
<Irvise_>In the end we settled for S7 and Chibi. Yesterday (see https://github.com/ashinn/chibi-scheme/issues/836), our main pain was lifted for Chibi, so I suppose we are ready to go with it.
<oriansj>Irvise: you should feel proud about that work and with that level of attention to detail, I am sure Ada is in good hands
<unmatched-paren>I expect that Copilot won't gain traction in the areas we are aiming at; i.e. not web developers.
<Irvise_>Although x-compiling Chibi is not very straight forward, as it requires to manually patch a line in the Makefile, but that is easily doable.
<unmatched-paren>Or ENTERPRISE CLOUD SCALE MOVE FAST AND BREAK THINGS developers.
<Irvise_>We were aiming to get as close to the seed as possible. That is not really so important was we probably could have moved up to steps ~60 or so, but still.
<oriansj>unmatched-paren: I very much hope so but I try not to bank on that.
<Irvise_>oriansj: thanks :)
<Irvise_>s/was/as
<unmatched-paren>Most systems programmers will probably just stick to their vi/emacs, possibly with autocompletion, but that doesn't really count as generated, does it?
<oriansj>unmatched-paren: I wouldn't count tab completion as generated code but where exactly to draw that line is a very good question that requires more consideration.
<unmatched-paren>The user of autocompletion generally chooses which of a choice of options they want to write themselves. The completion system doesn't analyze the code enough to be generated, imo.
<oriansj>unmatched-paren: also it only populates a single word and not a 500 line block of text
<unmatched-paren>Bad wording. It isn't based on the rest of the code, it's just chosen based on what you've typed. It's a shortcut, not a way to generate code for you. Therefore not generated.
<unmatched-paren>(I meant I had bad wording, not you :P)
<unmatched-paren>oriansj: Well, unless you're using snippet systems...
<unmatched-paren>you might type `if|` and have it completed to `if (|)`, then type a condition and then `)` and have it completed to `if (...) { | }`. Still not generated.
<oriansj>unmatched-paren: well if you write those snips yourself, is that any different than doing C-x (/C-x ) and C-x e
<unmatched-paren>what's C-x/C-x e? I am not emacs :)
<oriansj>super useful when writting a FORTH in assembly because of how repetitive the function headers are
<oriansj>record macro and run macro
<unmatched-paren>ah. (In vim that's q<key> and @<key> respectively)
<Irvise_>Isn't that record macro, execute macro?
<unmatched-paren>yes
<unmatched-paren> oriansj record macro and run macro
<Irvise_>Oh, I think orians was referring to Emacs having that already built into the language mode :)
<Irvise_>In Emacs a macro starts with C-x ( Which I find pretty nice, since it looks like you are writing an emacs-lisp expression (macros-are-code).
<unmatched-paren>ahhh
<Irvise_>Following oriansj recommendation to share my progress... I think we are going to use Chibi 100%! Here is chibi running the its test-suite on RISC-V (ULX3S FPGA, 50MHz, 32-bit IMACFD) :D
<Irvise_>No modifications were done to the src :) https://github.com/ashinn/chibi-scheme/issues/836#issuecomment-1140276734
<Irvise_>theruran: ^
<Irvise_>:D
<Irvise_>Arg, it is this comment (the other link was to the previous one) https://github.com/ashinn/chibi-scheme/issues/836#issuecomment-1140482393
<oriansj>neat
<Hagfish>i don't know what's more impressive: getting chibi running, having a RISC-V on an FPGA, or the fact it has a proper test-suite :)
<Hagfish>anyway, it sounds like some great work and wisdom has gone into reaching that milestone
<Irvise_>The ULX3S is difficult to get nowdays, but it is fully open silicon :)
<Irvise_>Sorry, not silicon as the silicon schematics. But at the PBC level.
<Irvise_>It also uses a fully open toolchain :D The core it is running, SaxonSOC, is fully open too :D
<Irvise_>And it seems that the opinion on Chibi is that "isn't it supposed to be a playing ground Scheme?". But from my experience, that opinion must have come from the beginning of Chibi, it is fairly mature nowdays :)
<Irvise_>S7 Scheme and Chibi did also run flawlessly in RISC-V without changes to the src. Small, well-written programs with little dependence on the OS/Arch does have its advantages :P
<Irvise_>The main shortcoming of the ULX3S is that it only has 32MB of RAM... The new ULX4 will have less "electronics" (GPIO, switches, buttons, etc), but will rock a much larger RAM (I think 1-2GB) with the 84k LUTs from the 85F version of the FPGA. I am saying this in case someone is interested in this.
<Irvise_>(though for the price of the ULX3S-85F to run RISC-V, you could probably get one of the new RISC-V SBCs that are coming out. Same price or lower price, much higher performance, more memory, more basically everything)
*Irvise_ shuts up :P
<unmatched-paren>No, don't shut up! This is all really interesting :)
<oriansj>Irvise: well those wanting an FPGA are a different group of people than those who just want a CPU.
<Irvise_>I obviated the obvious :P
<Irvise_>A few links in case you want to look into this (I know there is some interest in RISC-V here): ULX3S https://ulx3s.github.io/ Nezha SBC (quite powerful, supports the V extension) https://www.youtube.com/watch?v=613yEF6SrNo and VisionFIVE (powerful, but seems to aim IoT) https://www.youtube.com/watch?v=4PoWAsBOsFs
<Irvise_>And if you like Smartphones, RISC-V and hacking: https://www.crowdsupply.com/sutajio-kosagi/precursor
<Hagfish>yeah, thanks for the details. it's great to hear that it even has a fully open toolchain
<Hagfish>too often i see people say "well, it doesn't matter how much you audit the software because you can't trust the hardware"
<Hagfish>it sounds like the sort of attacks they are imagining are close to becoming unrealistic
<Hagfish>i mean, maybe the NSA has spent billions infiltrating every FPGA fab out there to hide quantum nanobots under the surface of the silicon...
<Hagfish>but i think Occam's razor will be on the side of the bootstrappers (and reproducible builders, and auditors, etc.), and not the naysayers
<oriansj>Hagfish: well once we figure out how to build lithography fabs in our garages, if the NSA can compromise all of those, well then. I guess we need to start bootstrapping society too
<vagrantc>/29/29