00:00 <Zarutian_HTC> in these cases often the compilation artifact is never provided to end-users/end-device but must be built often with just make and the flashed in

00:00 <tabemann> the problem is that it is hard to argue with zeptoforth because the kernel and its associated code all exist in the same addressing space with the same accessible words and like

00:02 <tabemann> one thing I think I could change is to use two different licenses - have the kernel be GPLed, while have the remaining Forth code be BSD3/2/1 or MIT, because these parts contain nary a line of code written by Matthias

00:03 <Zarutian_HTC> does not matter that it exists in the same address space in the end, you can say the address space is just the stage in the story-telling in the above metaphor

00:04 <tabemann> I'd have to talk to a copyright lawyer before I adopted said logic

00:06 <Zarutian_HTC> sadly the answer such lawyer will depend on the juristictions law tradition: the above applies to civil law afaiui while it might not under common law

00:06 <tabemann> yes

00:09 <Zarutian_HTC> for instance, I can take GPLed code, change it as I see fit, compile the result and never release the changes iff I never release the compilation artifact.

00:11 <tabemann> I think it only matters if you release the binaries

00:12 <tabemann> because the resulting binaries would be GPLed, and thus the code for their whole would need to be released

00:12 <Zarutian_HTC> it is because copyright licenses are contracts and for such to be enforcable a communication of assent between identifiable parties must occur. And that occurs in GPL case when I release/publish the compilation artifact

00:15 <Zarutian_HTC> there is none of this implied agreement to contract crap that seems to be in common law systems

00:16 <Zarutian_HTC> implied in sense that no communication between the parties ever occured in both directions

00:20 <Zarutian_HTC> this has the funny consequence that EULAs with restrictive clauses and perchance technological enforcement are mostly unenforcable (well beside all copy rights and such reserved) while TOSes are mostly enforcable

00:25 <Zarutian_HTC> Microsoft got in trouble with hardware id perma banning xboxes. If the banned party sold the xbox and the new owner provided Microsoft with notarized bill of sale the Microsoft had to either lift the ban on the hw id or buy back the xbox at their retail price or the price paid in the exchange or provide the buyer with a replacement xbox in exchange for the banned one.

00:27 <Zarutian_HTC> (same make and model with exact same firmware)

00:27 <tabemann> the thing about software licenses is that without them one has no right to use the software in the first place

00:29 <Zarutian_HTC> tabemann: incorrect. The software can be used, like you can listen to a vinyl record on a player without ever having EULA for the record

00:30 <Zarutian_HTC> at least in countries with civil law systems

00:37 <Zarutian_HTC> tabemann: app stores are here an interesting case, there you are 'buying' a contract 'right' in the sense you get the software from the app store at any future time after that to be able (not licensed or such) to use/run it.

00:44 <tabemann> back

00:53 <tabemann> okay, from looking it up

00:53 <tabemann> without a license you cannot distribute, reproduce, or derive something

00:55 <Zarutian_HTC> correct!

00:57 <Zarutian_HTC> though you can make and distribute instructions, effectively a patch, to change a work. But the patch is useless without the work though.

00:58 <tabemann> I presume it's correct that you can sell something provided you don't duplicate it

00:58 <Zarutian_HTC> for instance s/wand/wang/ applied to Harry Potter stories give hillarious results

00:59 <tabemann> like if you have a record collection, and sell the collection to someone else

00:59 <Zarutian_HTC> yebb

01:01 <Zarutian_HTC> and the copy duplication right owner nor the copy authorship owner can stop you

01:01 <Zarutian_HTC> s/and the/and neither the/

01:03 <tabemann> ugh I just realized something

01:03 <tabemann> inlining

01:03 <Zarutian_HTC> took you long enough ;-þ

01:03 <tabemann> when compiling code with zeptoforth, it sprinkles the resulting code with bits of the zeptoforth kernel

01:04 <tabemann> so code compiled with zeptoforth is inherently derived from it

01:04 <tabemann> I was thinking a moment about how if one made sure one's own code compiled with the zeptoforth kernel was above a certain address

01:05 <tabemann> and one pulled just that code as a .ihex file

01:05 <tabemann> and loaded it separate from the kernel later

01:05 <tabemann> that one could say that it could have a different license from the kernel with the kernel being GPLed

01:06 <tabemann> but with inlining...

01:07 <Zarutian_HTC> are you going to only release the .ihex file or also the bsd source code it was compiled from?

01:10 <Zarutian_HTC> s/bsd/mit/ s/mit/whathaveyoubutsimilaropensourcecopyrightlicense/

01:11 <tabemann> the .ihex file could have any license - it could even be proprietary - and it may or may not have its source code released

01:12 <tabemann> the key thing is that the .ihex file shouldn't have to share the same license as zeptoforth

01:13 <Zarutian_HTC> cant help you there. I was only addressing earlier the bsd/mit code using gpl code

01:13 <tabemann> yeah

01:13 <tabemann> bsd/mit is probably the most likely case that'd happen

01:14 <tabemann> but fundamentally

01:15 <tabemann> but fundamentally the license itself of the code being loaded separately shouldn't matter

