kobain has quit [Read error: Connection reset by peer]
kobain has joined #lisp
monokrom has quit [Remote host closed the connection]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 240 seconds]
kobain has quit [Ping timeout: 245 seconds]
vms14 has joined #lisp
<vms14>
whose are the functions you've created that you use so often?
meepdeew has joined #lisp
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
<vms14>
I ended using a lot this one (defun make-text-buffer () (make-array 0 :adjustable t :fill-pointer t :element-type 'character)) and the html functions I've made with a bad implementation that return html code
karlosz has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
libertyprime has quit [Ping timeout: 250 seconds]
jackdaniel2 has joined #lisp
karlosz has quit [Quit: karlosz]
jackdaniel2 has quit [Read error: Connection reset by peer]
<White_Flame>
whose are they? they're mine :-P
<White_Flame>
I use deep-mapcar a lot, though
meepdeew has quit [Remote host closed the connection]
<vms14>
White_Flame: what deep-mapcar does?
karlosz has joined #lisp
<vms14>
sounds profound
karlosz has quit [Client Quit]
<White_Flame>
recurses through all CARs of nested lists, as well as the last element of an improper list
<White_Flame>
*of nested list cells
<White_Flame>
also have deeper-mapcar which does hashtable key/values and arrays
<vms14>
do you tend to add stuff to the .sbclrc or alike?
<White_Flame>
only defuns to help load stuff
<vms14>
I'm tempted to add stuff in there, I'll end doing it I guess
<White_Flame>
no, make libs and load them intentionally
<vms14>
it's what I'm doing atm
<vms14>
btw there is no thing like :export :all?
<vms14>
to export all symbols of a package?
<White_Flame>
:: :-P
<Colleen>
Unknown command. Possible matches: 8, help, set, say, mop, get, time, tell, roll, deny,
<White_Flame>
I was unaware we had a functioning bot here
Bourne has quit [Read error: Connection reset by peer]
Bike has quit [Quit: Lost terminal]
<equwal>
I don't see the utility of that.
<oni-on-ion>
thank you for sharing
<equwal>
""The GENERIC-CL-USER package is also provided, which contains all the symbols in the CL-USER package" -- don't do that.
<equwal>
"This package is intended to be used only at the REPL" -- now I really don't see the utility.
<oni-on-ion>
hmm i don't see the purpose of these comments. it just sounds like its not for you
<equwal>
I was hoping for something like "it is useful for this use case where..." or similar. But it seems like it is for...no one?
<oni-on-ion>
rather than to suggest it for this purpose or that developer, i think its cool to have available. i personally happend upon it by someone looking for Lazy Sequences.
<saturn2>
it's for when you want your own objects to work with the usual CL functions
<equwal>
I see that, but only at the REPL?
<oni-on-ion>
saturn2, huh; funny -- thats exactly what the first paragraph of that URL describes it as. perhaps we are too accustomed to scrolling and scrolling and scrolling our social feeds =)
<saturn2>
equwal: the relationship between GENERIC-CL and GENERIC-CL-USER is the same as between COMMON-LISP and CL-USER
<equwal>
Okay I understand it now.
gravicappa has joined #lisp
zooey has quit [Remote host closed the connection]
Oladon has joined #lisp
orivej has joined #lisp
vms14 has quit [Remote host closed the connection]
gioyik has joined #lisp
khisanth_ has quit [Ping timeout: 252 seconds]
jamzattack has quit [Ping timeout: 240 seconds]
oni-on-ion has quit [Ping timeout: 245 seconds]
Lycurgus has joined #lisp
<beach>
Good morning everyone!
<Josh_2>
Mornin
akoana has joined #lisp
meepdeew has quit [Remote host closed the connection]
<p_l>
beach: morning treating you well? :)
khisanth_ has joined #lisp
dddddd has quit [Remote host closed the connection]
zaquest has quit [Read error: Connection reset by peer]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
<beach>
p_l: Yes, thanks. Monday mornings are always chaotic around here. This one a bit more than usual. But it is all planned and under control. You?
<patrixl>
planned and under control monday morning - sounds like a dream job
<Lycurgus>
planned chaos?
<p_l>
patrixl: I don't believe it will happen to me before retirement, and I expect retirement to come maybe ~20 years after I'm dead
<p_l>
... if I'm lucky
Josh_2 has quit [Ping timeout: 252 seconds]
zaquest has joined #lisp
khisanth_ has quit [Ping timeout: 240 seconds]
khisanth_ has joined #lisp
oni-on-ion has joined #lisp
brown121408 has joined #lisp
Inline__ has quit [Quit: Leaving]
brown121407 has quit [Ping timeout: 240 seconds]
dale has quit [Quit: My computer has gone to sleep]
<aeth>
That means that in the future, your employer will revive you from death so you can keep working!
<Josh_2>
this isn't lispcafe :O
torbo has quit [Remote host closed the connection]
gioyik has quit [Quit: WeeChat 2.6]
rgherdt has joined #lisp
shka_ has joined #lisp
rgherdt has quit [Quit: Leaving]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
ravenousmoose has joined #lisp
vlatkoB has joined #lisp
gxt has joined #lisp
ravenousmoose has quit [Ping timeout: 276 seconds]
ebzzry has quit [Read error: Connection reset by peer]
frgo has quit [Remote host closed the connection]
<p_l>
patrixl: *after* my death. what isn't clear is whether I'd be still working, certainly I won't get to enjoy retirement
JohnMS_WORK has joined #lisp
jackdaniel2 has joined #lisp
galdor1 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
akoana has quit [Quit: leaving]
Oladon has quit [Quit: Leaving.]
galdor has quit [Ping timeout: 276 seconds]
galdor1 is now known as galdor
kgop has quit [Ping timeout: 240 seconds]
libertyprime has joined #lisp
cyraxjoe has quit [Ping timeout: 250 seconds]
<flip214>
p_l: obviously you need to enjoy working, then it doesn't matter whether you retire or not
<p_l>
flip214: work has tendency to often not be on topics one enjoys
<flip214>
well, in 18 years you'll be one of the long-sought experts for the 2038 unix date migration, perhaps that's sufficient to let you retire
libertyprime has quit [Ping timeout: 240 seconds]
<markasoftware>
how can I get a random element from a hash table?
<markasoftware>
without loopig through a random number of elements
<Josh_2>
I was gonna say that
<White_Flame>
prefill another hashtable with number->key mapping
<White_Flame>
with randomly shuffled numbers
<White_Flame>
then pull them out in order
<White_Flame>
or dig into the hashtable internals of your implementation, and you'll likely find arrays to index into randomly
scymtym has quit [Ping timeout: 240 seconds]
libertyprime has joined #lisp
flamebeard has joined #lisp
<markasoftware>
ahhhhhhh
<markasoftware>
thanks for the suggestion though
varjag has joined #lisp
Duuqnd has joined #lisp
libertyprime has quit [Client Quit]
<saturn2>
or write your own hashtable implementation
<Josh_2>
maphash it and then break out at a random integer?
cyraxjoe has joined #lisp
mingus has joined #lisp
<saturn2>
he said he didn't want to do that
<Josh_2>
he said he didn't want to use loop xD
<saturn2>
sneaky
shka_ has quit [Ping timeout: 240 seconds]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
ravenousmoose has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
ym has quit [Ping timeout: 265 seconds]
gxt has quit [Remote host closed the connection]
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
ym has joined #lisp
MichaelRaskin has quit [Quit: MichaelRaskin]
Cymew has joined #lisp
ramus has quit [Ping timeout: 268 seconds]
clothespin has quit [Ping timeout: 240 seconds]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
scymtym has joined #lisp
mn3m has joined #lisp
ravenousmoose has quit [Ping timeout: 246 seconds]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
jonatack has quit [Ping timeout: 246 seconds]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
jonatack has joined #lisp
davepdotorg has joined #lisp
anewuser has joined #lisp
karlosz has quit [Quit: karlosz]
hhdave has joined #lisp
gxt has joined #lisp
jonatack has quit [Ping timeout: 252 seconds]
Fare has quit [Quit: Leaving]
ramus has joined #lisp
heisig has joined #lisp
ggole has joined #lisp
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
ljavorsk has joined #lisp
ralt has joined #lisp
frgo has quit [Remote host closed the connection]
raghavgururajan has joined #lisp
gareppa has joined #lisp
ramus has quit [Ping timeout: 240 seconds]
ebzzry has joined #lisp
jonatack has joined #lisp
manualcrank has quit [Quit: WeeChat 1.9.1]
ramus has joined #lisp
frgo has joined #lisp
Achylles has joined #lisp
ManyQuestionsPer has quit [Remote host closed the connection]
avicenna has joined #lisp
montxero has joined #lisp
montxero has quit [Ping timeout: 240 seconds]
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 265 seconds]
makomo has joined #lisp
raghavgururajan has quit [Remote host closed the connection]
cosimone has joined #lisp
gareppa has quit [Quit: Leaving]
longshi has joined #lisp
troydm has quit [Ping timeout: 240 seconds]
jeosol has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 252 seconds]
m00natic has joined #lisp
patrixl has quit [Quit: Leaving.]
patrixl has joined #lisp
pfdietz46 has quit [Remote host closed the connection]
many-questions has joined #lisp
<many-questions>
When I step in slime, SLDB, emacs momentarily flashes a yellow highlight to show which form is being evaluated. Is there a way to make this flash longer, or even have a permanent highlight of the current form?
jackdaniel2 has joined #lisp
cosimone has quit [Quit: Terminated!]
jackdaniel2 has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
Necktwi has quit [Ping timeout: 240 seconds]
cosimone has quit [Client Quit]
jackdaniel2 has joined #lisp
ramus has quit [Ping timeout: 276 seconds]
flamebeard has quit []
jackdaniel2 has quit [Read error: Connection reset by peer]
<Xach>
many-questions: that's an interesting question. i couldn't figure it out quickly from slime.el, but it can't be too tricky.
<trittweiler>
many-questions, There does not seem a way right now to configure this. To change the source code, you would want pass in a third parameter to slime-flash-region in slime-highlight-sexp
rumbler3_ has joined #lisp
<trittweiler>
From an UI point of view, perhaps what should be done is to add a command that redoes the last flash.
rumbler31 has quit [Ping timeout: 240 seconds]
pfdietz has quit [Remote host closed the connection]
longshi has quit [Ping timeout: 265 seconds]
nydel has quit [Read error: Connection reset by peer]
bacterio has quit [Read error: Connection reset by peer]
rople has quit [Ping timeout: 245 seconds]
<Xach>
trittweiler: can you tell me how sldb-step ties in to slime-highlight-sexp? I couldn't see the call sequence.
gabiruh has joined #lisp
semz has quit [Ping timeout: 252 seconds]
bitmapper has joined #lisp
Bourne has joined #lisp
<phoe>
If a Common Lisp type is non-NIL and non-T, then can/should negating it ever produce a NIL or T type?
<phoe>
Set theory tells me that this should never be the case, since a negation of a non-empty/non-universe set is never an universe/empty set.
ramus has joined #lisp
<heisig>
phoe: No, that should not happen.
<phoe>
heisig: thanks. (So it's bugfixing time.)
<phoe>
(NOT (OR (NOT INTEGER) (REAL (-0.5D0)) (REAL * (-0.5D0)))) is the smallest actual test case I've found that produces a NIL ctype on CCL and SBCL.
<phoe>
Hm, wait a second though...
<phoe>
This type is T. There is no object that is able to fail this test.
<phoe>
Let me backtrack a bit.
<jackdaniel>
I'll allow it
<jackdaniel>
;-)
<Shinmera>
That's (AND INTEGER (NOT REAL)), which is NIL.
<phoe>
So this also must mean that (OR (NOT INTEGER) (INTEGER * -1) (REAL (-3.5D0)) (REAL * (-3.5D0))) is T.
<phoe>
And that (OR (NOT INTEGER) (INTEGER * -1) (REAL (-3.926510009989861D+7)) (REAL * (-3.926510009989861D+7))) is T.
bitmapper has quit [Remote host closed the connection]
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 250 seconds]
grabarz has joined #lisp
lucasb has joined #lisp
mingus has quit [Ping timeout: 276 seconds]
longshi has joined #lisp
jackdaniel2 has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
scymtym_ has joined #lisp
scymtym has quit [Ping timeout: 250 seconds]
jeosol has joined #lisp
<trittweiler>
Xach: grep for :show-frame-source in the *.el and *.lisp files. The control flow is not very apparent at all, you are right
<phoe>
Okay, so it seems there are two things to be done...
<phoe>
First, somehow improve the type parsing, so CCL/SBCL can infer from the above type that it is equivalent to T.
<phoe>
Second, try and figure out why the hell (VALUES NIL T) is returned, which means that SBCL/CCL are *sure* that their decision is correct even if it is not.
Kevslinger has joined #lisp
jackdaniel2 has joined #lisp
<jackdaniel>
nil nil is returned from what call?
<jackdaniel>
subtypep on sbcl gives me nil nil
<jackdaniel>
with T as the first argument
amerlyq has joined #lisp
amerlyq has quit [Client Quit]
amerlyq has joined #lisp
bitmapper has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
<Bike>
is that by hand or do you have a deriver for this
<phoe>
Bike: by hand, and we have just proved the first and hardest step up there in #lisp
<phoe>
the later ones are simpler to prove
<phoe>
I mean, s/first/second/
<phoe>
the movement from step 1 to 2 was done by CCL
<phoe>
the first type in caps is where CCL is unable to simplify it further
<phoe>
since it is unable to work with the -3.926510009989861D+7 stuff
<phoe>
it can infer that the third and next types are all equivalent to T
dddddd has joined #lisp
<jackdaniel>
_death: right
jonatack has quit [Ping timeout: 240 seconds]
ljavorsk has quit [Ping timeout: 240 seconds]
dale_ has joined #lisp
dale_ is now known as dale
orivej has quit [Ping timeout: 245 seconds]
<phoe>
okay, there is very slow progress but progress
<phoe>
I am slowly chipping away at that thing.
bitmapper has quit [Ping timeout: 246 seconds]
anewuser has quit [Quit: anewuser]
manualcrank has joined #lisp
jack_rabbit has joined #lisp
brown121407 has joined #lisp
brown121408 has quit [Read error: Connection reset by peer]
<pjb>
phoe: it depends on whether "type-designator-1 IS type-designator-2" means the two type designators are identical, or whether they represent the same type, ie. the same set of values?
<easye>
It's real nice not to have the fans in my aging equipment wheeze on builds.
<Bike>
what does it mean for a type to contain another type, here
rgherdt has joined #lisp
<phoe>
easye: <3
<Bike>
"those types can be *EMPTY-TYPE* or *UNIVERSAL-TYPE* in disguise", yeah, ok
<easye>
As a public service, the Common Lisp Foundation also has Gitlab CI available to all users.
<phoe>
easye: <3 <3
<easye>
But that github/travis stuff has some nice toolin'
<phoe>
Travis has builds on macOS/Windows/Linux for free on github. Sourcehut has Linux/BSDs.
<easye>
But githubt/travis doesn't have Catalina that I can see yet.
<phoe>
Correct. I am not aware of a CI service with Catalina.
<phoe>
;; maybe they can't get any CI utils to run on catalina, which wouldn't surprise me
<easye>
"Correct under Linux means the vendors have the responsibility to make it work on their commercial offering."
<easye>
" maybe they can't get any CI utils to run on catalina": it's gonna take a little elbow grease, but they have the engineering talent and time to do it.
<phoe>
where is that first quote from?
<easye>
Mine.
<easye>
I dunno why I quoted it.
<phoe>
Oh, yes, I think I understand now
<Bike>
sbcl has similar subtypep code, except it divides things into type-classes
<Bike>
and in early-type.lisp it defines the cons type-class to have :might-contain-other-types nil
<phoe>
!!!
<phoe>
that's wrong though
<Bike>
but given the description in the definition of type classes, i'm not sure just switching it is correct
<phoe>
let me read up on that quickly
<Bike>
it's in type-class.lisp, the type-class def!struct
<phoe>
→ #sbcl
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
jackdaniel2 has joined #lisp
slyrus has joined #lisp
jackdaniel2 has quit [Read error: Connection reset by peer]
slyrus_ has quit [Ping timeout: 276 seconds]
bitmapper has joined #lisp
stepnem has quit [Ping timeout: 245 seconds]
stepnem has joined #lisp
gioyik has joined #lisp
grabarz has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
frgo has quit [Remote host closed the connection]
brettgilio has quit [Quit: Quit]
brettgilio has joined #lisp
frgo has joined #lisp
warweasle has quit [Quit: later]
frgo has quit [Ping timeout: 265 seconds]
jonatack has joined #lisp
shka_ has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
davepdotorg has quit [Remote host closed the connection]
gxt has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
slyrus_ has joined #lisp
slyrus has quit [Ping timeout: 240 seconds]
frgo has joined #lisp
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
hhdave has quit [Quit: hhdave]
m00natic has quit [Remote host closed the connection]
retropikzel has joined #lisp
frgo has quit [Ping timeout: 252 seconds]
varjag has joined #lisp
brettgilio has quit [Ping timeout: 245 seconds]
<phoe>
OK. My CCL PR is most likely wrong.
<jjkola>
why?
<phoe>
Discussing with Bike on #sbcl made me realize that ccl::type-might-contain-other-types-p might not be what I think it means.
<phoe>
with Bike and pkhuong that is.
jackdaniel2 has joined #lisp
<jjkola>
oh, I see
<phoe>
"contain" might be used as in set theory
<phoe>
A "contains" B if A is a subset of B
<pjb>
Note that there's no type type in CL. Only type-specifier = sexp.
jackdaniel2 has quit [Read error: Connection reset by peer]
<pjb>
So compilers need to define their own type type.
<phoe>
That is how it is used in SBCL internals. I wonder if that is also the case in CCL internals...
<phoe>
pjb: yes yes, both SBCL and CCL have their own internal implementations
<phoe>
they are both called ctypes
gioyik has quit [Ping timeout: 240 seconds]
<phoe>
and by "types" up there, I mean these ctypes
<pjb>
phoe: but worse, a type containing types, be them ctypes, would still be strange.
<pjb>
this would be a type useful only inside the compiler.
<phoe>
pjb: but that is what compound types are
<pjb>
Perhaps to compile the compiler?
<pjb>
phoe: not if "contains" = set membership!
<phoe>
let's not confuse things
<pjb>
But you said it was subset.
<pjb>
So ok..
<phoe>
I am talking about :might-contain-other-types nil that Bike mentioned up there
<phoe>
"contain" - what exactly does it mean
<pjb>
phoe: IMO, renaming is an important part of maintainance. ccl::type-might-contain-other-types-p -> ccl::type-might-be-a-subtype-of-other-types-p
<phoe>
pjb: that doesn't make sense, everything is a subtype of T for instance
<pjb>
contain = ∈ subset = ⊂
<phoe>
and STRING is a subtype of VECTOR is a subtype of ARRAY and so on
<pjb>
phoe: this is why CL doesn't define a type type, I would guess.
<pjb>
Logical paradoxes occur when your language allows type type.
<phoe>
and the only ctypes that satisfy TYPE-MIGHT-CONTAIN-OTHER-TYPES-P are hairy, negation, union, and intersection types
<pjb>
Bike: paradoxes such as the type of all types.
<phoe>
pjb: I'll rename it when I figure out what the hell it means and what the hell is it supposed to do
<Bike>
but that didn't come up in the conversation.
<pjb>
Does the type of all types belong to the type of all types?
<phoe>
Bike: pjb loves doing stuff like that
<Bike>
i know. i keep going for it, like an idiot.
<phoe>
picking on words and then bringing up straw men to attack
<jjkola>
pjb: I would say yes
<pjb>
I've debugged quite a number of bugs by renaming things globally in projects…
<pjb>
just by renaming.
<phoe>
pjb: I agree that this function needs to be renamed
<phoe>
but I need to figure out what it should be renamed *to*
<Bike>
phoe: I think the idea is that an instance of a type-class is a type, and that, if a type-class does not "contain other types", instances of that type-class are disjoint from instances of distinct type-classes
frgo has joined #lisp
<phoe>
Bike: CCL sources seems to agree with SBCL ones. The only four defined type classes in SBCL that have true might-contain-other-types are hairy, negation, union, intersection.
<Bike>
what about member?
rgherdt has quit [Ping timeout: 246 seconds]
<jjkola>
pjb: as type of all types contains all types thus it must also contain type of all types otherwise it is not type of all types
<phoe>
So my CCL fix is incorrect and might likely cause SUBTYPEP to behave incorrectly - as in, the patched SUBTYPEP could return NIL NIL instead of NIL T
<phoe>
yes, I think so
<phoe>
that by the time CSUBTYPEP is reached these are expected to be normalized away
<Bike>
no, (sb-kernel:specifier-type '(eql (3))) is a MEMBER-TYPE
<Bike>
wack
<phoe>
well anyway
<phoe>
this means that the proper issue is to fix this
<phoe>
even though (real -0.5d0 -0.5d0) is a subtype of (not integer)
<phoe>
well likely it does
<Bike>
er. wait, i see, it's all reals minus -0.5d0
<phoe>
but it doesn't see that -0.5d0 is a part of (not integer)
<phoe>
neither does CCL
<phoe>
I elaborated on a possible fix for that on #sbcl.
<Bike>
fuckin... anti ranges...
<phoe>
algebra is hard™
<Bike>
sbcl doesn't seem to detect these anti ranges
<Bike>
just as well, they're stupid
<phoe>
it likely needs to be smarter about merging ranges that end and begin on the same exclusive bound
<Bike>
well it can't merge them. that's a different thing from a range
<phoe>
wait, what do you mean by range then
<phoe>
is it a standardized math term that I am oblivious of because I learned it in Polish
<Bike>
er, no, just... you know, between two numbers
<phoe>
oh
<phoe>
wait, it CAN merge them
<Bike>
your disjunction of real types here adds up to all reals, except for this one real.
<Bike>
that's not a range.
<phoe>
if it can infer that the exclusive bound is elsewhere in the type
<phoe>
if it has (-inf, 0.5d0) sum (0.5d0, inf)
<phoe>
then it can look if 0.5d0 is anywhere else in the union type
<Bike>
holy shit nearly pasted my whole buffer in here, let's not do that
<phoe>
if yes, then bam, it can merge them
<Bike>
what i mean is that sbcl doesn't treat that sum specially
<Bike>
it ends up with just a union-type
<phoe>
and it should
<Bike>
no, you want it to also be smart enough to figure this othher thing out.
jonatack has quit [Ping timeout: 240 seconds]
<phoe>
or that, yes
<Bike>
if it's just a union type the ranges might as well be satisfies types for all it knows about them together
<phoe>
but we can't fix it with :might-contain-other-types
<phoe>
so we need to look for an even better solution
<Bike>
probably not, no.
<phoe>
which I don't know what it might look like
<phoe>
OK, let me sum up
<phoe>
one thing is (or (real * (-0.5d0)) (not integer) (real (-0.5d0))) not being detected as a T
<phoe>
what is the other thing again? I mean the one you meant by 19:17 < Bike> no, you want it to also be smart enough to figure this othher thing out.
<Bike>
well that's pretty much the same thing.
<Bike>
the analysis you're talking about doing is kind of predicated on the idea that (or (real * (-0.5d0)) (real (-0.5d0))) is handled more intelligently.
<Bike>
or like, at all
<Bike>
specially
<phoe>
it is just a special case of merging ranges
gioyik has joined #lisp
<phoe>
where you want to merge two ranges that neighbor but you need to find the point between them
<phoe>
that could be a function added to the mechanism that already merges ranges
<Bike>
what i'm saying is that it doesn't get to that point, yes.
<phoe>
I didn't mean that
<phoe>
I meant that when SBCL has two ranges that have the same exclusive bound, one starting, the other ending
jonatack has joined #lisp
<phoe>
it could go look around for that missing point in between them
<phoe>
as a part of its range-merging routines.
<Bike>
it doesn't know that (or (real * (-0.5d0)) (real (-0.5d0))) is (and real (not (real -0.5d0 -0.5d0)))
<Bike>
though it can figure it out with subtypep, apparently
<phoe>
it can figure it out then! if it has a union ctype with a range type with an exclusive bound, then it can look through all other ctypes in the union type
<phoe>
to see if another exclusive bound ends just where this exclusive bound begins
<Bike>
oh, i see, because it normalizes these to the same type.
<phoe>
if that is true, then it can look for the third ctype - the one that contains that missing point
<phoe>
and if it finds all three, then the ranges can be merged
<Bike>
that is, it makes a range for real, and then subtracts out the (real -0.5d0 -0.5d0) to get the same union type.
<Bike>
going the other way it probably couldn't do though.
<phoe>
I mean the following algorithm
<phoe>
SBCL grabs a (real * (-0.5d0))
<phoe>
it notices that it has an exclusive upper bound
<phoe>
and it has nothing to merge that range with using its current methods
<phoe>
so it iterates through all remaining ctypes to see if there is one whose *beginning* exclusive bound starts at -0.5d0
<phoe>
it finds (real (-0.5d0))
<Bike>
or, presuming it's in the middle of computing a disjunction, it sees if any of the types the exclusive range is being disjoined with includes the missing point.
<phoe>
so now it iterates through all remaining ctypes to see if there is anything that is a supertype of (real -0.5d0 -0.5d0)
<phoe>
if yes, then we have the full range - so it can merge the hell out of it
<phoe>
basically - SBCL right now doesn't work with these missing points
<phoe>
and it could and I say it should
<pfdietz>
I have a feeling solving the general case here will look a lot like a SMT solver.
sjl_ has joined #lisp
xuxuru has joined #lisp
<phoe>
the general case is solving this problem for all dense sets that SBCL can operate on
<phoe>
so that is, reals, ratios, {double-,single-,short-,long-,}floats...
<phoe>
and this directly calls type-might-contain-other-types-p
<Bike>
this is for = of two unions, or just anything with a union?
many-questions has quit [Remote host closed the connection]
<phoe>
documentation for INVOKE-TYPE-METHOD
<phoe>
;;; Invoke a type method on TYPE1 and TYPE2. If the two types have the same
<phoe>
;;; class, invoke the simple method. Otherwise, invoke any complex method. If
<phoe>
;;; there isn't a distinct complex-arg1 method, then swap the arguments when
<phoe>
;;; calling type1's method. If no applicable method, return DEFAULT.
<Bike>
hrm.
clothespin has joined #lisp
<phoe>
one type is UNION-CTYPE and the other is CONS-CTYPE
<phoe>
so a complex method is called
<phoe>
and CONS-CTYPE has no complex method
<phoe>
so the complex method for UNION-CTYPE is called
<phoe>
and the only possible results here are NIL T and NIL NIL
<phoe>
which is already a bad sign
<phoe>
because we can only bail out and confuse ourselves and we cannot return T T at this point
<Bike>
and the union is all of cons types, so none of them have type-might-contain-other-types-p.
<phoe>
yes
<phoe>
and the cons types are disjoint
<phoe>
because the car-type of the first cons is the hellish T type in disguise that wasn't detected
<phoe>
hence my reasoning - if we solve this T detection, then this type nicely folds up into a T
<phoe>
and we return T T much earlier on
<phoe>
because in this complex-= method, the only thing we can effectively do now is return NIL NIL
<Bike>
well i'm just wondering if this couldn't ocme up with some unrelated weird type.
<phoe>
pfdietz has his random subtypep tester, we could possibly adapt it to turn CCL's subtypep into swiss cheese.
<phoe>
but my opinion is to fix what we have now in CCL with the tools that we have, especially since numeric ranges are actually used and utilized and it is possible that someone will end up with a weird range like this someday.
<phoe>
(this situation we're talking about now was actually found by the random tester.)
<Bike>
huh, if i try this with satisfies types i just get... nil
<phoe>
we've just eliminated union types from the equation
<Bike>
haha, why the heck
<Bike>
that one properly returns NIL NIL in sbcl.
<phoe>
that is three problems now
<phoe>
fuckity fucketty fuck
<Bike>
i'm helping!!
<phoe>
yes you are!
<phoe>
#| even though I quietly hoped that your help would reduce the number of open bugs, not increase it |#
Xizor has joined #lisp
<jasom>
so https://github.com/norvig/paip-lisp/issues/10 being on the front-page of HN reminded me of my attempts to get abcj running in DoppioJVM (a JS JVM impelmentation). It works, but the startup is *very* slow any idea what happens between "Low-level initialization" and "Startup completed"? I'm seeing over 90 seconds spent in that time...
<Xach>
what is abcj?
<jasom>
s/abcj/abcl
<Xach>
ah
<Xach>
i don't know the answer, sorry. in my experience abcl is slow to start up directly on my laptop, too, but it's not 90 seconds.
<jasom>
It's junder 1 second to reach the "Startup completed" message on my workstation and 106 seconds on Firefox, 45 seconds on chromium.
<jasom>
And another minute or so from "Startup completed" to getting a REPL.
<phoe>
I'd try and profile it there to see where it spends the longest
brown121408 has joined #lisp
<phoe>
Bike: okay, that is three different bugs
<phoe>
on CCL that is
<phoe>
one - ranges are not merged properly
<Bike>
well, that's an enhancement.
<phoe>
two - union types with conses are overconfident
<phoe>
three - cons types with satisfies are overconfident
<phoe>
the first one I can solve with numeric things, the way I intended
<phoe>
the latter two, I'll think of once I fix the first one
brown121407 has quit [Ping timeout: 276 seconds]
<phoe>
does that sound somewhat sane?
<Bike>
sure.
<phoe>
OK - I'll go reset my mind and likely start from tomorrow.
rippa has joined #lisp
<phoe>
it seems that the ctype vocabulary in CCL and SBCL is similar
<phoe>
so maybe my anti-range merger will be fully portable across the two
sauvin has quit [Ping timeout: 246 seconds]
vlatkoB has quit [Remote host closed the connection]
<Bike>
i think i see what's going on with the cons type one.
<Bike>
the (cons :simple-subtypep) method checks both subtypeps, obviously, and gets NIL NIL and T T for my example, respectively.
<Bike>
then it merges those into NIL T
<Bike>
seems easy to fix
<Bike>
probably what it's meant to have is that if one of the inner subtypeps is NIL T, the conses' subtypep is NIL T regardless of the other one.
<jasom>
heh, I just ran the boyer test from the gabriel benchmarks (chosen alphabetically). It's ~200 times slower in the browser, so it seems to just be an across-the-board difference in performance between the two JVMs.
<phoe>
wait a second
<phoe>
why does it merge it into NIL T
<phoe>
NIL NIL means that the compiler just dun goofed
<phoe>
so the result is undefined
<phoe>
jasom: welcome to the future
<phoe>
Bike: when you have something postworthy, please post at https://github.com/Clozure/ccl/issues/249 - my brain is unable to comprehend Lisp right now, so please treat anything that you tell me as lost
<Bike>
ok.
<phoe>
I'll be better tomorrow, but today I've been digging into the type system for about eight hours straight
<phoe>
I need to run my GC overnight
hiroaki has joined #lisp
ebrasca has joined #lisp
brown121408 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
bacterio has joined #lisp
<Bike>
ppppposted
<phoe>
Bike: there is no (satisfies bar) in the last example
<phoe>
but there is one in your post
<phoe>
did you mean foo2?
<Bike>
fxd
<Bike>
i did
slyrus__ has joined #lisp
<phoe>
спасибо
stepnem has quit [Ping timeout: 250 seconds]
gravicappa has quit [Ping timeout: 240 seconds]
stepnem has joined #lisp
<phoe>
I'll digest that slowly and come up with a fix mayhaps
<phoe>
and a few more ANSI-TEST tests
gxt has joined #lisp
<Bike>
well, i could probably write a fix, it's just that `if` form is messed up
slyrus_ has quit [Ping timeout: 240 seconds]
<Bike>
that that*
brettgilio has joined #lisp
<phoe>
go ahead then
<Bike>
yokay
ggole has quit [Quit: Leaving]
<Bike>
let me just think back to how to do karnaugh maps with 3 valued logic
bitmapper has quit [Ping timeout: 250 seconds]
pfdietz has quit [Remote host closed the connection]
slyrus has joined #lisp
pfdietz has joined #lisp
lavaflow has joined #lisp
slyrus__ has quit [Ping timeout: 265 seconds]
<pjb>
Bike: you need 8 boxes.
<pjb>
2*4 with 2 groupings: 2|2 and 1|2|1
<Bike>
actually i guess what i actually want is a 4d kmap, except i absolutely don't want that
<pjb>
Oh, sorry, 3-value. So 3*3 nine boxes.
ebrasca has quit [Remote host closed the connection]
<pjb>
Bike: I understand. I would write a program to generate them.
<PuercoPope>
jasom: I wonder how feasible would be to use clasp to compile CL to WebAssembly through LLVM's WebAssembly backend
<phoe>
then that's a concrete Lisp topic to talk about
<mooch2>
yeah but i don't want to keep other conversations from happening here!
<phoe>
mooch2: the channel is not all that high-traffic
<mooch2>
yeah, true, but still
<jasom>
PuercoPope: clasp is a maybe, if it uses C++ exceptions for non-local transfers of control. IIRC ECL and CLISP are both a no-go for webassembly due to the way they do non-local control flow transfers.
grabarz has joined #lisp
<phoe>
mooch2: I'd worry only after and if someone tells you to take your discussion elsewhere
<mooch2>
aight fine...
jackdaniel2 has joined #lisp
<phoe>
I say that writing an X emulator in Lisp is a #lisp topic
<phoe>
and so are the Lisp-specific issues that might arise
<mooch2>
well, anyway
<jasom>
PuercoPope: does clasp have an interpreter? Last time I checked, LLVM wouldn't run under webassembly so compilation in the browser is also problematic.
<LdBeth>
Sure, so how to emulate CPU clocks?
<mooch2>
i'm currently working on a multi-system emulator project if anybody wants to contribute https://gitlab.com/cl-emu
<mooch2>
so far, i'm starting with the nes
<dlowe>
seems like the easiest thing to do (which wouldn't be easy) would be to treat wasm as an sbcl backend and cross-compile the works
<mooch2>
but anybody's free to start their own cores
<mooch2>
the only rule is one core per real device, and one core per real machine
jeosol has quit [Remote host closed the connection]
<mooch2>
*real machine type
<PuercoPope>
jasom: I'm not to familiar with Clasp. Last time I tried building it was last year.
bars0_ has joined #lisp
<Bike>
yes, it probably wouldn't be good for webassembly
<phoe>
mooch2: per real machine? what do you mean?
<mooch2>
like, one for neses, one for snes, one for the mega drive, etc
<mooch2>
one for the pc and its clones
<jasom>
Really a bytecode targeting lisp coupled with a fast js/webassembly interpreter for the bytecode would probably be best. Webassembly is just not a great target for lisp.
<phoe>
oh, core as in an object that implements target system
<phoe>
I thought for a moment that you meant a physical CPU core
<phoe>
welp, I got confused, sorry
<mooch2>
nah lol
<jasom>
dlowe: that's probably only marginally easier than getting jscl to be more spec compliant.
<mooch2>
i also want to create a frontend that can handle any type of system, and change properties of the systems, such as which software it's running, flipping a floppy disk, or changing the cpu in the case of computers
<dlowe>
jasom: I'm also thinking about the quality of the result
<phoe>
mooch2: smells like reimplementing RetroArch
<mooch2>
kind of
<dlowe>
jasom: and that sbcl is meant to be ported to different cpu archs
<mooch2>
more like reimplementing higan
<mooch2>
though it would be best if the machine cores were plugins that you switched between
<mooch2>
i don't know how to do that in lisp though
<jasom>
dlowe: I've yet to find a single example of wasm generating new wasm to be loaded at runtime though.
<dlowe>
jasom: hm. okay, that would be a problem
<jasom>
dlowe: also sbcl seems to assume a stored-program machine, which wasm is not.
<phoe>
jasom: why would that be forbidden though
<phoe>
generate wasm, pass it around via javascript, load it
ralt has quit [Quit: Connection closed for inactivity]
<phoe>
as long as two wasm programs can link together that shouldn't be an issue
<Shinmera>
dlowe: WASM is not ASM.
<jasom>
phoe: but I think that implies a javascript shim for calling from one wasm linking unit to another (I haven't read the spec closely)
<phoe>
mooch2: plugins are doable - for instance your cores can be CLOS objects and common functionality can be declared via generic functions, and implemented by defining methods on the GFs.
<phoe>
mooch2: read up on Practical Common Lisp's CLOS chapter to get the CLOS basics
<mooch2>
nono, i mean dynamically loading them at runtime
<phoe>
that is doable
<mooch2>
so you don't have to distribute ALL the cores when you distribute the frontend
<phoe>
you have #'LOAD available for lowlevel stuff
<jasom>
mooch2: (load) is a thing.
Cymew has quit [Quit: Konversation terminated!]
<mooch2>
yeah, but i'm planning for each core to be multiple files and shit
<phoe>
for more intricate modules you can use ASDF
<phoe>
and possibly Quicklisp
<mooch2>
ah, okay
<LdBeth>
#'compile is another
<phoe>
so you can (ql:quickload '(:my-emu :my-emu.nes :my-emu.snes :my-emu.psx))
<mooch2>
ah, fair enough
<jasom>
phoe, dlowe, basically each compilation in a wasm implementation would require a dlopen() call to get it into the same linear memory space.
<mooch2>
i want to like, make dlls or something though
<phoe>
and this will not pull in :my-emu.amiga unless any of these systems depends on these
<phoe>
mooch2: you can distribute FASL files if you want to. Source distribution is very much preferable though.
<mooch2>
i want the frontend to have a gui option for selecting a dll or something to load in and use as a system
<phoe>
why DLL? just list all available cores
<mooch2>
i mean, i am still going to contribute source, but i don't want to pull in EVERYTHING every time i load the frontend
<dlowe>
okay, so I guess a bytecode implementation like clisp would be a better option.
<jasom>
mooch2: you can use asdf to generate a bundle if you prefer, but a source-tree is only different from a dll at the file-system level.
<phoe>
mooch2: I don't understand, why would you pull in everything
<phoe>
load just :my-emu.gui
<jasom>
mooch2: see e.g. clack which includes many backends, but only loads a backend when it is used.
<phoe>
and then you can load :my-emu.nes when a NES game is booted up
<White_Flame>
mooch2: btw, since this is lisp, you should start with dynarec by default
<phoe>
you can do that at execution time without any problem
<mooch2>
because i'd have to in order to be able to have per-system configuration options
<phoe>
no
<phoe>
why
<phoe>
you can configure a system without loading all of its internal junk
<mooch2>
White_Flame, no? dynarecs can't be cycle-accurate
<LdBeth>
mooch2 is maybe think about SML like functors
<mooch2>
phoe, yeah, but i want the machine system to have like, the configuration options defined in a structure in that system, and then i'd only load the configuration options if the core is loaded
<White_Flame>
mooch2: you could still be cycle accurate, and still likely maintain far better speed
<phoe>
mooch2: I don't understand then
<hortiel_>
can we avoid js using lisp
<hortiel_>
why everyone hates lisp.. although I love it
<mooch2>
White_Flame, not with a dynarec!
<phoe>
if you distribute a DLL then you will have to load that DDL anyway
<hortiel_>
thinking of learning it
jonatack has quit [Ping timeout: 246 seconds]
<phoe>
so if you want to be able to configure all cores then you have to load all the DLLs anyway
<mooch2>
phoe, i dunno...
<mooch2>
okay, fair enough :/
<dlowe>
hortiel_: so you love lisp but you've never learned or used it?
<mooch2>
sorry, i'm dumb lol
<phoe>
this is not a Lisp problem
<White_Flame>
mooch2: lisp sexprs are a way better codegen than outputting asm instructions in normal dynarecs.
<phoe>
this is an architectural issue
<hortiel_>
dlowe: yes, first love then learn
<phoe>
you want to be able to configure your system without loading it
<hortiel_>
I decided metaprogramming is great
<phoe>
that is possible, for example by splitting your system into my-emu.nes.config and my-emu.nes.backend
<LdBeth>
hortiel_: JavaScript these days is like assembly. You may avoid it depends on what kind of tasks you’d like to do
<phoe>
load only :my-emu.nes.config at startup and use the configuration options that it presents to you
<hortiel_>
js is spreading like virus
<mooch2>
White_Flame, except dynarecs rely on pre-decoding the opcodes and then running them all as one big block
<phoe>
and then when you want to fire up a game then load the heavy machinery in :my-emu.nes.backend that depends on :my-emu.nes.config
<mooch2>
but for cycle accuracy, you can't do that
<mooch2>
phoe, ahhhh okay
<LdBeth>
mooch2: that’s what I want to ask, how do you control cycle accuracy
<mooch2>
LdBeth, ???
<mooch2>
what do you mean?
<White_Flame>
mooch2: usually cycle accuracy requiring events between various chips happen in a minority of cycles. Being able to unroll and partially reevaluate instructions can get you better speed in the straightforward portions, and run slow paths when accesses intersect, depending on the architecture
cosimone has joined #lisp
<LdBeth>
mooch2 How to ensure every OPCODE runs in constant time?
<White_Flame>
it's an interesting field that since Lisp can do much better codegen, can yield better speed than C-based emulators that have to do everything more interpreted
<mooch2>
LdBeth, that's... not the problem lol
PuercoPope has quit [Remote host closed the connection]
<jasom>
White_Flame: many emulators do not hold that the minority of cycles require cycle accuracy because the majority of instructions will access a shared memory bus.
<jasom>
okay, maybe not majority, but a large minority at least.
jackdaniel2 has quit [Read error: Connection reset by peer]
clothespin_ has joined #lisp
<White_Flame>
for instance, on a single raster line the more fixed-function chips know what spots are "live". If the CPU's processing within that line touches one of those locations, you break out of the fast path
bitmapper has joined #lisp
<pjb>
mooch2: 1- you can create a new channel just by joining it. You can "lock" it and become op by using freenode bots, I don't know how, read freenode documentation.
jonatack has joined #lisp
<dlowe>
mooch2: msg chanserv help
<mooch2>
pjb, i know that, i just wanna try to get people to try joining it
<mooch2>
???
<mooch2>
i didn't say i was having trouble making the channel or anything lol
<dlowe>
I think you'll get more traction on emu channels
<LdBeth>
mooch2: since you already have a project you can put the channel in your project description
<pjb>
mooch2: 2- there are a lot of different kinds of emulators and they can be written in CL. It's indeed an interesting subject. It may be interesting to divert their the discussion to a specific channel, when it becomes too loudly, crowding the general discussion in #lisp. So if you expect a lot of traffic specifically about emulators in CL (or in lisp in general), it may be interresting to create this channel.
<oni-on-ion>
i've thought of making an emu, would be fun and good excersize and lisp excuse
<oni-on-ion>
there is #lispgames . lots of smarties in there.
<mooch2>
i don't know if there's enough interest though
<White_Flame>
i have a semi-functional ivory chip emulation, but I need some assistance in debugging
<mooch2>
oni-on-ion, the skills of gamedev basically don't apply to emudev at all
<White_Flame>
well, mostly-functional I shoudl say
<oni-on-ion>
(i got the subtext "emu is more sErIoUs than game engine")
<White_Flame>
mooch2: I followed the docs, but it goes off into la-la land on bootup execution
<White_Flame>
across millions of instruction executions
<pjb>
A good ESP32 emulator.
clothespin has quit [Ping timeout: 250 seconds]
<mooch2>
White_Flame, yeah but you might've made an error in your coding of the info from the docs
<White_Flame>
so my next step will otherwise be to disassemble and try to figure out what it "should" be doing
<mooch2>
pjb, ...why are you bringing up so much irrelevant stuff?
<White_Flame>
also, the docs are scattered leaked internal documents
<mooch2>
ah
<LdBeth>
White_Flame: MacIvory?
<White_Flame>
and the VLM itself is not documented at all, and has unknown variances from the hardware ivory envrionment
<mooch2>
wait, isn't it illegal to use them then?
<mooch2>
vlm?
<White_Flame>
symbolics vlm
<mooch2>
what is that though
troydm has joined #lisp
<White_Flame>
dec alpha emulator for symbolics ivory lisp machiens
<mooch2>
ah okay
<LdBeth>
mooch2: I think the patent just expired last year
<mooch2>
???
<mooch2>
it's not the fact that it's patented, it's the fact that those docs are copyrighted
<White_Flame>
where do you think all the console emulator docs came from?
<White_Flame>
video game consoles
<mooch2>
...mate, first off, they're not all from illegal sources
<oni-on-ion>
when i had GBA dev docs they were pirated and leaked (around 2001)
<mooch2>
secondly, it's still illegal according to the relevant court cases about emulation
<oni-on-ion>
more fun to me is to create Fantasy Console. especially with [common] lisp being somewhat halfway there ^_^
<mooch2>
that's not interesting to me tbh
<White_Flame>
most are from illegal sources. they just had sceners rewrite summary docs with the descriptions of their findings of the most critical portions
<mooch2>
...
<mooch2>
yeah, but IT'S STILL ILLEGAL
<mooch2>
and if you're caught, you can be sent to jail and shit!
<White_Flame>
but yeahh, lots of hardware edge cases would have been experimentally discovered, and not be officially documnted at all
<mooch2>
i know
<LdBeth>
Copyright is just you don’t release the doc publicly
<White_Flame>
I don't recall a single case of legal trouble around emu devs based on copyrights of leaked docs
<White_Flame>
but, we're also getting fairly far off topic, #lispcafe also exists
<phoe>
1) emulators were, are, and will be developed despite emulation being a huge grey area, 2) emulation legality is #lispcafe more than #lisp
* phoe
high-fives White_Flame
<oni-on-ion>
i feel we may be going slightly outside discussion of CL
<mooch2>
phoe, emulators aren't the grey area
jmercouris has joined #lisp
<mooch2>
making them using illegally acquired docs is
<mooch2>
emulators are fully legal
stzsch has quit [Ping timeout: 252 seconds]
<phoe>
mooch2: 1) I see, 2) #lispcafe
<oni-on-ion>
noo #cafe is busy with a serious discussion
<White_Flame>
I need to leave, but using "illegal" docs does not mmake the software illegal at all. The software is fine. Only your possession of the docs might be actionable
Bike has quit [Remote host closed the connection]
<mooch2>
White_Flame, it does though
<mooch2>
according to us case law, anyway
<mooch2>
just as using an illegally acquired sdk makes any software compiled with it illegal
<pjb>
mooch2: what stuff do you deem irrelevant?
<LdBeth>
Liking software is different case
<pjb>
mooch2: if you create a lisp channel, you should register it on cliki.net/IRC !!!
<mooch2>
oh
<mooch2>
sorry
<mooch2>
i thought you wanted me to read it for info or something
<pjb>
mooch2: if you're interested in lisp X, the first thing to do is to search X on cliki.net !!!
<mooch2>
da heck is lisp x?
gioyik has quit [Ping timeout: 265 seconds]
<pjb>
mooch2: I'd be interested in having an ESP32 emulator written in lisp !!!
<mooch2>
oh wait durr
<mooch2>
sorry lol
jmercouris has quit [Remote host closed the connection]
<pjb>
Everything is fucking relevant !!!
<mooch2>
pjb, only if i can find a system that uses an esp32
<pjb>
and X is anything you want, such as an emulaotr.
<mooch2>
and acquire a dump of that system
<oni-on-ion>
i've a feeling that illegal docs would lead to enough suspicion. for example if another company made an exact Tesla clone. but then, RMS at MIT labs ...
<LdBeth>
Haha
<LdBeth>
We all know that
<mooch2>
oni-on-ion, not really, it's still describing the same things you'd find reverse engineering the thing
<pjb>
mooch2: emulators are not written from dumps of the silicon design, but from the manual describing the processor.
<mooch2>
pjb, i need to find a system that uses that processor first, i told you!
<mooch2>
pjb, i know that
<pjb>
What for?
<mooch2>
...to test my code?
<mooch2>
seriously, do you think i'm stupid or something?
<pjb>
The purpose of the emulator is to help develop software fo that processor!
jonatack has quit [Quit: jonatack]
<pjb>
mooch2: you start to look stupid, indeed.
<mooch2>
...
<mooch2>
pjb, no, the purpose of an emulator IS TO PRESERVE THE HARDWARE IT EMULATES
<mooch2>
FUCK
<Xach>
If you're new here, it is not always clear that you can and should ignore everything pjb writes in any medium.
<mooch2>
ah, okay, thanks Xach
<mooch2>
Xach, are they just a troll, or?
<pjb>
mooch2: emulators are written in general BEFORE the hardware is completed, to let software engineer develop the software at the same time the hardware engineers develop the hardware!
<pjb>
mooch2: and beware of people advising you to ignore people…
<Xach>
Knows CL, but aggressive and vile, not worth the trouble.
<mooch2>
ah :/
<phoe>
pjb: you are semantically correct but people commonly refering to emulators usually refer to retro-emulators where you already have all the software but lack a physical machine.
<oni-on-ion>
mooch2, yea but isnt reverse engineering wrong/bad ? in legal terms that is
<mooch2>
oni-on-ion, no?
<mooch2>
it's protected under the dmca lol
<phoe>
NES, SNES, VLM, et cetera, et cetera.
<mooch2>
mate, emulators have already been sued, and won
<oni-on-ion>
if its protected, then does that not mean YES ?
<mooch2>
no, you're allowed to reverse engineer
<mooch2>
i meant that that right is protected
<oni-on-ion>
oh, did not know that. =)
<mooch2>
Xach, are you interested in my emulator project at all, btw?
<Xach>
mooch2: Not in ongoing discussion, but interested in periodic info
<oni-on-ion>
to take a short tangent, we should have the specs/schematics for all parts in our iphones shouldnt we ?
<mooch2>
we don't lol
<Xach>
mooch2: I like neat stuff in any form but can't always follow it in realtime.
<mooch2>
Xach, i mean, you could contribute if you want
<mooch2>
that doesn't have to be done in realtime
<phoe>
mooch2: many of us have little time to spare on contributing whatsoever
<phoe>
there's lots to be done and few free hands
<Xach>
mooch2: oh, I'm afraid I can't contribute
<oni-on-ion>
phoe, owning rom-dumps are wrong though , no?
<mooch2>
ah :/
<phoe>
oni-on-ion: these are obviously copyrighted, same as pirated PC games
<mooch2>
oni-on-ion, only if you didn't dump them from the real hardware yourself
<oni-on-ion>
what system(s) are you planning to emulate ?
<mooch2>
oni-on-ion, anything with a cpu lol
<oni-on-ion>
also of course we should be aware of the difference between Emulator and Simulator. i think pjb referred more to Simulator when considering hardware development
<oni-on-ion>
mooch2, ahh. i was looking at GBA because its awesome. or NDS its bigger brother =)
<oni-on-ion>
phoe, the hardware is not copyrighted?
<pjb>
So you'd say that qemu should be renamed qsim.
<mooch2>
oni-on-ion, ??? no, it's patented lol
retropikzel has quit [Quit: Leaving]
<mooch2>
also, a rom isn't hardware, it's software
* oni-on-ion
is learning the legal differences between hardware and software =)
<mooch2>
software burnt into a chip
<oni-on-ion>
pjb, yeh and possibly VirtualBox etc ?
hortiel has joined #lisp
<oni-on-ion>
mooch2, ah right
xuxuru has quit [Quit: xuxuru]
hortiel_ has quit [Ping timeout: 265 seconds]
lxbarbosa has joined #lisp
<LdBeth>
mooch2: Can ROM persevere the PCB design of cartridges
Bike has joined #lisp
<oni-on-ion>
i was helping der group whom ripped/dumped the gamecube eeprom it was fun but lost my cube =) i was a pirate at the time so couldnt tell from there if it were immoral or illegal