CrazyPython has quit [Read error: Connection reset by peer]
monolithic has quit [Remote host closed the connection]
CrazyPyt_ has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
<sm2n>
is there a way to dispatch on an optional parameter with a default argument in CLOS?
asarch has joined #lisp
<sm2n>
I have a bunch of methods that are constantly being called on the same special variable, it'd be nice if I could omit that parameter
rgherdt has joined #lisp
rgherdt has quit [Ping timeout: 260 seconds]
xTriixrx has joined #lisp
<xTriixrx>
Does anyone here have experience using the usocket and/or general tcp server/client experience with Common Lisp? I am attempting to create a persistent TCP connection for a server/client thread which will eventually be used for a distributed message bus application written in Common Lisp. All of the usocket / tcp cl documentation online is very
CrazyPyt_ has quit [Read error: Connection reset by peer]
luckless has quit [Ping timeout: 240 seconds]
srhm has quit [Quit: Konversation terminated!]
homonyms has joined #lisp
luckless has joined #lisp
mrchampion has quit [Read error: Connection reset by peer]
mrchampion has joined #lisp
xTriixrx has quit [Quit: Connection closed]
Codaraxis_ has joined #lisp
skami has quit [Remote host closed the connection]
Codaraxis has quit [Ping timeout: 240 seconds]
LispSporks has joined #lisp
prxq_ has joined #lisp
prxq has quit [Ping timeout: 252 seconds]
LispSporks has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
indathrone has left #lisp ["Leaving"]
Spawns_Carpeting has quit [Remote host closed the connection]
LispSporks has joined #lisp
Spawns_Carpeting has joined #lisp
johnjay has quit [Quit: WeeChat 2.3]
LispSporks has quit [Ping timeout: 245 seconds]
johnjay has joined #lisp
asarch_ has joined #lisp
asarch_ has quit [Client Quit]
Oladon has quit [Quit: Leaving.]
asarch has quit [Ping timeout: 260 seconds]
<beach>
Good morning everyone!
<beach>
contrapunctus: That's a cute one. I am not surprised. A lot of people here still talk about RAM.
<beach>
pjb: Why do we need to do that?
hypercube has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
mindCrime has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 246 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
Oladon has joined #lisp
luckless has quit [Ping timeout: 240 seconds]
luckless has joined #lisp
homonyms has quit [Remote host closed the connection]
homonyms has joined #lisp
hypercube has quit [Quit: WeeChat 3.1]
homonyms has quit [Remote host closed the connection]
kmeow has joined #lisp
slyrus has joined #lisp
karlosz has joined #lisp
skapata has quit [Remote host closed the connection]
andrei-n has joined #lisp
mindCrime has quit [Ping timeout: 252 seconds]
CrashTestDummy3 has joined #lisp
LispSporks has joined #lisp
nicktick has quit [Ping timeout: 268 seconds]
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
<jackdaniel>
uh oh, a nice lisp quote: "Common #Lisp has no philosophy. We are held together only by a shared disgust for all the alternatives." -- Scott Fahlman
<jackdaniel>
(stolen from twitter as one can tell from the hash)
<beach>
Date?
* jackdaniel
doesn't know
<beach>
:(
<beach>
I guess it is more recent than twitter at least.
<jackdaniel>
it may be also a fake quote; not trusting random quotes on the internet is a websurfing 101 these days ,)
<moon-child>
beach: I think the # was added by a twitter user quoting the original
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
orivej has joined #lisp
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
Codaraxis has joined #lisp
Codaraxis_ has quit [Ping timeout: 260 seconds]
mindCrime has joined #lisp
f4r5983 has joined #lisp
karlosz has quit [Quit: karlosz]
msk has quit [Ping timeout: 246 seconds]
shka_ has joined #lisp
karlosz has joined #lisp
masp has joined #lisp
kmeow has quit [Quit: Leaving]
gaqwas has quit [Ping timeout: 252 seconds]
yoonkn has joined #lisp
imode has quit [Ping timeout: 268 seconds]
xsperry has quit [Quit: quit]
jacks2 has joined #lisp
<contrapunctus>
pjb: a lot of the post and also your responses are beyond my knowledge level...but what can a CL programmer writing for Linux do about this today? 🤔
<jacks2>
hi. what parsing library is used this days?
xsperry has joined #lisp
<phoe>
|3b|: hmmm, I have not tested
<phoe>
made an issue, will check
cantstanya has quit [Remote host closed the connection]
ljavorsk has joined #lisp
cantstanya has joined #lisp
heisig has joined #lisp
heisig has quit [Quit: Leaving]
elderK has quit [Quit: Connection closed for inactivity]
Oladon has quit [Quit: Leaving.]
hiroaki has quit [Ping timeout: 260 seconds]
mindCrime has quit [Ping timeout: 240 seconds]
<beach>
jacks2: esrap, I think.
anticrisis has quit [Read error: Connection reset by peer]
pve has joined #lisp
epony has quit [Ping timeout: 240 seconds]
fourier has joined #lisp
hiroaki has joined #lisp
asarch has joined #lisp
OlCe has joined #lisp
maxwilliamson has joined #lisp
maxwilli- has quit [Ping timeout: 240 seconds]
<contrapunctus>
jacks2: I like esrap ^ a friend is partial to MaxPC
mrchampion has quit [Ping timeout: 252 seconds]
silasfox has joined #lisp
asarch has quit [Quit: Leaving]
bmansurov has quit [Quit: 👋]
<pjb>
beach: the objective would be to unify the view of memory. To avoid having to program explicit I/O. To use memory mapped files in Lisp. Of course, we could just use FFI to access the memory mapped file, (or if the implementation provides it, accessing the memory mapped file as a vector of octet), but we would then have to serialized and deserialize lisp objects onto those octets.
fourier has quit [Changing host]
fourier has joined #lisp
<pjb>
In C, they can access directly the memory mapped blocks (the only thing is to use offsets instead of pointers). In lisp, we have a different data model, so we need to obtain lisp objects from a memory mapped file. This means that some lisp objects are not in the main heap.
<pjb>
Also, they may be accessed by multiple processes at the same time.
<pjb>
But as I mentionned, it's not a trivial problem to solve.
bmansurov has joined #lisp
<beach>
pjb: But, Common Lisp already treats everything as primary memory. The virtual memory system takes care of the rest.
bmansurov is now known as Guest81166
<pjb>
But if we don't attempt to solve it one way or another then we will still have to distinguish lisp image memory from secondary memory and serialize/deserialize and doing I/O. Hence we won't be able to benefit from the optimizations of the kernel.
<pjb>
beach: that'd be true only if we didn't use files, and saved the lisp image instead.
<beach>
Oh, you are assuming a stupid OS like Unix and you want your Common Lisp system to use its stupid file system? That's different. I see.
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
<jacks2>
beach, contrapunctus thanks
<pjb>
Not especially. For one thing using memory mapped files goes in the right direction: we don't have to write explicit I/O, but we just work with (partial) process images.
<pjb>
beach: but the core of the difficulty would happen also with other OSes. For example, with EROS, which allowed to "mount" memory images thru capabilities from remote systems, we'd still have to solve the problem of unified resources such as symbols.
<pjb>
beach: When we have the "same" symbol in two different lisp images, if those two images are put in common, now we have to resolve the inconsistencies that may exist between the copies of this same symbol.
<phoe>
I guess we'd need to solve the problem of "unifying" two distinct memory images
<phoe>
which would be akin to interning everything internable from one into the other, e.g. symbols
<pjb>
beach: we of course intern the symbol itself and the packages, but its value, function and plist are in conflict.
<phoe>
but that's already getting similar to FASL loading
<pjb>
exactly.
<beach>
pjb: I am having a hard time thinking in those terms. To me, there would be a single Lisp image.
<pjb>
In the case of FASL this is solved by NOT saving those slots in the FASL, and by providing load-time-value and eval-when :load-toplevel :execute, to let the programmer perform the required mutations.
<pjb>
beach: even if conceptually you assert that there's a single lisp image (covering the whole Universe), you still have to deal with the fact that parts of this image are not accessible, and to deal with the synchronization when several processes access this unique universal lisp image.
<pjb>
beach: on the other hand, given those difficulties, perhaps this means that the blog article referenced earlier about memory mapping and I/O is actually wrong, and that there is indeed still a difference between core memory and secondary memory, despite the effort of unix to present one as the cache of the other.
<pjb>
beach: it's related to the problem of OO databases for lisp.
<beach>
I don't feel smart enough to solve problems related to running Lisp on "modern" operating systems, which is why I wrote the CLOSOS specification instead.
heisig has joined #lisp
prxq has joined #lisp
<pjb>
beach: actually, you may be fundamentaly right: most of the problem comes from the separate addressing space for the separate processes. If ther was a single lisp image for all lisp processes on a system, then we could just persist this lisp image, and there wouldn't be problems, at least in the scope of a single system. With 64-bit addresses, the lisp image could encompass all the local storage.
<beach>
That's the plan, yes.
aindilis has quit [Remote host closed the connection]
mindCrime has joined #lisp
nydel has quit [Ping timeout: 252 seconds]
aindilis has joined #lisp
<lukego>
splittist: hey I wonder what key/mouse bindings we want on CLIME images. I'm doing a first keymap now so that left-click can answer ACCEPT calls. But could be neat to pan/zoom on large images, open objects in the SLIME inspector, grab references for the REPL...
ryanbw has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
<lukego>
splittist: oh I see your PRs now! Sorry I was drowning in too many github notifications and missed 'em
<splittist>
lukego: Hmm. I'm about to send a PR with more stuff - basically finishing initial implementations of the medium-draw-foo* methods. Some things not quite right yet - text directionality and arcs of ellipses (which make my head hurt), but it's pretty (: (Still need to handle transformations and clipping, I think.)
<lukego>
keep 'em coming :) I'll merge liberally and try to quickly push fixes to whatever I break in the process
rdd has joined #lisp
perdent has joined #lisp
<perdent>
How would I convert these 40 16 bytes hex strings/plaintext to uint8_t raw format, without \n? https://bpa.st/BD2A
<phoe>
perdent: is that the whole file?
<perdent>
phoe: yes
<phoe>
so you want to read this file and you want to receive 40 vectors of (unsigned-byte 8)?
<perdent>
correct
<flip214>
perdent: how about reading the lines, and using IRONCLAD:HEX-STRING-TO-BYTE-ARRAY
<perdent>
without /n
<phoe>
perdent: lisp has no /n so you are lucky
<phoe>
but yes, what flip214 mentioned
<flip214>
perdent: are these MSB or LSB, BTW? you could also get a vector of INTEGERs...
<perdent>
can you show me the code how it would look?
<flip214>
is that a homework?
<perdent>
flip214: its C's unit8_t
<phoe>
perdent: we don't have uint8_t in CL, we have (unsigned-byte 8) which is equivalent
<perdent>
(16:46:58) candide: dave0: no output: s = "EBD2FBEEEA4F7A84"; a = "\353\322\373\356\352Oz\204"
<perdent>
I want it to have output similar to that
<lukego>
bounding boxes are an interesting one. I mean ideally Emacs would work this out from the SVG and we wouldn't have to spell out the viewBox bounding box for the whole drawing but I didn't see an obvious way to make it so
<jdz>
Something along the way choked on NUL character.
<lukego>
splittist: circle example is working but I'm getting an error on the first one due to some stream-position missing method, looking closer, maybe just a compilation issue
<splittist>
lukego: yay. Although it seems that despite the SVG spec referring to the content of text elements as 'character data', it actually needs to be xml-escaped.
<perdent>
pjb: awesome thanks, and how would you strip it so the is no newlines in the outut?
<perdent>
output*
<perdent>
so there*
<perdent>
pjb: and how would it look if the values were not infact hex but ascii/text charachters instead?
<splittist>
lukego: I have an idea. Let me check.
<pjb>
perdent: remove ~% from the format.
<pjb>
perdent: how about you start programming?
lotuseater has joined #lisp
mindCrime has quit [Ping timeout: 246 seconds]
adam4567 has quit [Read error: Connection reset by peer]
waleee-cl has quit [Quit: Connection closed for inactivity]
yoonkn has quit [Remote host closed the connection]
<pyc>
Is Logo programming language a dialect of Lisp?
karlosz has quit [Quit: karlosz]
<beach>
pyc: There is no agreed-upon definition of "Lisp", so the question can't be answered.
<beach>
pyc: Which is why #lisp is about Common Lisp which is quite well defined.
<pyc>
beach: so Lisp is a "feeling". a language *feels* like Lisp?
<beach>
pyc: It is worse than that. Many people who invent their own programming language for some reason desperately want it to be a dialect of Lisp, so they simply declare it so and then they come here to show it off.
<no-defun-allowed>
The definition I usually see is the same as what people who dislike Lisp say, that "it's anything with a lot of parentheses which looks like (f (g x))".
<phoe>
;; unless it's Dylan
<pyc>
no-defun-allowed: okay. Logo does not have parens. Logo has fixed number of arguments per command (called "word" in Logo), so very unlike Lisp then. Still I read on Wikipedia and other places that Logo is a dialect of Lisp. it didn't look like Lisp when I first learnt Logo.
<beach>
pyc: If I were you, I would stop trying to put labels like that on Logo or any other programming language. What would the purpose be?
<phoe>
it does seem kinda pointless to me, given the similarity to Plato's "man is a featherless biped" type of argument
<no-defun-allowed>
Right. Can you make a definition which excludes Smalltalk or JavaScript then (unless you feel that they should be included)? Though I agree with beach, mostly because I generally dislike Lisp apparently.
<beach>
pyc: Discussions related to "dialects of Lisp" are better conducted in ##lisp, which is not as strict about the kind of Lisp being talked about.
<no-defun-allowed>
As for Lisp with late binding and introspection, aye I'll take that, but that's mostly for the late binding and introspection.
ramHero has joined #lisp
<no-defun-allowed>
pyc: So what can I say, if you like Logo, that's all the justification you need. If you don't, again that's all the justification you need. No need to play language taxonomist.
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
Nilby has quit [Ping timeout: 250 seconds]
monolithic has joined #lisp
silasfox has joined #lisp
cchristiansen has quit [Remote host closed the connection]
<pjb>
pyc: Logo is not really a lisp. It can be implemented in lisp easily enough. But it has a specific program syntax, different from a syntax to write logo data.
<phoe>
the left/right and up/down are contrary to my intuition, but maybe that's just me
<phoe>
ohhh I think I get it now
<jackdaniel>
splittist: it does
luckless has joined #lisp
<jdz>
splittist: How come rectangle is drawn last, and does not overdraw everything?
<jdz>
I guess operations are pushed onto a list, and replayed in reverse?
<jdz>
In which case with-output-to-emacs could reorder the forms?
<splittist>
jdz: yeah. This probably isn't quite right. But I'll leave lukego to handle that (:
<splittist>
jackdaniel: thanks
<jackdaniel>
splittist: you may compare with tests in clim-examples (drawing tests -> text align)
<jackdaniel>
drawing tests have a headless run mode for pdf, postscript and raster image backends, so perhaps emacs could be added to that too
hendursa1 has quit [Ping timeout: 240 seconds]
hendursa1 has joined #lisp
Lord_of_Life has quit [Ping timeout: 265 seconds]
xsperry has quit [Remote host closed the connection]
<lukego>
splittist: oh nice test case!
xsperry has joined #lisp
zeroish has quit [Remote host closed the connection]
<lukego>
jdz: The way it works is that CLIM records all the drawing operations into a tree of "output records" and then at the end the Emacs backend traverses this to convert them into SVG elements. So in principle we have control over the order in which the elements are collected. I'm not sure if we're exercising that control properly yet though :-). Code: https://github.com/nuddyco/McCLIM/blob/clime/Backends/Emacs/emacs.lisp#L384
<lukego>
splittist: wow there is a lot of nice stuff in this file now :)
rodriga has joined #lisp
<jackdaniel>
that there is exactly the place where you reverse the order ,)
<jackdaniel>
a naive approach would be changing the last line to (reverse (remove nil shapes))
<jackdaniel>
(naive correct*)
<jackdaniel>
also: (with-bounding-rectangle* (x-min y-min x-max y-max) root …) seems to be less verbose than m-v-b
OlCe has quit [Ping timeout: 240 seconds]
<lukego>
anyone wanna make a pull request? :)
renzhi has joined #lisp
CrazyPython has quit []
ljavorsk has quit [Ping timeout: 265 seconds]
ramHero has joined #lisp
niflce has joined #lisp
Lord_of_Life has joined #lisp
OlCe has joined #lisp
troydm has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
pfdietz has joined #lisp
saganman has joined #lisp
saganman has quit [Changing host]
saganman has joined #lisp
homonyms has joined #lisp
<flip214>
Is there something like strace for CL? So that I get the tree of function calls with their arguments, timestamps, and runtime?
amb007 has joined #lisp
<lukego>
,clhs trace
<phoe>
this does sound like cl:trace but on steroids
<lukego>
i guess that's not the syntax :-) oh well, yes, it's called TRACE.
<lukego>
(oh right)
<lukego>
sorry yes forgot the steroids bit there
<flip214>
lukego: doesn't show timestamps
<phoe>
you'd need to trace all the functions, which might not be a good idea, and then also record timestamps
<phoe>
I assume you can achieve this by hacking your implementation's TRACE implementation
<flip214>
also, reconstructing the tree means reading backtraces all the time, destroying the performance
<phoe>
reconstructing? what do you mean?
<flip214>
I'd hoped there's something better
<phoe>
you want to get the trace as Lisp data or as printed output?
<flip214>
phoe: to see that FOO calls BAR I need to fetch the stack in BAR and relate back to the outer FOO frame -- and that for every call...
<flip214>
well, ultimately I need some human readable representation, of course...
<phoe>
do you? can't you encapsulate FOO so that you get some code that runs before and after calling it?
<flip214>
but intermediate would be some lisp structure
<phoe>
there's no stack reconstruction there I think, just dynamic rebinding and printing I guess
<flip214>
phoe: is :encapsulate T standard? I believe SBCL has it, though.
<flip214>
right.
contrapunctus has left #lisp ["Disconnected: closed"]
<flip214>
could try that, thanks
contrapunctus has joined #lisp
<phoe>
flip214: :encapsulate is not standard whatsoever
<phoe>
but I assume that SBCL has something like that
<phoe>
also, SBCL has a :report option to TRACE
<phoe>
oh wait - the proper option seems to be :print where you can print timestamps
<flip214>
phoe: not necessarily... perhaps I just want to collect data and report latency percentiles
<phoe>
there's no standard way to encapsulate anything
<flip214>
I'd have hoped for some TRIVIAL-FUNCTION-TREE-RUNTIMES library or similar ;)
wsinatra has joined #lisp
<phoe>
there will be one if you make it!
<pfdietz>
Trivial: adj. (1) The property of being a de facto standard library.
<easye>
Another example of what we do in the face of no ANSI revision: TRIVIAL-EVERYTHING
<phoe>
TRIVIAL-ANSI, d'oh
xkapastel has joined #lisp
frost-lab has quit [Quit: Connection closed]
wsinatra has quit [Read error: Connection timed out]
wsinatra has joined #lisp
notzmv has quit [Read error: Connection reset by peer]
ryanbw has joined #lisp
Inline has joined #lisp
nydel has joined #lisp
nicktick has joined #lisp
OlCe has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
Sheilong has joined #lisp
masp_ has joined #lisp
rpg has joined #lisp
masp has quit [Ping timeout: 265 seconds]
OlCe has joined #lisp
<rpg>
What's the right approach for multi-line string constants that are NOT format strings? Put tildes in to break them up and then wrap in format nil?
<beach>
rpg: That's what I do, and then I use tilde-newline with a @ modifier so that I can indent subsequent lines.
<rpg>
beach: Thanks! Kind of ugly to embed in an ASDF defsystem form. Tempting to extend ASDF's parser for description and long-description to accept the tilde-newline FORMAT operator.
<beach>
I see.
<rpg>
lukego: That gives you a multi-line string with hard line breaks in it, which is what I was trying to avoid.
aeth_ has joined #lisp
<lukego>
I wonder if CL-INTERPOL has something since it's already sexing up string literals
Josh_2 has joined #lisp
<lukego>
(nope)
aeth has quit [Ping timeout: 240 seconds]
aeth_ is now known as aeth
mrchampion has joined #lisp
yoonkn has quit [Remote host closed the connection]
<Josh_2>
Hi
orivej has joined #lisp
aeth has quit [Ping timeout: 252 seconds]
aeth has joined #lisp
<beach>
Hello Josh_2.
Jesin has quit [Ping timeout: 252 seconds]
pfdietz has quit [Quit: Connection closed]
amb007 has quit [Ping timeout: 260 seconds]
silasfox has quit [Ping timeout: 250 seconds]
kini has quit [Ping timeout: 245 seconds]
<lukego>
holy shoes I finally got ACCEPT working in CLIME i.e. you (accept 'string) and then click a string in an image and it gets returned to Lisp
<lukego>
it's coming together rather quickly - many hands make light work !
contrapunctus has left #lisp ["Disconnected: closed"]
* jackdaniel
cheers on lukego, however he is wondering why the same effect on emacs generates approximately PI-times more wow than natively in CL ;)
contrapunctus has joined #lisp
<lukego>
maybe partly "ha ha only serious" hack value and partly that many of us are living inside Emacs and anything we can do there might get 100x more usage than stuff outside
hjudt has quit [Quit: leaving]
<jackdaniel>
you are probably right
<lukego>
for example every time I figure up the McCLIM listener I think "that's awesome!" and then within a minute or two I kill it to get my "real" REPL back.
<jackdaniel>
perhaps we should call the listener slime-repl and play dumb when someone tries to close it ^_^
<jackdaniel>
(i.e make frame-exit a no-op)
<lukego>
credit here is to McCLIM anyway because it is doing all the real work, CLIME is just making it more accessible to emacs nerds.
<Josh_2>
Very impressive lukego
<beach>
rpg: Looks good to me.
cantstanya has quit [Remote host closed the connection]
<lukego>
jackdaniel: well it doesn't work. a minute in Drei is enough to drive me to distraction. Some people think of Emacs as a stop-gap hopelessly inferior Lisp machine, but I'm in the other camp that thinks Emacs is basically the most powerful program every made.
<jackdaniel>
input editing is one of wip branches on my local machine :)
<beach>
rpg: I am trying to teach ASDF to use my custom LOAD function during SICL bootstrapping, and I am reading the ASDF manual. But I can't figure out what I am missing. Is there a convenient time for me to ask you how to do this?
<lukego>
So I love stuff that's complementary to Emacs rather than in conflict
<jackdaniel>
but I doubt that it will be even close to emacs
<lukego>
input editing won't be as good as emacs
<lukego>
right
<rpg>
beach: You mean, say, by Zoom?
<beach>
rpg: No, here is fine, or in #sicl.
<rpg>
beach: You are trying to make your own LOAD-OP?
<beach>
Essentially, yes.
cantstanya has joined #lisp
hjudt has joined #lisp
* lukego
wonders whether to push the code now or test it while actually having more than one type of presentation...
varjag has quit [Quit: ERC (IRC client for Emacs 26.3)]
<rpg>
Here is fine, but if it would stomp on other discussions too much, I could hop over to #sicl. But will need a little time for me to finish up something. On the half hour?
<beach>
Sure, just let me know when you are available and where you want to be.
<lukego>
jackdaniel: btw it's pretty exciting in splittist's demo to start seeing existing CLIM code able to render into Emacs - and will have working ACCEPT. This could potentially create a two-way street where CLIM code written for the "Emacs world" and "CLIM native world" works on both sides and people can build on each others' stuff.
<jackdaniel>
sure, I'm watching the progress with excitement
<lukego>
for example if clim-listener presentations could render into Emacs, then Emacs users could make clim-listener extensions of their own, and that could get folded into the upstream native clim listenre
<lukego>
ok maybe obvious :) it's a bit of a revelation to me to truly see CLIM as a flexible set of user-interfacing protocols rather than a monolithic "lisp machine user interface"
<lukego>
I know that it's always been described as such but I've never used e.g. PDF backend etc before so I never experienced that.
<lukego>
(Maybe I'm also squeamish but it's also really comforting that CLIM is not running a whole bunch of threads and event loop machinery behind the scenes here i.e. it's all the usual threads belonging to SLIME and my application that are driving execution. knowing that lifts a weight from my shoulders.)
<jackdaniel>
that depends on the implementation strategy and mixins
<lukego>
anyway yada yada yada I am feeling happy about Emacs at the moment :)
<lukego>
yeah I don't know what's really happening in e.g. x11 mode but it seems a bit scary and opaque to me. I say that as someone who does not dare to use threads in my Lisp programs.
<beach>
jackdaniel: Don't worry, once we have the planned IDE, it will be irresistible for Common Lisp programming.
<jackdaniel>
I'm not worried, I was just making an observation
<beach>
Good. :)
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
niflce has quit [Ping timeout: 240 seconds]
homonyms has quit [Remote host closed the connection]
hypercube has joined #lisp
irc_user has joined #lisp
hjudt has joined #lisp
easye has quit [Remote host closed the connection]
srhm has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
rogersm has joined #lisp
amb007 has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
aartaka has quit [Ping timeout: 265 seconds]
long4mud has joined #lisp
amb007 has joined #lisp
imode has joined #lisp
Jesin has joined #lisp
aartaka has joined #lisp
mindCrime has joined #lisp
<_death>
phoe: oh, I misinterpreted your question.. the mutation is done on the genotype, i.e. an s-expression.. like (abs (and x y))
narimiran has quit [Ping timeout: 240 seconds]
notzmv has joined #lisp
ramHero has quit [Remote host closed the connection]
<phoe>
I see
<lukego>
beach, jackdaniel: it's actually really nice the way you guys have structured projects like sicl and mcclim in such a way that they can drive towards a grand ambition but also be modular enough to act as components of other people's less ambitions systems e.g. emacs hacks, existing lisp compilers, etc. kudos :)
<beach>
Thanks!
<beach>
We no longer have (never did?) the manpower to duplicate work for each client.
Lycurgus has joined #lisp
<jackdaniel>
mcclim was structured by previous caretakers (beach included); I only fix typos in the code and such
<jackdaniel>
thanks though!
<beach>
People here should know that what jackdaniel just said is a gross underestimation of his role in McCLIM development.
mindCrime has quit [Ping timeout: 240 seconds]
dtman34 has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
<beach>
In my opinion, it is largely thanks to jackdaniel that McCLIM has been transformed from a useful but incomplete hack with tons of bugs to a serious library. He didn't do all the transformations himself, of course, but he was the one who took on the maintenance after years of no activity on McCLIM.
CEnnis91 has quit [Quit: Connection closed for inactivity]
<jackdaniel>
thank you, these are very kind words
* jackdaniel
blushes
dtman34 has joined #lisp
<beach>
I don't follow #clim closely enough, so I am not going to attempt a list of all the contributors, but I know that scymtym has dont quite a lot of things. I am sure jackdaniel can tell us who the others are.
<beach>
And loke[m], and ...
<jackdaniel>
there is longi-sh authors list in the codebase; I'm too afraid that I'll forget about someone important while enumerating
<beach>
Yeah.
<jackdaniel>
from top of my head scymtym, loke, slyrus, nsahmad, john-a-carroll, pwerkowsky; but there are more
<loke[m]>
Many more. Isn't the list very long?
<jackdaniel>
(half of the mentioned names are people who contribute by insightful bug reports)
<jackdaniel>
as I said, many more. check out the .asd file
<jackdaniel>
(or the website)
* jackdaniel
puts back ecl hat and gets back to the type inferencer
nostoi has quit [Quit: Verlassend]
V1sor has quit [Ping timeout: 265 seconds]
troydm has joined #lisp
rpg is now known as rpg_away
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
aartaka_d has quit [Read error: Connection reset by peer]
<pjb>
rpg_away: ~ are format specifiers, so you will have to use #.(format nil …)
<pjb>
rpg_away: note: this is only a presentation. The string would be full flushed to the left (no prefix spaces on the lines). But the editor would align them to a rectangular box instead of the indented area, and would fill the left with a filler color or character to indicate it's not part of the source code. It could be the same face as the fringe, if it was distinct from the background.
wsinatra has quit [Quit: WeeChat 3.1]
narimiran has joined #lisp
<pjb>
rpg_away: this could even be implemented easily enough in emacs, when you type RET in a string literal, it would automatically indent with those ░ characters with an overlay or a compose-region or something… The source code wouldn't include them.
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
anticrisis has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
hiroaki has quit [Ping timeout: 260 seconds]
mindCrime has joined #lisp
CrazyPython has quit [Read error: Connection reset by peer]
OlCe has joined #lisp
kpoeck has joined #lisp
silasfox has joined #lisp
Nilby has joined #lisp
edvardo_ has joined #lisp
<albusp>
In zpb-ttf package, I see this usage: (defpackage #:zpb-ttf (:use #:cl) ...
<albusp>
why the #?
<lotuseater>
albusp: the #: is the reader macro for not interned symbols
<lotuseater>
like when you use GENSYM
gigetoo has joined #lisp
<albusp>
yes, but what's the effect/difference between :use :cl to :use #:cl ?
<albusp>
I thought reader will still use the keyword package for :cl, or does it still intern it in the current package when it encounters it? Is that why we do #:cl so that it is not interned?
<jackdaniel>
albusp: this is to inform the person who reads the code, that the symbols itself has no meaning - only the name in this context matters
<jackdaniel>
namely "CL"
<jackdaniel>
using :cl would work as well
mindCrime has quit [Ping timeout: 240 seconds]
<albusp>
ah, ok thanks for the answers! I further checked it on repl now, and see the difference:
<albusp>
(boundp :testme) --> T (which means it first creates the :testme symbol in the keyword package)
<albusp>
(boundp #:testme) --> enters debugger saying testme is unbound, so the reader doesn't intern the symbol in the keyword package
mindCrime has joined #lisp
<jackdaniel>
symbols in the keyword package are exceptional because their value is always their name
<jackdaniel>
s/their name/the symbol value is that symbol itself/
<Nilby>
#:cl is one step more in the quest to working after (delete-package :keyword)
<pjb>
albusp: #:foo is an uninterned symbol. But it's a symbol like any other. If you try to evaluate, CL will try to return its value slot. If that's not bound an error occurs.
<pjb>
Long before boundp is called.
<pjb>
albusp: in the case of the lexica LET testme, this doesn't bind the value slot of the symbol. With lexical let, the symbol is only used as a name to a lexical variable that is bound. Not the symbol itself.
slyrus has quit [Quit: Leaving]
<pjb>
But you can both bind the value slot of the symbol, and the lexical variable named by the symbol! Hence the results 42 and 33 in the example.
kenran has joined #lisp
OlCe has quit [Ping timeout: 252 seconds]
<pjb>
albusp: note that with defpackage, the reader know that the elements are string designators. The difference between :use cl, :use :cl, and :use #:cl are only in the interning and in what package the symbol is interned. :use cl interns a symbol named "CL" in the current package. :use :cl interns a symbol named "CL" in the package named "KEYWORD". :use #:cl doesn't intern any symbol, it just creates an uninterned symbol named "C
<pjb>
albusp: the difference being that the interned symbols are not garbage collected once the compilation is finished, since the packages are still refrenced in (list-all-packages). But the uninterned symbol (or the strings, when you :use "CL") can be garbag collected.
silasfox has quit [Ping timeout: 250 seconds]
<pjb>
albusp: the difference between (:use cl) (:export a b c) vs (:use :cl) (:export :a :b :c) is not with (:use cl) (:export a b c) now the current packages has a whole bunch of symbols interned in it: (cl a b c), and if uou try to use the package that you just defined, you will get name conflict, between the exported symbols and the interned symbols that have the same name, but are not the same!
OlCe has joined #lisp
<pjb>
albusp: with keywords, you would get name conflicts if you tried to use the package in the "KEYWORD" package, but nobody does that, so no problem.
<pjb>
albusp: the best is to use #:foo or "FOO", I prefer the later since that makes less memory to allocate and garbage collect at compilation time.
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
<albusp>
pjb: wow, I didn't expect to learn this much, good explanations :)
<albusp>
I use "FOO" approach as well, but both #:foo and "FOO" seem clean enough then.
<albusp>
pjb: and it took some musing to understand your (let.. example
narimiran has quit [Ping timeout: 240 seconds]
masp_ has quit [Quit: Konversation terminated!]
<pjb>
albusp: Now, you can have: (defun f () (declare (special var)) var) ; note no variable named var is defined. (let ((var 42)) #| lexical variable |# (list var (let ((var 33)) (declare (special var)) #| dynamic variable var |# (list var (f))) var)) #| --> (42 (33 33) 42) |#
<pjb>
albusp: so during the execution of the inner, dynamic let, the scope of the lexical variable var of the outer, lexical let, is shadowed, and the _dynamic_ variable can be accessed even outside of the lexical scope, in the function F.
jonatack has quit [Ping timeout: 240 seconds]
<pjb>
(let ((var 42)) #|lexical|# (setf (symbol-value 'var) 22) (list (list var (f)) (makunbound 'var) var)) #| --> ((42 22) var 42) |# here, we don't bind dynamically a dynamic variable var, but we directly set the symbol value, (it's where dynamic variable values are stored), so it can be read by F.
silasfox has joined #lisp
lando_ has joined #lisp
lando_ has left #lisp [#lisp]
irc_user has quit [Quit: Connection closed for inactivity]
edvardo_ has quit [Remote host closed the connection]
OlCe has quit [Ping timeout: 252 seconds]
silasfox has quit [Ping timeout: 245 seconds]
<phoe>
splittist: :D
<jcowan>
beach: What happens when you are running CLOSOS and so am I, and I want to reuse parts of your iaage?
<phoe>
sounds like FASLs
pfdietz has quit [Quit: Connection closed]
<jcowan>
FASLs are isomorphic to source files (or at any rate multiple files constituting a single compilation unit, whreas (frozen) Lisp images have it all.
<albusp>
pjb: :mind-blown:
<phoe>
jcowan: to put it another way - sounds like a need to serialize a part of the object tree of one image to a file, and intern it/merge it into the other image later
hjudt has quit [Ping timeout: 240 seconds]
<jcowan>
Just so, while making sure e.g. that symbols are properly merged
aartaka_d has quit [Ping timeout: 252 seconds]
mindCrime has quit [Ping timeout: 265 seconds]
<phoe>
yes
jonatack has joined #lisp
hjudt has joined #lisp
asu_shida has quit [Ping timeout: 240 seconds]
gaqwas has quit [Ping timeout: 252 seconds]
kenran has quit [Quit: leaving]
surabax has quit [Quit: Leaving]
<no-defun-allowed>
The Self people had a transporter for getting objects between images. A careful reading suggests the transporter framework is just a convenient way to create methods on MAKE-LOAD-FORM.
jprajzne has quit [Ping timeout: 240 seconds]
jprajzne has joined #lisp
hjudt has quit [Ping timeout: 246 seconds]
akoana has joined #lisp
pve has quit [Quit: leaving]
umashm has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
kpoeck has quit [Quit: Connection closed]
elderK has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
hjudt has joined #lisp
amb007 has joined #lisp
mindCrime has joined #lisp
wsinatra has joined #lisp
nicktick has quit [Ping timeout: 260 seconds]
aartaka has joined #lisp
Nilby has quit [Ping timeout: 250 seconds]
luckless has quit [Ping timeout: 240 seconds]
luckless has joined #lisp
kevingal has quit [Remote host closed the connection]
maxwilli- has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
maxwilliamson has quit [Ping timeout: 240 seconds]
CrazyPython has joined #lisp
White_Flame has joined #lisp
akoana has quit [Quit: leaving]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
terpri has quit [Remote host closed the connection]