robdog has quit [Remote host closed the connection]
robdog has joined #lisp
robotoad has quit [Quit: robotoad]
robdog has quit [Ping timeout: 268 seconds]
Demosthenex has quit [Ping timeout: 244 seconds]
Essadon has quit [Quit: Qutting]
Demosthenex has joined #lisp
robdog has joined #lisp
robotoad has joined #lisp
Demosthenex has quit [Ping timeout: 250 seconds]
lumm has quit [Quit: lumm]
Demosthenex has joined #lisp
tessier has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
warweasle has joined #lisp
arescorpio has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
Bronsa` has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
makomo has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
bike has joined #lisp
robdog has quit [Ping timeout: 260 seconds]
makomo has joined #lisp
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
permagreen has quit [Remote host closed the connection]
debsan has quit [Ping timeout: 268 seconds]
[X-Scale] has joined #lisp
permagreen has joined #lisp
X-Scale has quit [Ping timeout: 250 seconds]
[X-Scale] is now known as X-Scale
<LdBeth>
good evening
robdog has joined #lisp
arescorpio has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
Arcaelyx has joined #lisp
shifty has joined #lisp
equwal has joined #lisp
<equwal>
good morning
zch has joined #lisp
[X-Scale] has joined #lisp
X-Scale has quit [Ping timeout: 250 seconds]
[X-Scale] is now known as X-Scale
rumbler31 has joined #lisp
malice_ has quit [Ping timeout: 256 seconds]
Bronsa` has quit [Ping timeout: 252 seconds]
slyrus1 has quit [Ping timeout: 250 seconds]
mejja has quit [Quit: mejja]
gxt has quit [Ping timeout: 264 seconds]
dorketch has joined #lisp
ebrasca has joined #lisp
dale has quit [Quit: dale]
robdog has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
<jcowan>
If I were to go to ELS it would have to be by ship. Probably as freight.
anewuser has joined #lisp
<fiddlerwoaroof>
I wonder if there's an audience for an LA-area lisp conference
<fiddlerwoaroof>
or at least a mini conference
<fiddlerwoaroof>
There's a bunch of clojure stuff
robdog has joined #lisp
shifty has quit [Ping timeout: 244 seconds]
<Jachy>
I met the CL Cookbook maintainer once at a clojure meetup, so you might find interest crashing those and inviting people?
robdog has quit [Ping timeout: 252 seconds]
debsan has joined #lisp
gxt has joined #lisp
zch has quit [Quit: Leaving]
SaganMan has joined #lisp
robotoad has quit [Quit: robotoad]
robotoad has joined #lisp
makomo has quit [Ping timeout: 246 seconds]
dddddd has quit [Remote host closed the connection]
robdog has joined #lisp
makomo has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
nirved has quit [Ping timeout: 252 seconds]
elderK has joined #lisp
<makomo>
morning!
<elderK>
Moin1 :)
makomo has quit [Ping timeout: 246 seconds]
equwal has quit [Ping timeout: 250 seconds]
dorketch has quit [Quit: WeeChat 2.1]
<elderK>
Guys, is there a way to use macroexpand inside of a macrolet form?
<elderK>
:) So far when I've found code that uses macrolet, I've had to factor the macros out to be global so that I can expand them to learn from.
<bike>
(defmacro expand-helper (form &environment env) `',(macroexpand-1 form env)) (macrolet ((foo () ...)) (expand-helper (foo))) i think
makomo has joined #lisp
<White_Flame>
I tend to copy/paste it out
<White_Flame>
the macrolet and the macro usage
<White_Flame>
throw a (list ...) in or something to the expansion isnt' evaluated
Lycurgus has joined #lisp
FreeBirdLjj has joined #lisp
<makomo>
elderK: emacs' package macrostep (and the accompanying SLIME contrib) can expand macrolets for you in-place
FreeBirdLjj has quit [Ping timeout: 268 seconds]
<elderK>
makomo: That requires Emacs :P
<makomo>
of course :-D
robdog has quit [Read error: Connection timed out]
wooden has joined #lisp
rumbler31 has quit [Remote host closed the connection]
robdog has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
commanderkeen has quit [Quit: bye]
robdog has quit [Ping timeout: 252 seconds]
snits has quit [Ping timeout: 260 seconds]
snits has joined #lisp
jochens has joined #lisp
jochens has quit [Ping timeout: 244 seconds]
rumbler31 has joined #lisp
robdog has joined #lisp
adolby has joined #lisp
dale has joined #lisp
orivej has joined #lisp
bike has quit [Quit: Lost terminal]
space_otter has joined #lisp
rozenglass has quit [Remote host closed the connection]
rumbler31 has quit [Remote host closed the connection]
rippa has joined #lisp
robdog has quit [Read error: Connection timed out]
dale has quit [Quit: dale]
<beach>
Good morning everyone!
<beach>
dim: Thanks. I'll have a look.
slyrus1 has joined #lisp
emaczen has joined #lisp
<fiddlerwoaroof>
Yeah, as bike points out this is what &environment is for
vlatkoB has joined #lisp
dale has joined #lisp
makomo has quit [Ping timeout: 268 seconds]
lmy9900 has joined #lisp
makomo has joined #lisp
lmy9900 has quit [Read error: Connection timed out]
<Inline>
morning
<no-defun-allowed>
morning Inline
lmy9900 has joined #lisp
les has quit [Quit: ""]
les has joined #lisp
makomo has quit [Ping timeout: 250 seconds]
shka_ has joined #lisp
makomo has joined #lisp
pierpal has joined #lisp
rumbler31 has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
makomo has quit [Ping timeout: 244 seconds]
makomo has joined #lisp
dale has quit [Quit: dale]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
<emaczen>
What are the performance differences between CFFI and a FFI provided by a CL compiler?
<emaczen>
CL implementation*
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
<no-defun-allowed>
i think it should be zilch-ish since most of CFFI would be wrappers like most compatibility packages (closer-mop, bordeaux-threads, usocket, etc etc)
pierpal has quit [Ping timeout: 268 seconds]
<p_l>
emaczen: there might be a small overhead, probably on the order of one-two funcalls depending on what you're doing exactly, can also drop to as low as zero
robdog has joined #lisp
<jackdaniel>
ecl's default static methods is tens of times faster (but it can't be used by default with cffi due to (fixable) architectural problem in the library)
<jackdaniel>
but in principle cffi expands into whatever your implementation provides, so overhead is most likely close to 0 indeed
xkapastel has quit [Quit: Connection closed for inactivity]
Blukunfando has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 260 seconds]
<jackdaniel>
i.e defcfun on sbcl expands into (defun foo () (alien-funcall (some-alien-internals)))
elazul has joined #lisp
SaganMan has quit [Quit: WeeChat 1.6]
angavrilov has joined #lisp
makomo has quit [Read error: Connection timed out]
makomo has joined #lisp
pierpal has joined #lisp
random-nick has joined #lisp
pierpal has quit [Ping timeout: 268 seconds]
robotoad has quit [Quit: robotoad]
trittweiler has joined #lisp
orivej has quit [Ping timeout: 268 seconds]
lumm has joined #lisp
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lumm_ has joined #lisp
pierpal has joined #lisp
longshi has joined #lisp
lumm has quit [Ping timeout: 252 seconds]
lumm_ is now known as lumm
pierpal has quit [Ping timeout: 244 seconds]
space_otter has quit [Remote host closed the connection]
pierpal has joined #lisp
robotoad has joined #lisp
pierpal has quit [Ping timeout: 250 seconds]
<fiddlerwoaroof>
I wish there was a way to express a composition of FFI calls without an intermediate FFI boundary
pierpal has joined #lisp
<fiddlerwoaroof>
I guess ECL has an inline C feature?
lumm has quit [Quit: lumm]
lumm has joined #lisp
lumm_ has joined #lisp
pierpal has quit [Ping timeout: 246 seconds]
pierpal has joined #lisp
lumm has quit [Ping timeout: 246 seconds]
lumm_ is now known as lumm
<jackdaniel>
it does (I'm leaving right now, so I won't answer next question :-)
<loke`>
fiddlerwoaroof: It does, and it's very neat.
Odin- has quit [Ping timeout: 250 seconds]
pierpal has quit [Ping timeout: 246 seconds]
ealfonso has quit [Disconnected by services]
rumbler31 has joined #lisp
nirved has joined #lisp
anewuser has quit [Ping timeout: 246 seconds]
yvy has joined #lisp
lumm has quit [Quit: lumm]
pierpal has joined #lisp
lumm has joined #lisp
elazul has quit [Quit: leaving]
McParen has joined #lisp
FreeBirdLjj has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
lmy9900 has joined #lisp
muyinliu has joined #lisp
lmy9900 has quit [Client Quit]
<muyinliu>
It's there function md5sum-file exists in LispWorks ? (ironclad:digest-file :md5 xxx) seems very slow on LispWorks(1G file took 2345s).
pierpal has joined #lisp
<beach>
muyinliu: Freenode is for free software. For commercial Common Lisp implementations, you are better off contacting the supplier directly .
doubledup has joined #lisp
robdog has joined #lisp
<McParen>
isnt having a stable commercial vendor beneficial for the free ecosystem too?
<beach>
Maybe so, but that's beside the point.
<p_l>
ehh, I'd argue that it's beneficial and that we shouldn't discriminate, but you will have much bigger chances talking on LW support channels (I think they have a mailing list?)
<p_l>
some of the commercial users never show up to community things outside of support lists and so on, I fear
yvy has quit [Read error: Connection reset by peer]
pierpal has quit [Ping timeout: 246 seconds]
<splittist>
late morning, all
<beach>
Hello splittist.
robdog has quit [Ping timeout: 268 seconds]
pierpal has joined #lisp
jcowan has quit [Quit: Connection closed for inactivity]
longshi has quit [Quit: WeeChat 2.3]
debsan has quit [Ping timeout: 240 seconds]
<muyinliu>
I think solving problems is the fun for living, no matter it's commercial or free. If you don't know, just say "I don't know".
debsan has joined #lisp
<McParen>
it does matter though where you decide to ask the question.
debsan has quit [Ping timeout: 250 seconds]
<p_l>
muyinliu: on purely pragmatic grounds, a lot of people here simply don't use/have access to commercial implementations
Necktwi has quit [Quit: leaving]
<elderK>
Evenin' all
<beach>
Hello elderK.
muyinliu has quit []
Necktwi has joined #lisp
<elderK>
beach: Hey! I've been reading through your CLOS MOP pages tonight :) Nice resource.
<elderK>
Also, Happy Saturday (now Sunday) to all.
<beach>
Thanks.
<beach>
I created those pages, because I could not see myself implementing CLOS+MOP from the book or from existing sites.
<elderK>
I've seen it before - but it is a fun watch.
<beach>
What is it?
<elderK>
It's a University Video Communications video about Common Lisp and CLOS. Circa 1987
<elderK>
Daniel Bobrow is presenting it.
<beach>
I see.
<elderK>
The UVC channel actually has a lot of very interesting videos.
<elderK>
Not all related to Lisp, of course, but interesting all the same.
<elderK>
I like that most do not shy away from technical details.
Necktwi has joined #lisp
<elderK>
Kind of blows me away that such videos were once like, distributed to University students and stuff :)
<pjb>
Besides, I've been told that freenode allow discussion of commercial software too.
<elderK>
Also blew me away that MIT had video recordings in the 80s. OU is struggling to do that even now.
<elderK>
beach: As for the MOP pages, I'm finding them very useful atm. It's nice to have an effective reference, rather than having to scan through AMOP
<pjb>
But more precisely, the topic of #lisp is Common Lisp, not specific implementations. Perhaps there's a #lispworks channel? If not may be you could open it (list it in http://cliki.net/IRC) and see how many lispworks users gather there…
<beach>
Maybe we can close this discussion now that the person left?
orivej has joined #lisp
Odin- has joined #lisp
<makomo>
elderK: i've watched that video as well, great stuff :-)
Necktwi has quit [Quit: leaving]
<elderK>
makomo: Yeah! Any chance you know others? I'd like to find some good videos to watch related to Lisp
<elderK>
I mean, I'm having fun of a sort reading and stuff but it would be neat to have videos, too.
<makomo>
i do have a few i think
<elderK>
:P I know, I'm demanding a lot :P :)
<makomo>
lemme take a look
<elderK>
Awesome!
<elderK>
I get a kick out of the CL video - it was the year I was born :)
<makomo>
hah not at all, i have an org file full of lisp notes, resources, etc.
pierpal has quit [Read error: Connection reset by peer]
<elderK>
beach: I was thinking about the ELS. I was wondering if like, the Lispers that go there will just be there for one day? Or will many be around for a few days on either side of it, to socialize / mingle and stuff?
<elderK>
I found another binary library today, too: LISP-BINARY.
<elderK>
Uses the MOP, etc.
<makomo>
it'd be cool if rainer visited #lisp, but i don't think he does
<elderK>
Yeah, he seems very knowledgable.
<elderK>
I've enjoyed watching some of his LispM videos.
<elderK>
One of these days, I might try to get Genera runnign for fun.
<elderK>
Seems some can do it on Ubuntu - should be possible on Crux
<makomo>
yeah, i have to give it a go as well some time
<elderK>
A question, for those about: What kind of provisions exist to like, ensure that the type of stuff, is what you've specified rather than just, check-type on stuff?
<elderK>
Like, I've been thinking about binary structural stuff a lot today - but not directly. I visited a friend today.
<elderK>
But I was definitely thinking of things that most libraries seem to ignore: "Array Slots."
<elderK>
And as far as I know, depending on how an array is initialized or created, it's possible that things are stored in it that are say, not what you'd hope for.
orivej has quit [Ping timeout: 250 seconds]
<elderK>
For a binary kind of thing, we'd want to be able to trust that the slots are filled with stuff that IS the type we expect.
<makomo>
backus and the crew reading code print outs
q-u-a-n has quit [Remote host closed the connection]
q-u-a-n has joined #lisp
<elderK>
:D Cool
<makomo>
but it might be lisp code i think
<beach>
elderK: People typically arrive on Sunday and leave on Wednesday.
<makomo>
wow! the person who shot these last 2 videos and was a secretary of x3j13: "I'm almost 74 now so the only way they'll last is for people to take copies. Encourage that where you can."
<makomo>
a comment on the last video
lxpz has quit [Remote host closed the connection]
<elderK>
Wow indeed
<elderK>
beach: Cool :)
cage_ has joined #lisp
lxpz has joined #lisp
nirved is now known as Guest14048
scymtym has quit [Ping timeout: 246 seconds]
nirved has joined #lisp
eminhi has joined #lisp
<beach>
elderK: So there is typically time for a few beers and a few dinners.
<elderK>
:) Good. I was really hoping that would be the case.
graphene has quit [Remote host closed the connection]
<beach>
Since you would come from afar, you should probably stick around in Europe for a while. There are plenty of Lispers here, so you can visit some of us.
<beach>
elderK: Bike has been here recently, and heisig is a regular visitor. And rme was here not too long ago.
graphene has joined #lisp
Guest14048 has quit [Ping timeout: 252 seconds]
<makomo>
pretty cool :-)
<elderK>
Here as in, in the chat or in Europe? :)
<beach>
In the house of myself and my (admittedly small) family.
<elderK>
Oh wow :) Neat
<beach>
Oh, and drmeister and his family were here for a week not too long ago.
<beach>
Also in our house.
vlatkoB_ has joined #lisp
<p_l>
elderK: i960 or i860?
<elderK>
i960 but i860 is interesting, too.
<elderK>
I've always intended to go to Europe sometime, for this reason. Lots of awesome Scheme meetups, too.
<elderK>
And you guys have the Chaos Communication Congress too, iirc.
anewuser has joined #lisp
<p_l>
i960 was pretty standard RISC, but if you get the rare "full" chip (used mainly by military and aerospace) it had 33bit word size with highest bit used for tagging whether something was a pointer or not
<p_l>
IIRC
<elderK>
p_l: Sounds cool :)
<p_l>
I recently found out that some company licensed materials from intel to restart production
vlatkoB has quit [Ping timeout: 245 seconds]
<p_l>
also, a lot of storage controllers tend to have at least exterior interface made in same style as some of the embedded versions of i960
<elderK>
Interesting.
<elderK>
I heard it was used in like, high-end printers and things. NICS in some cases, too.
<elderK>
Maybe not anymore - but back in the day.
<elderK>
I always liked the idea of them simply because they were not x86 or ARM :D
robdog has joined #lisp
Demosthenex has joined #lisp
ggole has joined #lisp
<fiddlerwoaroof>
elderK: that's a good reason to like something
<pjb>
elderK: fundamentally, in lisp, all functions are "generic" functions; not necessarily generic-functions, but by the general meaning of "generic": they can take any type of argument.
<pjb>
elderK: some functions may have constraints, being able to work only on some specific subtype of T. For example, + can work only on NUMBER arguments. If you pass a non-NUMBER to +, it will signal a type-error, at run-time.
anewuser has quit [Quit: anewuser]
<pjb>
elderK: it's important: (if (primep 44) (+ 1 "eleven") (* 2 6)) will always work. and even the behavior of (if (zerop (random 2)) (+ 1 "eleven") (* 2 6)) is perfectly specified (it either returns 12 or signals a type-error).
Demosthenex has quit [Ping timeout: 246 seconds]
robdog has quit [Remote host closed the connection]
scymtym has joined #lisp
robdog has joined #lisp
<elderK>
fiddlerwoaroof: well, they seemed novel and interesting.
<elderK>
I really liked the 68K architecutre, too, although I never got to program for it.
<elderK>
I did write a half-complete simulator for it a long time ago though
Demosthenex has joined #lisp
<pjb>
elderK: so, the only ways we have to ensure that the type of data is what we want, is to explicitely test forit using typecheck, etypecheck, typep, type-of, subtype, check-type (and also method dispatch for class types); or implicitely using functions that will perform their own type check and signal errors. For example, one whay to test for a list, is to call CAR on it. If it returns something, it's a list; if it signals an er
<pjb>
then it's not.
<elderK>
The i860 and i960 architectures seemed very... interesting to me. It's been a long while but I believe they supported a lot of high-level stuff. Or were intended to, just like the iAPX 4xx
<elderK>
pjb: That would mean for instance, for say binary serialization, that I'd have to check all the things were correct types prior to writing anything out
<elderK>
/or/ rely on the fact that a method specialization was not present, say.
<pjb>
elderK: this is why IMO, 1- you should not declare types, 2- you should use check-type only when it's meaningful at the external interfaces, but leave that out in internal functions, so they can be entirely generic and the only constraints come from the implicity type checking done by the primitive functions.
<elderK>
I would prefer it to be like, impossible to even set the slot of a "binary structure" if the value we're setting it to, is invalid for that slot
<elderK>
Like say, in the "binary structure", you have a slot. This slot is to contain an array of some predefined size, containing objects of a specific type. Now, the array might store primitive numeric types like uint32 or so.
<elderK>
Or it may store instances of other binary structures.
<elderK>
Or perhasp it stores arrays of such structures
<pjb>
elderK: now of course, you have the contradictory requirement that you want to give good error conditions and error messages, reporting the error at the earliest meaningful point for the user. This is why check-type can and should be done at the API level.
<elderK>
but of course, the user can always (setf ...) some bogus stuff there, which will fail during serialization.
<pjb>
This will let you indicate the user the exact parameter that is wrong, in the exact function he called, instead of getting a more cryptic error from an internal function about some derived data he doesn't know where it comes from.
<elderK>
pjb: Yes, contradictory in that I want to avoid runtime type-checking if at all possible, and provide good... safety.
<elderK>
But I guess, I have no choice.
<elderK>
:) check-type and friends. Or typep and such
<elderK>
I was just hoping there was a better way
<pjb>
elderK: if you have a generic function as API, you can provide a default method that will signal a meaningful error message.
<elderK>
But, take the instance of binary structure that has a slot which is an array of say, uints. Now, the user is able to access that "array slot." They are able to (setf ...) that slot, and they are able to update the elements stored in the array that the slot references.
<elderK>
once they get a reference to that array,
<elderK>
They are free to do what they will.
<elderK>
(aref ...) etc, I can't do much about that.
<elderK>
If hte user (setf (class-slot obj) ...)
<elderK>
I /can/ check then that the array they are setting the slot to, is sane.
<elderK>
But if htey are simply getting the slot, and updating the array it references directly with aref, I can't do much
<pjb>
Either you allow it (you can choose to do that if the upgraded element type of that array is exactly the type you want), or you should make it opaque to the user.
<elderK>
So the type checking would have to happen later.
<pjb>
Don't let the user get a hand on the actual data, instead return an opaque object, and provide the accessors.
<fiddlerwoaroof>
elderK: I wasn't actually criticizing your interest in non-x86/ARM architectures.
Demosthenex has quit [Ping timeout: 268 seconds]
<fiddlerwoaroof>
I'm really tired of those two as well
<elderK>
pjb: Right, so wrap the array.
<elderK>
That's not a bad idea - one I ignored.
<elderK>
fiddlerwoaroof: Me too. Much of my tinkering has been on IA32 / x86_32.
<elderK>
But I always wanted to write something for 68K or PPC.
<elderK>
But of course, I never had access to machines using either.
<elderK>
I did have a PPC G4 once. But I did not make use of it
<elderK>
At least, I was not in the zone to do system hacking when I had it
<elderK>
And these days, people want way, way, wayyy too damn much for old Macintosh hardware.
<fiddlerwoaroof>
It depends what you're looking for
<elderK>
I am not going to pay near-1k$ for a friggin G4.
<elderK>
Even 400$ is too much for a G4 PBook
<fiddlerwoaroof>
I've seen some of the business ones for < $100
Demosthenex has joined #lisp
<elderK>
Business ones?
<elderK>
pjb: I'm thinking of writing up my thoughts on like, this stuff, binary serialization and deserialization and stuff.
<fiddlerwoaroof>
From the in-between-steve-jobs phase
<elderK>
And then posting that here, for suggestions, potential solutions to the questions, etc.
<elderK>
At least that way I can present like, the complete idea, requirements, hopes, etc.
<elderK>
What I intend to achieve.
<elderK>
Might make it easier for those guiding me, too
<elderK>
fiddlerwoaroof: Oh, right.
<elderK>
fiddlerwoaroof: There are also like, afaik, PPC-based embedded boards. But last time I checked, they were quite pricey.
<elderK>
fiddlerwoaroof: I also considered buying M68K parts directly and building a little machine to tinker with
<elderK>
Kiwis expect much more for their old Macintosh hardware.
<elderK>
At least, on TradeMe :)
<fiddlerwoaroof>
Oh, I do here everything over their is more expensive, sorry :)
* fiddlerwoaroof
can't spell
<elderK>
NP :P And it can be.
<fiddlerwoaroof>
You might not be interested in SPARC, but you can sometimes find old sun boxes for the same approximate price
<elderK>
One of these days I'd like to write a "MESI" simulator, too. Something simple: You create processor objects, connect them to caches or to memory objects, and then... simulate accesses.
<elderK>
Have hooks that allow you to "see" what's going on.
<elderK>
Not for any practical purpose, really. Just for fun.
<fiddlerwoaroof>
Yeah, I've started that sort of thing a couple times
<elderK>
Since understanding MESI - and things like store buffers and invalidate queues are pretty much necessary if you want to properly grok memory barriers.
<elderK>
It's funny how some "projects" get deprioritized compared to other things in life.
<elderK>
Like all the emulators I intended to write. Or say, compiler stuff I wanted to learn.
<elderK>
:P There's a lot for me to achieve before I am 40.
<elderK>
:) Hopefully CL will help me accomplish those things.
<elderK>
fiddlerwoaroof: I know this isn't really Lisp... stuff, so we might want to (finally?) move to #lispcafe but, do you have any favorite architectures?
<elderK>
The MIPS architecture seemed interesting, too.
<elderK>
And as a side bonus: R4000 is used by the PSX so... there are ways to execute it on a PSX :P
Demosthenex has quit [Ping timeout: 250 seconds]
kajo has quit [Ping timeout: 252 seconds]
Demosthenex has joined #lisp
robdog has quit [Remote host closed the connection]
bike has joined #lisp
makomo has quit [Ping timeout: 246 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
<pjb>
elderK: write assembler programs for the 68k! You'll have fun.
robdog has joined #lisp
<pjb>
elderK: WriteNow, the best word processor ever, was written in 68K assembler on NeXTSTEP.
Lycurgus has quit [Quit: Exeunt]
<pjb>
(unfortunately, this is why when they switched to ix86, WriteNow was lost).
<_death>
pjb: now you have to forego anything that expects an ordinary array
<elderK>
Aye, a good point.
<elderK>
I guess it's all a game of trade offs, though, as always.
<elderK>
I think I will do exactly what I said above though - write down my ideas, goals, etc.
robdog has quit [Ping timeout: 268 seconds]
<pjb>
_death: you can forward anything you want.
<elderK>
pjb: How do you mean?
<elderK>
I mean if they are expecting a slot is an array, and access that slot, they expect to be able to call aref on it
<pjb>
Now, if you want to provide arrays, just with your own patches, it's better to use the same symbol names. So you will forward by shadowing the symbols from CL, defining your own version.
<elderK>
Ah, I see.
<elderK>
So in a sense, I redefine things like aref, etc, and simply forward if it's not my type say
<elderK>
What is the deal with say, defining a function that has the same name as something CL itself provides?
<elderK>
What is there to prevent me from say, defining a new GF "aref" or something
<elderK>
Am I even able to do that if I :use cl?
<jackdaniel>
elderK: package CL is locked, that means that you can't redefine any symbol in it
FreeBirdLjj has joined #lisp
<elderK>
jackdaniel: Right, but whats' the deal with shadowing import then?
<elderK>
What is to stop me say, not :useing CL, and defining functions with the same names as those provided by CL?
<scymtym>
elderK: providing "replacements" for CL operators is actually a powerful technique. the screamer library is an interesting example of this https://nikodemus.github.io/screamer/#Overview
<jackdaniel>
_death: I don't have any issues with shadowing things from cl package if you clearly say so
<elderK>
_death: So, if you properly wrapped things, forwarded, etc, why would that break existing code?
<elderK>
Ignoring the fact that they will need to accept say, shadowing-import
<jackdaniel>
also that ↑ nobody forces existing code to use package which is not cl
<jackdaniel>
if file doesn't have (cl:in-package #:cl) then it indeed agress, that someone may have shadowed in-package
<jackdaniel>
(but this is qutie extreme thing, let's discuss cases where in-package is not shadowed ;-)
igemnace has quit [Quit: WeeChat 2.3]
<_death>
jackdaniel: sure, me neither.. and in this case you can even use sb-sequence to provide access to the controlled array
<elderK>
I tried not like, using :cl but man, problems :P Solvable, but man, to someone new.
<jackdaniel>
oh, then I must have misunderstood you
<_death>
elderK: you ignore what should not be ignored.. existing code is code yet unchanged ;)
<pjb>
elderK: https://pastebin.com/pYaf44MN of course, if you start this way, you will have to forward all the array operators, and define a print-object method on your carray to print as cl:array.
<elderK>
_death: Right. So, assuming forwarding is handled correctly, and the only change is "make sure the shadowing is done"
<elderK>
existing code shoudl work
<pjb>
elderK: it's as expensive as a function call.
<elderK>
For some reason, I would have expected (funcall 'symbol) to be more expensive than just (symbol ...)
<elderK>
I have a hard time like, having a feel for how expensive stuff is.
<pjb>
elderK: you cannot expect anything, it's all implementation dependent.
<elderK>
Other than the usual "Focus on the algorithms first."
<pjb>
elderK: see for example my last post on cll.
<elderK>
Link?
<elderK>
c.l.l is loaded with spam these days.
<pjb>
news://comp.lang.lisp
<elderK>
And btw, anyone recommend a better way to read c.l.l than google? It's a horrible interface, particularly if you have to zoom heavilyt as I do
<another-user>
indeed, with hash-table execution time is 0.02s now
<another-user>
thanks everyone!
robdog has quit [Ping timeout: 260 seconds]
<beach>
A beautiful illustration of the effect of micro-optimizations vs choosing the right data structure.
<pjb>
another-user: you can define easily a type of finite length list. (deftype list-of (length element-type) (cond ((plusp length) `(cons ,element-type (list-of ,(1- length) ,element-type))) ((zerop length) `null) (t (error "Invalid type specifier ~S" `(list-of ,length ,element-type))))) (list (typep '(1 2 3) '(list-of 3 integer)) (typep '(1 2 3) '(list-of 4 integer))) #| --> (t nil) |#
<another-user>
pjb: nice one, thank you!
<pjb>
another-user: you can also define a type of list of bounded number of elements (exercise for the reader).
<another-user>
beach: i totally agree :)
<pjb>
another-user: and you can also define a type of unbonded number of elements, but then you have to use satisfies, and switch to turing machines (ie. lisp code) to validate the list type.
<pjb>
another-user: and unfortunately, the way satisfies is specified, makes it delicate to implement correctly, if the predicate is not pre-defined.
patrixl has quit [Remote host closed the connection]
McParen has quit [Ping timeout: 244 seconds]
robdog has joined #lisp
FreeBirdLjj has joined #lisp
<pjb>
another-user: on the other hand, there's rarely a good reason to check or declare or do anything with the type of a list. If you need a list of numbers, then just put numbers in your list, and you'll have a list of numbers.
zch has joined #lisp
<another-user>
pjb: yeah, i was interested in it from educational standpoint and my actual bottleneck was resolved by proper data structure usage
<pjb>
another-user: now, if you use your list as: (reduce '+ list), say, then there would be absolutely no reason to declare list as a (list-of 3 integer) for example. Since (reduce '+ list) can work as well on (list-of 10 real) or (list-of 2 complex). Perhaps your program currently needs to work only with lists of 3 integers, but you never know what the requirements will be tomorrow!
<pjb>
another-user: perhaps you'll have to switch to complex or something else?
<pjb>
So why write down artificial restrictions?
<another-user>
pjb: i agree
<pjb>
another-user: yes, for educational standpoint, writing one or two programs in Modula-2 (or Modula-3 or Pascal or Oberon), can be a good idea. But better would be to implement a type inference engine for lisp programs, and integrate it into an IDE, so that at editing time, you could have annotation about the type of the expressions at the point (infered from the assumed bindings to the functions applied to the data).
<pjb>
or the functions in the subexpressions.
rozenglass has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 268 seconds]
zch has quit [Client Quit]
<pjb>
So you'd type (+ 2 (car x)) and you'd see in the minibuffer : x: (cons number t)|type-error (+ 2 (car x)): number|type-error
FreeBirdLjj has quit [Ping timeout: 268 seconds]
<pjb>
Note that type inference in CL should process also signaled conditions and other non-local exits! They're characterize the type of a function as the type of the results.
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<pjb>
ie. the type of (handler-case (+ 2 x) (error () 42)) and the type of (+ 2 x) are not the same!
<another-user>
pjb: do you know if this kind of functionality has been implemented for emacs already? because it sounds really good
<pjb>
Not yet. There have been some intents on live coding, where the code you type is run on some test data, so you can see the results as you type the code, but nothing comprehensive. slime only shows the lambda-list for the current operator.
gxt has quit [Ping timeout: 260 seconds]
gxt has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
another-user has quit [Remote host closed the connection]
bigfondue has quit [Ping timeout: 252 seconds]
igemnace has joined #lisp
Demosthenex has quit [Ping timeout: 245 seconds]
Demosthenex has joined #lisp
FreeBirdLjj has joined #lisp
nanoz has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
FreeBirdLjj has quit [Ping timeout: 250 seconds]
Inline has quit [Quit: Leaving]
robdog has quit [Ping timeout: 260 seconds]
bigfondue has joined #lisp
Inline has joined #lisp
Khisanth has quit [Ping timeout: 250 seconds]
orivej has joined #lisp
<shka_>
Kiczales talk is seriously good
dim has quit [Ping timeout: 250 seconds]
dim has joined #lisp
<Inline>
where ?
Khisanth has joined #lisp
robdog has joined #lisp
FreeBirdLjj has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
cage_ has quit [Remote host closed the connection]
FreeBirdLjj has quit [Ping timeout: 268 seconds]
trittweiler has quit [Quit: Leaving]
slyrus1 has quit [Ping timeout: 240 seconds]
lemoinem has joined #lisp
nika has joined #lisp
robdog has joined #lisp
<ebrasca>
Hi
rumbler31 has joined #lisp
<beach>
Hello ebrasca.
robdog has quit [Ping timeout: 268 seconds]
<dim>
hi
<dim>
hey beach! did you have my late message from yesterday?
<beach>
I saw it, yes, thank you.
<beach>
I am slowly reading up. But I don't think it will be adapted to what I plan to do.
kyby64 has joined #lisp
<dim>
again I have no idea, but it made me think about clasp/sicl/cleavir, more about in the angle of how to add CL to graalvm than something else but anyway
<beach>
Yes, I see.
<dim>
then I though that maybe GraalVM would be solving problems that are still on your list
<beach>
There are no more problems to solve on my list. :)
<beach>
I recently designed a garbage collector specifically tailored to my use case, and I doubt that what they suggest would have the same good properties.
<beach>
... just to mention an example.
FreeBirdLjj has joined #lisp
<beach>
Also, they claim duplication of functionality in most language implementations.
<beach>
Let me find the phrase...
<dim>
nice to hear that! go beach go! ;-)
<shka_>
never seen this graalvm thing
<shka_>
looks interesting
robdog has joined #lisp
<beach>
"Multiple tiers increase the implementation and maintenance cost for a VM: In addition to a language-specific optimizing compiler, a separate first-tier execution system must be implemented. Even though the complexity of an interpreter or a baseline compiler is lower than the complexity of an optimizing compiler, implementing them is far from trivial....
<beach>
But more importantly, the semantics of the language need to be implemented multiple times in different styles: For the first tier, language operations are usually implemented as templates of assembler code. For the second tier, language operations are implemented as graphs of language-specific compiler intermediate representation. And for the runtime system (code called from the interpreter or compiled code using runtime calls),
<beach>
language operations are implemented in C or C++."
<beach>
So the main problem they are solving does not exist in SICL.
<beach>
Second paragraph of the introduction.
Bronsa` has joined #lisp
nanoz has joined #lisp
slyrus1 has joined #lisp
marvin3 has joined #lisp
marvin2 has quit [Ping timeout: 250 seconds]
<shka_>
beside i think that clasp can by forced to run on this thing
<dim>
beach: oh I see, thanks for pointing that out, I wouldn't have seen it for myself
shka_ has quit [Read error: No route to host]
<beach>
Clasp does have exactly the problem they are citing.
<beach>
Oh, that talk by Kiczales is great!
<beach>
at 22:35 he says something that probably most people missed.
<dim>
we had a chat about graalvm with a friend who's mostly a Java developer, because he is using that now for single-binary deployment of his code, and I mentioned that I have a plan to someday have a look at making a pgloader.jar thanks to ABCL, in order to benefit from JDBC (and bypass OpenSSL too)
<beach>
Commenting on a phrase in a paper from 1980 that says that most major systems are still written in assembly language, he says: "And that's of course still true today, although the syntax is worse, and now it's an ANSI standard."
<beach>
He is talking about C. :)
<dim>
hehe
shka_ has joined #lisp
robdog has quit [Read error: Connection timed out]
rumbler31 has quit [Remote host closed the connection]
<jackdaniel>
C is so much more and so mach less than a assembler, depends how you look at it, so his claim (imo) is bogus
<jackdaniel>
s/a assembler/an assembler/
<beach>
Of course.
robdog has joined #lisp
eminhi_ has joined #lisp
<beach>
Boy, I really like this talk. How could I have missed it for so long.
elazul has joined #lisp
eminhi has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 268 seconds]
<ebrasca>
mmm Black Boxes
robdog has joined #lisp
nanoz has quit [Ping timeout: 246 seconds]
SaganMan has quit [Ping timeout: 250 seconds]
Demosthenex has quit [Ping timeout: 272 seconds]
drewes has joined #lisp
robdog has quit [Ping timeout: 260 seconds]
drewes has quit [Client Quit]
FreeBirdLjj has quit [Remote host closed the connection]
<pjb>
ebrasca: the MOP defines a set of classes and methods to manipulate classes and methods. So you use it by instanciating classes (or finding some object), and calling generic functions on them.
kyby64 has quit [Remote host closed the connection]
<pjb>
ebrasca: ie. basic programming.
<pjb>
well, basic meta programming.
robdog has joined #lisp
Demosthenex has quit [Ping timeout: 268 seconds]
Demosthenex has joined #lisp
jcowan has joined #lisp
dacoda has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
scymtym has quit [Ping timeout: 268 seconds]
nika has quit [Quit: Konversation terminated!]
phadthai has quit [Read error: Connection reset by peer]
nanoz has quit [Ping timeout: 245 seconds]
SaganMan has quit [Quit: WeeChat 1.6]
robdog has joined #lisp
elazul has quit [Quit: leaving]
slyrus1 has quit [Quit: slyrus1]
Demosthenex has quit [Ping timeout: 246 seconds]
robdog has quit [Ping timeout: 268 seconds]
Demosthenex has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
dale has joined #lisp
fikka has joined #lisp
milanj has joined #lisp
Demosthenex has quit [Ping timeout: 245 seconds]
<Fade>
beach: I'm looking in the log and I don't see a link to the talk you mentioned. do you have an URL?
<shka_>
Kiczales has outstanding charisma in this video
<shka_>
(as well as having good point)
exit70 has joined #lisp
pierpal has quit [Ping timeout: 268 seconds]
<shka_>
he must be awesome teacher
<shka_>
he reminds me a little bit Alan Kay
<shka_>
*of Alan Kay
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
rumbler31 has joined #lisp
Mr-Potter has quit [Ping timeout: 268 seconds]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
ggole has quit [Quit: ggole]
robdog has quit [Read error: Connection timed out]
robdog has joined #lisp
mejja has joined #lisp
orivej has joined #lisp
<jackdaniel>
someone asked yesterday, if Rainer Joswig drops on IRC - afair he did that a few times (his nick was lispm, like in other places)
equwal has joined #lisp
Essadon has joined #lisp
Essadon has quit [Max SendQ exceeded]
Essadon has joined #lisp
Jesin has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
robdog has quit [Ping timeout: 252 seconds]
dacoda has quit [Ping timeout: 264 seconds]
<fiddlerwoaroof>
I don't think he's stopped by in the last three years or so, though
milanj has joined #lisp
slyrus1 has joined #lisp
<equwal>
Morning
Mr-Potter has joined #lisp
pierpal has joined #lisp
robdog has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 246 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
fikka has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
eminhi has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
ebrasca has quit [Remote host closed the connection]
Demosthenex has quit [Ping timeout: 246 seconds]
kajo has joined #lisp
Demosthenex has joined #lisp
vlatkoB_ has quit [Remote host closed the connection]
Lycurgus has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 272 seconds]
angavrilov has quit [Ping timeout: 246 seconds]
angavrilov has joined #lisp
fikka has joined #lisp
<no-defun-allowed>
Anyone worked with oclcl before?
Demosthenex has quit [Ping timeout: 250 seconds]
Demosthenex has joined #lisp
dale has quit [Quit: dale]
sauvin has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 250 seconds]
dale has joined #lisp
Odin- has quit [Quit: Wireless just means the plug has already been pulled.]
Demosthenex has quit [Ping timeout: 268 seconds]
Demosthenex has joined #lisp
sauvin has joined #lisp
Kundry_Wag has joined #lisp
robdog has quit [Remote host closed the connection]
angavrilov has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
orivej has joined #lisp
scymtym has joined #lisp
emaczen has quit [Read error: Connection reset by peer]
emaczen has joined #lisp
elazul has joined #lisp
scymtym has quit [Ping timeout: 250 seconds]
emaczen has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
Demosthenex has quit [Ping timeout: 246 seconds]
rumbler31 has quit []
fikka has joined #lisp
Demosthenex has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
robdog has quit [Remote host closed the connection]
robdog has joined #lisp
scymtym has joined #lisp
shka_ has quit [Ping timeout: 268 seconds]
Demosthenex has quit [Ping timeout: 250 seconds]
Demosthenex has joined #lisp
elazul has quit [Quit: leaving]
random-nick has quit [Read error: Connection reset by peer]
Lycurgus has quit [Quit: Exeunt]
robdog_ has joined #lisp
dacoda has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
robdog_ has joined #lisp
moei has joined #lisp
<fe[nl]ix>
hey Fade
robdog_ has quit [Ping timeout: 268 seconds]
Jesin has quit [Quit: Leaving]
<LdBeth>
morning
Jesin has joined #lisp
<no-defun-allowed>
morning
fikka has quit [Ping timeout: 244 seconds]
robdog_ has joined #lisp
robdog__ has joined #lisp
debsan has joined #lisp
robdog_ has quit [Ping timeout: 252 seconds]
phadthai has joined #lisp
robdog__ has quit [Ping timeout: 268 seconds]
robdog_ has joined #lisp
fikka has joined #lisp
eminhi has quit [Quit: leaving]
shifty has joined #lisp
Demosthenex has quit [Ping timeout: 245 seconds]
makomo has joined #lisp
<makomo>
beach: re gregor's talk: hah, i have that exact timepoint where he disses C written down in my notes as "C burn" :-)
<makomo>
and yeah, his talk is awesome
<makomo>
i'm thinking of ordering AMOP as well
Demosthenex has joined #lisp
<makomo>
the advent of code puzzle that came up was a great example of choosing the right data structures. i ran into the same problem earlier today (doing the same puzzle) :-)
<makomo>
it was a nice reminder
makomo_ has joined #lisp
<dim>
can I use eql on fixnums (in a hash table key)? seems like it, but I want to make sure…