01:15 <Zarutian_HTC> you could change zeptoforth to emit inlining instructions instead of sprinkling itself into the compiled code. Effectively like Mach-o dynamic loaded code artifact.

01:16 <Zarutian_HTC> then when the thing gets loaded those inlining instructions get interpreted

01:17 <Zarutian_HTC> or just turn inlining off

01:17 <tabemann> I could provide a means of turning off inlining, but that'd almost certainly result in a performance hit

01:18 <tabemann> probably the easiest means though is simply talking Matthias into relicensing as much material as possible and then rewriting the rest, :P

01:18 <Zarutian_HTC> inlining, to me, indicates shitty design decision regarding the cpu isa

01:19 <tabemann> inlining in zeptoforth enables incorporating constants into compiled instructions

01:19 <Zarutian_HTC> tabemann: if you need help badgering him then I am up for it up to a point

01:19 <tabemann> like 4 + becomes ADDS R6, #4

01:20 <tabemann> rather than being this horrific sequence of instructions

01:21 <Zarutian_HTC> eh? I have the habit to just define 1+ to n+ and 1- to n- for small values of n

01:22 <tabemann> I had already did that

01:22 <tabemann> but this in the general case

01:23 <tabemann> all values from -255 to 255 can be added as constants in single instructions

01:23 <Zarutian_HTC> but then again I mostly write forth code for virtual cpu+mem implemented as seq bool circuit ontop of smpc these days

01:24 <tabemann> smpc?

01:24 <Zarutian_HTC> secure multi party computation

01:25 <Zarutian_HTC> architecture is excamera j1 and canonical stackmachine from koopmans book inspired

01:27 <Zarutian_HTC> do not have the luxury of complex logic circuit design

01:28 <Zarutian_HTC> like arm or intel or amd folks have

01:33 <Zarutian_HTC> and I am still trying to get the bloody adder (not incr and decr mind you) below 48 tau

01:33 <tabemann> tau?

01:33 <tabemann> thousand astronomical units?

01:34 <Zarutian_HTC> (tau being half the round trip time between the smpc nodes)

01:35 <Zarutian_HTC> the greek letter tau, used like in capicitor charging time formula

01:36 <tabemann> I know, I was just being silly

01:37 <Zarutian_HTC> this one https://www.google.com/search?q=greek+symbol+tau&client=ms-android-htc-rev&prmd=inv&source=lnms&tbm=isch&sa=X&ved=2ahUKEwijwZGczPbrAhWJsKQKHbbNCVgQ_AUoAXoECA8QAQ&biw=527&bih=239#imgrc=Sgi03v37j3aNWM

01:39 <Zarutian_HTC> it is because the and gates in the circuit need to do nodes intra comms for secret sharing of the intermeditary result

01:40 <Zarutian_HTC> the primitive circuit components I get are: input, output, delay cell, xor, and.

01:43 <Zarutian_HTC> from the last two plus a constant 1 wire I can implement all of combinational boolean logic

01:44 <Zarutian_HTC> add in the delay cell, and all of sequential boolean logic is implentable

01:46 <Zarutian_HTC> so, smpc enables two or more mutually suspictious parties to synthezise a trusted third party between themselfs

01:47 <tabemann> I can see how that'd be useful

01:49 <Zarutian_HTC> and that thing can then get private data from the participants, do the computation on it, and give back results without the participants learning anything more than the results

01:50 <Zarutian_HTC> (and stuff they can infer from those results and their own private data)

01:51 <Zarutian_HTC> it is usefull for that kind of confidentiality

01:52 <Zarutian_HTC> but it is also usefull for throwing a wrench into a lawyers understabding of where the computation is hosted

01:54 <tabemann> because the computation is distributed amongst all the participants?

01:55 <Zarutian_HTC> yes and no participant has meaningfull ?access? to the computations working memory/state

01:59 <Zarutian_HTC> one of the possible computation is vote tallying. So online voting is possible! for cypherpunks of basic sophistication at least

02:03 <Zarutian_HTC> asking normies to flip a fair coin to random sum secret share their votes and sending those shares securely to the correct smpc nodes is a bit too much

04:23 <tabemann> hey

04:43 <proteusguy> tabemann, if you write it from scratch, even if it appears close to identical, it is not a violation of copyright. The idea isn't copyrighted, only the expression of the idea. So for small bits of code you have no issue so long as you haven't actually moved the bits from his source deck into yours. Don't let a viral license ruin your product.

04:47 <tabemann> the main part that matthias seemed reluctant to relicense was the flash code, but at the same time that's one of the easier parts to rewrite

04:48 <tabemann> the other part he didn't want to relicense was the compiler, but my compiler is completely independently written from his anyways

04:49 <proteusguy> yeah just redo the flash and be done with it.

04:49 <tabemann> the parts I realy need to relicense are the double-cell arithmetic code and the platform initialization code (as these are the parts I understand the least)

04:49 <proteusguy> gotcha

04:50 <tabemann> getting the system up to a certain clock is kinda arcane, as is trying to do 64-bit division on a 32-bit MCU with no 64-bit division instructions

04:53 <tabemann> I sent matthias some messages to this effect recently, but he hasn't gotten back to me yet