IRC channel logs

<stikonas>live-bootstrap and linux-from-scratch is only small specific part of software engineering. You can learn some things but that might not be enough for most software engineering jbos

<muurkha>well, there's an awful lot you have to learn to debug "why doesn't this software compile?" or "why does this software I just got to compile crash on startup?"

<muurkha>which might be more important in practice than the names of the 7 layers of the OSI model or the asymptotic complexity of heapsort

<oriansj>muurkha: the AArch64 and riscv64 port of stage0-posix were each done in about a month. Mind you this included creating the M1/hex2 details, writing ELF-headers and doing *ALL* of the coding including hex0 work. So I wouldn't consider myself that special of a programmer as everyone else here seems to be just as good if not better by a large margin at various bits.

***jackhill is now known as jackhill[m]

***jackhill[m] is now known as jackhill

<littlebobeep>Confused about C# bootstrapping here:

<littlebobeep> https://bootstrapping.miraheze.org/wiki/Bootstrapping_Specific_Languages

<littlebobeep>"While the runtime of Mono is written in C, the C# compiler of Mono is written in C# itself, and needs a recent version of Mono to bootstrap. "

<littlebobeep>But this site: https://handwiki.org/wiki/Bootstrapping_(compilers)

<littlebobeep>says C# is bootstrapped

<littlebobeep>how?

<oriansj>littlebobeep: well you could look at how it is built: gnu/packages/mono.scm

<oriansj>well I don't see the C# mono compiler being built. And looking at the history of Mono: https://www.mono-project.com/docs/about-mono/history/ it was always written in C# but bootstrapped from the Microsoft C# compiler

<oriansj>So there might not be a Libre way to bootstrap C# yet

<oriansj>and finding if someone else worked on that problem is complicated by Microsoft using the C# and bootstrap keyword for one of their products

<oriansj>ooh; found: https://www.gnu.org/software/dotgnu/pnet.html

<pabs3>ISTR Mono is merged into the official Microsoft .NET stuff these days

<oriansj>So there is probably a path using pnet to build a version of mono and a chain to the latest C# compiler

<oriansj>and the patents didn't quite expire for C# yet, so there is that complication which the FSF https://www.fsf.org/news/dont-depend-on-mono points out

<littlebobeep>Didn't MS promise not to exert patents on projects?

<oriansj>it would probably be a weekend (to week long) project figuring out the steps and getting a C# compiler into Guix and then we would have to update our wiki accordingly with the praise for the person who did the work.

<littlebobeep>oriansj: one week sounds shorter than 2 years haha

<oriansj>littlebobeep: promises are not legally binding and MicroSoft is a business who will do what makes them more money

<oriansj>littlebobeep: well JavaScript requires much more work to detangle than making a package for a single program, finding the newest version of mono it can successfully build (and then self-host) and then walking the chain to latest

<oriansj>verse JavaScript being: it downloads arbitrary binary blobs from god knows where and figure out what source code corresponds to those blobs and figure out ....

<oriansj>and I updated the wiki to reflect this additional data

<oriansj>and it is buildable C

<oriansj>so still buckets of bootstrapping work to do; shitload of low hanging fruit for anyone to pick up

<muurkha>promises are legally binding; sometimes they are called "contracts" or "covenants" in legalese

<muurkha>most of common law is actually about promises

<oriansj>muurkha: perhaps I should have been more legally precise. I have not seen a Microsoft statement which in the court of law would prevent them from enforcing their patent rights against a party doing Free Software Development

<muurkha>there are various, but none that are as broad as we'd like; https://en.wikipedia.org/wiki/Microsoft_Open_Specification_Promise was one of the first ones

<muurkha>they sure do talk a big game though: https://www.microsoft.com/en-us/legal/intellectualproperty/open-source

<muurkha> https://www.mono-project.com/docs/about-mono/concerns-about-mono/ says "At this point we know of no patents that Mono infringes upon. Any knowledge of such patents would be welcome as it may allow us to modify Mono in a way that reduces or eliminates the concern over infringement."

***DonRichie2 is now known as DonRichie

***roptat is now known as Guest8410

<unmatched-paren>so i'm reading through the asm versions of the stage0 programs, and I'm currently looking at hex0, but i'm not entirely sure how it accesses the command-line arguments?

<unmatched-paren>I understand that linux initializes the stack to contain argv, followed by a null, then env variables

<unmatched-paren> ld a1, 16(sp) # Input file name

<unmatched-paren>why here do we use 16(sp) specifically?

<unmatched-paren>i guess it's to skip argv[0]? but wouldn't that be a 64-bit pointer (which would be skippable with 8(sp))?

<unmatched-paren>i'll have a look at the c versions

<unmatched-paren>OH RIGHT

<unmatched-paren>I forgot about argc!

<unmatched-paren>makes sense now :)

<unmatched-paren>so... does the stack look like this?

<unmatched-paren>long argc (64 bits, 8 bytes), char *argv[] (each pointer is 64 bits, 8 bytes), [however the env variables are represented]

<unmatched-paren>^ with a NULL between argv and the env vars

<oriansj>unmatched-paren: the x86 and AMD64 versions actually do popping of the stack as you would expect

<stikonas>fossy: after your last PR parts.rst is a bit out of date compared to run.sh files

IRC channel logs

2022-04-06.log