cyberoctopi has quit [Remote host closed the connection]
cyberoctopi has joined #lisp
makomo has quit [Ping timeout: 258 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
rumbler3_ has quit [Remote host closed the connection]
karlosz has joined #lisp
defunkydrummer has joined #lisp
cyberoctopi has quit [Ping timeout: 245 seconds]
ludston has quit [Remote host closed the connection]
ludston has joined #lisp
defunkydrummer has quit [Quit: Yaaic - Yet another Android IRC client - http://www.yaaic.org]
libertyprime has joined #lisp
rumbler31 has joined #lisp
atgreen has quit [Ping timeout: 276 seconds]
Blukunfando has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
<jsatk>
Hi all. I'm new to Common Lisp. And I'm a vim user. I installed Quicklisp & Vlime (Slime-like plugin for vim). Whenever I start up my server via Vlime I get this strange error. http://i.jsatk.us/AH2bpp
rumbler31 has joined #lisp
<jsatk>
Does anyone happen to know what ☝️ is and how to fix it?
ebrasca has joined #lisp
cyberoctopi has joined #lisp
anewuser has joined #lisp
Aruseus has joined #lisp
cyberoctopi has quit [Ping timeout: 258 seconds]
equwal has joined #lisp
<Bike>
those are warnings, not errors. do they actually cause a problem?
<sjl>
That's "interesting". I use Vlime and don't get those warnings (well, I do get the emacs-inspect one, but that's fine). The warnings about undefined variables I wasn't seeing.
<p_l>
wouldn't it be only for first run?
<p_l>
also, TCP-based connection, so usocket being loaded
<sjl>
But I haven't updated my Quicklisp dist in a while. So I updated, and now I see those same errors.
<p_l>
first run of slime after update of either SBCL or SLIME always printed a bunch of warnings for me
rumbler3_ has joined #lisp
<sjl>
Looking at the commit history, there was this on Feb 26 which "fixed" something for SBCL, but actually causes those warnings
<sjl>
But the version in the latest quicklisp dist is 0.8.1, not 0.8.1.1, so I guess the latest dist just missed getting that extra fix
<sjl>
Anyway, you can just ignore those errors. They won't affect you unless you try to run usocket's unit tests
<sjl>
*benny hill theme intensifies*
rumbler31 has quit [Ping timeout: 245 seconds]
notzmv has quit [Ping timeout: 246 seconds]
rtypo has quit [Ping timeout: 250 seconds]
Blukunfando has quit [Ping timeout: 250 seconds]
dddddd has quit [Remote host closed the connection]
caltelt has quit [Ping timeout: 244 seconds]
aautcsh has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Bike has quit [Quit: Lost terminal]
notzmv has joined #lisp
<beach>
Good morning everyone!
Blukunfando has joined #lisp
dacoda has joined #lisp
dacoda has quit [Ping timeout: 276 seconds]
<equwal>
Good morning
<equwal>
Congrats on the SICL paper in ELS.
<beach>
Thanks.
<beach>
I found that writing papers for ELS takes 4 months per year. It is hard to concentrate on anything else for that time. First, figure out what to write about, then figure out how to write it. Then write it, fix it, submit it. Then modify according to the wishes of the referees. Then submit again. Then prepare the talk, make travel plans, buy tickets, reserve hotel rooms, travel.
<beach>
So I decided I have 8 months to think about design and coding, and I decided to work very hard to try to get an initial native version of SICL going before the end of that period.
<beach>
I have been kind of stymied with respect to changes in SICL and Cleavir because I now have a very important client (Clasp). So I finally decided to bite the bullet and "branch" Cleavir so that I can take care of some problems without disturbing the client(s). This decision turned out to be the right one.
<beach>
Because, since I made it, I have made much faster progress towards the goal.
<beach>
Probably much more than you wanted to know. Sorry.
<equwal>
No, just formulating my question
<equwal>
Yeah, I recognise the difficulty of it. I remember you said you though nobody had done anything like SICL before. How is it different from other bootstrapping papers like the ones from this page of Lisp In Small Pieces? spensertruex.com/static/LiSP-bootstrappers.pdf
<equwal>
I know you compiled with the object first, and Clasp (a very influential project) now uses your compiler!
Arcaelyx has quit [Ping timeout: 246 seconds]
Arcaelyx_ has joined #lisp
<equwal>
Is primarily that you used more modern stuff (since those are all pretty old papers)? Original or not, Clasp is a really big deal.
<beach>
For my bootstrapping talk, I figured out the main difficulty of building a Common Lisp system, compared to building ordinary "file-processing compilers", like a C++ compiler, for instance.
<beach>
The main difficulty is that a Common Lisp system does not contain just code to execute the way a C++ compiler does.
<beach>
It also contains complex data structures.
<beach>
Like a generic function contains a list of methods, a list of effective methods, etc.
<beach>
A symbol contains a name and a package. A package contains a list of exported symbols.
<beach>
So the difficulty with Common Lisp is HOW and WHEN those data structures are created.
<beach>
Systems written in C or C++ often build them at startup time, like ECL and Clasp.
<beach>
For Clasp, this is not so good because they have to create the discriminating function of more than 1000 generic functions at startup time and that takes many seconds.
<beach>
It is also possible to do something like Emacs does (or used to do, I haven't looked for some time), i.e. load up stuff and dump the current image as an executable.
arescorpio has joined #lisp
<equwal>
Do you think SICL can eventually solve Clasp's major performance issues?
<beach>
Image-based Common Lisp systems do that exclusively. They never start from source code. They modify an existing image and dump it.
gravicappa has joined #lisp
<beach>
equwal: Yes, I think so. Unless it turns out that LLVM is a major performance bottleneck as has been hinted in the past.
<equwal>
My understanding of Clasp is that it is pretty nonperformant (I have never compiled it, I can't on my machine) despite it's purpose of scientific computing.
<equwal>
Ooof fixing LLVM would be pretty tedius.
<beach>
I don't follow the comparison with other systems, but it is still not great I think.
<beach>
But we have a long way to go with optimizing Cleavir, so that part will eventually no longer be a problem.
<beach>
Though, as long as Clasp is written in C++ and they can't dump the image, the startup time is not going to be great.
<beach>
As I recall, Clasp now has several compilers and several interpreters, for various aspects of the system, in order to get it fast enough.
<beach>
And Xof talked about SBCL at ELS and said something similar for SBCL.
<beach>
I can't afford that for SICL. I want a single evaluator.
MichaelRaskin has quit [Ping timeout: 245 seconds]
<beach>
And that requirement is responsible for the complicated bootstrapping procedure.
<beach>
Time for a break. I'll be back in 30 minutes or so.
<equwal>
Thanks for answering my questions, I wrote your answers on my copy of your paper.
<equwal>
This is all very exciting.
sakalli has quit [Remote host closed the connection]
aru_ has joined #lisp
Aruseus has quit [Ping timeout: 258 seconds]
anewuser has quit [Ping timeout: 245 seconds]
_whitelogger has joined #lisp
<beach>
equwal: Thanks!
<beach>
p_l: That is what I am thinking too.
<beach>
p_l: And we currently have no decision procedure for determining WHETHER something should be inlined.
<p_l>
beach: also, I think it should be possible to generate discriminating functions and include them in "C++ image"
<beach>
It is entirely possible that the LLVM slowness is due to the fact that we submit HUGE functions to it.
<beach>
p_l: Bike has done some work on that as I recall. The limitations of C++ are very puzzling to me.
<p_l>
beach: it was definitely mentioned to me as an issue by one of the attendees I talked with, except for him it was making it too big to compile usable systems
<p_l>
beach: the "big lie" of C/C++ is that it's supposed to not be image oriented
cyberoctopi has joined #lisp
arescorpio has quit [Ping timeout: 268 seconds]
<p_l>
beach: in practice, for normal OS, you have an external "image builder" which makes the image from different files
<p_l>
so I see no reason why it couldn't reuse ECL approach, or even create object files that would get relinked with main executable at some point
<beach>
I believe you. Again, I am very puzzled.
aru_ has quit [Remote host closed the connection]
<beach>
I know it is possible in C to create a data structure in the executable. You just make top-level struct definitions and creations, linking them as appropriate.
<beach>
So I don't understand why this can not be done in Clasp.
<p_l>
I seem to recall you have used monotonic counters for class discrimination?
<beach>
There are hints that it has to do with the GC.
<beach>
Me? In SICL? Yes, but Clasp doesn't use SICL.
<p_l>
ah
<beach>
I don't know what Clasp is doing.
<p_l>
I wonder if there might simply be an unholy mess at the crossroads of LLVM codegen, C++ runtime, GC, and Clasp's compiler which makes otherwise simple task into an attempt at unmaking spaghetti
cyberoctopi has quit [Ping timeout: 244 seconds]
<beach>
I wouldn't attempt anything like that myself, because I would never be able to sort it out.
<beach>
But Clasp made some initial choices that are hard to back out of now.
<p_l>
I haven't been able to get flour out of spaghetti yet either :)
<beach>
Luckily, drmeister has much more time and energy than I do to deal with issues like that.
<beach>
Bike has been working on inlining, but it has taken a long time just to make the mechanism work correctly, so he hasn't had time to think about the WHEN aspect of it.
<beach>
But, yeah, for SICL, I will definitely not depend on external software that I have to track. Especially not software written in C++.
<drmeister>
Hello
<beach>
Hello drmeister.
rumbler31 has joined #lisp
<beach>
p_l: It has been proposed that I use LLVM (by several different people) and MPS (same), but I am not going to attempt that.
<p_l>
beach: an old idea of mine was to perhaps write a parser/writer for ELF objects and try to make SBCL use them as FASL format that is inherently memory-mappable
<beach>
p_l: Sure, why not.
<beach>
p_l: I decided kind of the opposite for SICL. We'll see how that works out.
<beach>
I decided to use a simple external form of the AST as the FASL format.
<beach>
I think it's the right decision, especially with respect to CLOSOS, because it would be nearly impossible to verify the safety of a FASL consisting of only executable code.
rumbler3_ has quit [Ping timeout: 245 seconds]
<p_l>
I have to admit I'm very interested in how CLOSOS evolves
<p_l>
kinda want to be proven wrong on certain ideas (because it might be more interesting to be proven wrong than right)
pankajgodbole has joined #lisp
gbiesiad has joined #lisp
john2x has quit [Ping timeout: 246 seconds]
<p_l>
I'd be probably going for something closer to IBM AS/400 design, where safety is guaranteed partially by hw
<equwal>
p_l: are you making a hardware device?
marusich has joined #lisp
<p_l>
equwal: if I were making a system right now? I'd go with POWER9-based design
<p_l>
the bits designed to support OS/400 are little documented but are there on all chips
<equwal>
oh CLOSOS is Strandh again, I follow.
<beach>
p_l: The only way to find out what won't work is to attempt it. At least for me. I am unable to think through a design completely without implementing it.
<p_l>
beach: it's also why I am very interested. Verification of hypotheses et al :)
varjag has joined #lisp
<beach>
I see, yes.
jfe has quit [Ping timeout: 246 seconds]
Inline has quit [Quit: Leaving]
john2x has joined #lisp
varjag has quit [Ping timeout: 250 seconds]
<beach>
p_l: With respect to Clasp, if it were up to me, I would have rewritten Cando in Common Lisp (including the libraries it uses) and just used an existing high-performance Common Lisp implementation like SBCL. It is several orders of magnitude simpler to implement an application than to create something as complex as a high-performance Common Lisp system.
<beach>
However, as I often remark, I am not good with strategic decisions like that, and I would have made the wrong one. The decision drmeister made has generated a huge amount of interest in Clasp by people unrelated to chemistry, simply because it can make Common Lisp and C++ work together. This decision has also attracted millions of dollars in grants, supported several graduate students and developers, etc. With me in charge, none of
<beach>
that would have happened.
Folkol has joined #lisp
jfe has joined #lisp
<loke`>
beach: If the development of Clasp had been a strategic decision, I'm not sure it would have been taken.
<beach>
I know I am bad with this stuff, because I often think about what I would have done in Richard Stallman's position. I would have chosen Lisp as the basis for the free system. And that would have been the wrong strategic decision, because then Unix programmers would not have been attracted, and we would not have the body of free software that we do today.
<loke`>
Many huge projects started because the original developer didn't know that it was impossible. :-)
<beach>
loke`: I see.
<loke`>
I mean, would Linus have started Linux if we knew what he was getting himself into?
<beach>
I think I have understood the suite of decisions that led to Clasp, though.
<beach>
loke`: Hard to tell indeed.
<loke`>
beach: True. But when the initial decisions were taken, I'm pretty sure drmeister didn't know the full scope of the work.
<loke`>
Would he have gone ahead if he had known?
<beach>
Now, that's definitely true. He couldn't foresee the issues.
dale has quit [Quit: dale]
<beach>
You'll have to ask him. He is here but Linus is not. :)
<loke`>
Yeah :-)
<loke`>
on a smaller scale... Would I have started making Climaxima if I had known that I would have to learn harfbuzz/freetype and implement a new font renderer, along with the copy&paste stuff, etc, etc? Unlikely. I would probably have targetted GTK+ or something instead.
<loke`>
But now it's done, and I think CLIM is better off for it.
<drmeister>
Obviously I didn't know the scope of the work - did anyone really?
<p_l>
as for Linus... he publicly stated that it was only his frustration with Minix and lack of availability of other useful OSes at acceptable prices (as a poor student with a 386)
<loke`>
p_l: right. and he also stated that he'd never expect it to be big and successful (“like Hurd” if I recall correctly)
<p_l>
loke`: and that if he had known about 386BSD, he would have joined on that project
<loke`>
p_l: right
<loke`>
good point
<beach>
loke`: Yes, and we are grateful that you did the McCLIM thing.
<p_l>
as for RMS... I wonder how much of that was pure luck
<loke`>
So many developments happening due to random things happening by individual people in the past.
<beach>
p_l: Not much. I know him fairly well.
<beach>
p_l: He is a very smart man. Way smarter than I can ever hope to be.
<loke`>
p_l: a lot of what he set out to do has come true. Of course, from his point of view it's not perfect (not enough GNU and too much BSD license)
<p_l>
beach: because from what I heard regarding some of his other strategic decisions...
<beach>
p_l: Oh, that's true too, yes.
<p_l>
loke`: well, from my PoV, a lot of people got... disillusioned with FSF?
<beach>
People are strange.
<beach>
They like to put words in people's mouths.
<p_l>
loke`: probably didn't help that some of the projects where RMS was more visible had to take a long road to devolve themselves of RMS (and got better for it), and with how people view RMS and FSF as pretty much the same
<p_l>
beach: ehh, I remember a rather... militant? side around GPL in late 1990s (might be localized effect though), and I do feel disillusioned especially when more than once I caught FSF on FUD campaign :(
<beach>
I see, so you are one of the disillusioned people. I think we had better not discuss that here. It is off topic, and I am a member of the FSF, even though I don't follow everything they do in detail.
john2x has quit [Ping timeout: 246 seconds]
<p_l>
true, it's veering off-topic
<beach>
So anyway, I hope we can fix Cleavir-related performance problems in Clasp...
<beach>
But it might be the case that there are others that can't be fixed by Cleavir.
<p_l>
I dunno if it got disseminated further, but I've seen a fancy CLIM-based visualizer for Cleavir?
<beach>
Yes, the AST visualizer and the HIR visualizer. I use them on a daily basis.
<beach>
They are not meant to win beauty contests. Just help me do my work. :)
jprajzne_ has joined #lisp
cyberoctopi has joined #lisp
<p_l>
it looked pretty fine to me! :)
oni-on-ion has quit [Disconnected by services]
<beach>
Thanks! :)
<beach>
To get back to Clasp, one of the main difficulties is that drmeister wanted Cleavir too early. My idea was to work pretty much alone on making the compiler generate good code. But Clasp has build-time and startup-time performance problems, which suggests the need to make the Cleavir compiler faster, as opposed to making it generate fast code.
oni-on-ion has joined #lisp
<beach>
So there is currently this "conflict" between working on the code generated by the compiler, and working on the way the compiler generates its code.
<beach>
As it turns out, the latter often suggests special-purpose code, which I am allergic to, because it means a bigger maintenance burden.
<beach>
This is partly the reason I "branched" Cleavir. It is better to let Bike and karlosz work on the existing version and for me to work on a branch where I am not concerned with the execution time of the compiler itself, at least not for now.
cyberoctopi has quit [Ping timeout: 250 seconds]
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dale has joined #lisp
vlatkoB has joined #lisp
lavaflow_ has quit [Read error: No route to host]
<beach>
The good part, of course, is that drmeister has made it possible for Bike to make a lot of improvements to Cleavir.
<drmeister>
et
lavaflow_ has joined #lisp
<drmeister>
Good night
varjag has joined #lisp
varjag has quit [Remote host closed the connection]
<beach>
'night drmeister.
JohnMS_WORK has joined #lisp
gbiesiad has quit [Quit: gbiesiad]
rumbler3_ has joined #lisp
Folkol has joined #lisp
rumbler31 has quit [Ping timeout: 255 seconds]
Lycurgus has joined #lisp
rumbler31 has joined #lisp
deng_cn1 has joined #lisp
rumbler3_ has quit [Ping timeout: 258 seconds]
deng_cn has quit [Ping timeout: 255 seconds]
deng_cn1 is now known as deng_cn
dale has quit [Quit: dale]
jfe has quit [Ping timeout: 250 seconds]
catchme has joined #lisp
Xach has quit [Ping timeout: 250 seconds]
Xach has joined #lisp
marusich has quit [Remote host closed the connection]
rumbler3_ has joined #lisp
rumbler31 has quit [Ping timeout: 250 seconds]
cyberoctopi has joined #lisp
ltriant has quit [Quit: leaving]
varjag has joined #lisp
nadare has joined #lisp
Arcaelyx_ has quit [Max SendQ exceeded]
schweers has joined #lisp
makomo has joined #lisp
<phoe>
good morning~
puchacz has quit [Quit: Konversation terminated!]
nadare has quit [Quit: Leaving]
arduo has quit [Ping timeout: 258 seconds]
<oni-on-ion>
hello phoe
Arcaelyx has joined #lisp
pierpal has joined #lisp
slac-in-the-box has joined #lisp
pierpal has quit [Ping timeout: 245 seconds]
asarch has joined #lisp
scymtym has joined #lisp
<asarch>
What is the opposite of vector-push-extend?
hvxgr has quit [Ping timeout: 244 seconds]
Lord_of_Life has quit [Ping timeout: 250 seconds]
Lord_of_Life has joined #lisp
<asarch>
vector-pop?
<makomo>
morning
<phoe>
asarch: there's no vector-pop-contract or anything
<phoe>
or rather, no vector-pop variant that reallocates
Arcaelyx has quit [Ping timeout: 276 seconds]
<asarch>
How would you pop?
<phoe>
huh? what do you mean?
<phoe>
the opposite of vector-push is vector-pop
<phoe>
there is no direct opposite of vector-push-extend
<phoe>
vector-pop will work well, but it will not reallocate the vector if the fill pointer is small compared to the vector length
<asarch>
I mean, if I vector-push-extend, how would I pop the value? Can I use vector-pop?
hvxgr has joined #lisp
p9fn has joined #lisp
<beach>
asarch: Do you have a copy of the Common Lisp HyperSpec?
<asarch>
"4While frequently used together, the :fill-pointer and :adjustable arguments are independent--you can make an adjustable array without a fill pointer. However, you can use VECTOR-PUSH and VECTOR-POP only with vectors that have a fill pointer and VECTOR-PUSH-EXTEND only with vectors that have a fill pointer and are adjustable. You can also use the function ADJUST-ARRAY to modify adjustable arrays in a variety of ways beyond just extending the length of a
<heisig>
flip214: burgled-batteries is about using Python code from Lisp (a horrible thought!). What I want to achieve with cl4py is that one can use Lisp code from Python.
lumm_ has joined #lisp
<flip214>
well, why not provide them an interface "load python file" in climaxima instead? Or have a text REPL for them?
<flip214>
heisig: ^^
lumm has quit [Ping timeout: 264 seconds]
lumm_ is now known as lumm
<selwyn>
given the intention that python programmers should be able to play around with code written in lisp, i suspect that the best approach is to have lisp available from the (c)python REPL, if only to make it more attractive at first sight
<selwyn>
(as opposed to a FFI approach, or having a python implementation written in Common Lisp)
<heisig>
Yes, what selwyn says.
dddddd has joined #lisp
<selwyn>
this question does not have a cut and dried answer, since it depends on reasoning about other people's prejudices concerning choosing different software libraries
<schweers>
reasoning about prejudices ...
<schweers>
sounds like a difficult task
<selwyn>
one thing i do notice: most enthusiastic python programmers would not like to program in something other than CPython as that implementation contains the bulk of the libraries that make scientific computation feasible (iiuc)
<flip214>
still, I would see it as a kind of responsibility to gently nudge them to saner programming languages ... ;)
<selwyn>
i have not used burgled batteries, but i again suspect that in order to use it practically, one would need to make it aware of which of the various python binaries and environments it should use on a given system.. this seems like a lot of work
<selwyn>
flip214: well, this is one of my hopes from cl4py. unfortunately, it did not arouse immediate interest from some pythonistas i know
<selwyn>
they said that there's no point given the range of things they can do with python. it's understandable - most people will not experiment with new things if they are happy with what they have. it's a different matter if some new library, such as a 'python-maxima' were to be presented
Bike has joined #lisp
nicball has joined #lisp
<heisig>
selwyn: That is good to know. One thing that might interest pythonistas already is having access to cl:compile (and cl:disassemble).
Lycurgus has quit [Quit: Exeunt]
igemnace has quit [Ping timeout: 245 seconds]
<selwyn>
hopefully
<selwyn>
i have noticed some frustration at the reality of having to switch over to C to write performant code for python
<selwyn>
heisig: anyway, i ask since i am thinking of using maxima for some symbolic manipulation of n-dimensional tensors and matrices
<loke`>
re
nicball has quit [Ping timeout: 245 seconds]
<heisig>
selwyn: I haven't used maxima for tensor manipulation yet. But there seem to be some modules for it.
<loke`>
heisig: There is more than one, in fact :-)
<loke`>
itensor and ctensor, if I remember correctly.
<heisig>
loke`: And atensor.
<loke`>
yeah
<loke`>
I've never used them.
<loke`>
but they supposedly work :-)
<guicho>
Hi all, last week I presented my numpy-clone in common lisp in Shibuya.lisp meetup. The talk was in Japanese but here is the youtube link to the recording which starts right at the beginning of the demo on the REPL, which you could understand. https://youtu.be/dWfR25EZNjs?t=6259
<selwyn>
thank you guicho
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<guicho>
(I recommend x2 speed)
<selwyn>
very nice. i do miss negative array indexing
<guicho>
Also notice that the array element type of the result array is computed precisely.
igemnace has joined #lisp
<selwyn>
yes
libertyprime has quit [Ping timeout: 246 seconds]
<flip214>
why not enter mostly-python-syntax in a text field in clmaxima, convert that to CL (shown in a second field) and then run that?
lucasb has joined #lisp
<heisig>
guicho: How do you compute the array element type of the results?
<loke`>
flip214: What is the problem that actually needs to be solveed here?
<loke`>
Perhaps I'm too stuck in the Maxima ecosystem
<flip214>
loke`: getting more people to use CL
<loke`>
flip214: Maxima already has Lisp integration if you want it (using :Lisp).
<loke`>
flip214: Also, Climaxima integrates the CLIM-Listener, so you get a full REPL
<loke`>
again, only if you want it.
<guicho>
heisig: I basically reimplemented a specialized version of type inference mechanism. Currently every inference happens in the runtime, but they will be shifted to the compile time in the future.
<flip214>
loke`: my propaganda here is not about getting lisp people to use CL ;)
<guicho>
heisig: specialized because it needs to account for the type upgrading in the common lisp array. Ratios are all converted to single-floats. Bignums are truncated to fixnums, and if overflow happens it signals errors. (COMPLEX FIXNUM) does not exist because common lisp does not allow a complex with imagpart 0.
<guicho>
(but it allows a complex with imagpart 0.0, which is funny)
cosimone has joined #lisp
LiamH has joined #lisp
<flip214>
guicho: I just had a COMPLEX BIT for #c(1 1) in SBCL ;)
nicball has joined #lisp
saravia has joined #lisp
<heisig>
guicho: Is the source code available? That sounds very interesting and useful.
<guicho>
flip214: but you cannot make a specialized array for (COMPLEX BIT), SBCL does not have it
<guicho>
heisig: Still struggling to publish it. I have some backer in my company, and hoping it helps. arademaker and fsmunos
<flip214>
(type-of (aref * 1))
<flip214>
(COMPLEX BIT)
<guicho>
flip214: check (array-element-type *)
<guicho>
IT is not a specialized array, you will get T
ensat1 has joined #lisp
Folkol has joined #lisp
<pfdietz>
(upgraded-array-element-type '(complex bit)) ==> T
<flip214>
oh, yes. hrmpf.
<pfdietz>
You CAN make arrays of (unsigned-byte 2) though.
nicball has quit [Ping timeout: 258 seconds]
<heisig>
pfdietz: Which is a blessing for working with DNA sequences.
vms14 has joined #lisp
nicball has joined #lisp
<guicho>
heisig: since I implemented the inference part, you can focus on the distributed part in PetaLisp with the limited type subset you currently have
<guicho>
heisig: I will handle the high-level API too
corvidzz has joined #lisp
<guicho>
heisig: the distributed computation part and the lazy compilation part are your skill set and are more important for your your research question.
nicball has quit [Ping timeout: 268 seconds]
<heisig>
guicho: That is very kind. Thank you!
aautcsh has joined #lisp
<heisig>
guicho: One more remark - I had yet another idea for type inference over the last few days.
Oladon has quit [Ping timeout: 268 seconds]
<heisig>
guicho: Instead of working with type specifiers, one could work with integers that store a bitvector representation of each type as in Baker's subtypep paper.
<jackdaniel>
ecl has that
nicball has joined #lisp
<heisig>
jackdaniel: Oh, cool! I will have a look.
<jackdaniel>
if you have questions let me ask. basically its all in file src/lsp/predlib.lsp
rwlisp has joined #lisp
nicball has quit [Ping timeout: 244 seconds]
rwlisp has left #lisp [#lisp]
keep_learning has quit [Remote host closed the connection]
nicball has joined #lisp
nicball has quit [Remote host closed the connection]
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Folkol has joined #lisp
Folkol has quit [Client Quit]
Folkol has joined #lisp
lumm has quit [Remote host closed the connection]
lumm has joined #lisp
Folkol has quit [Client Quit]
nicball has joined #lisp
Folkol has joined #lisp
lumm has quit [Remote host closed the connection]
sjl_ has joined #lisp
lumm has joined #lisp
brundleticks has joined #lisp
reverse_light has joined #lisp
guicho has quit [Remote host closed the connection]
mapcar has quit [Remote host closed the connection]
Arcaelyx has joined #lisp
Inline has joined #lisp
nicball has quit [Ping timeout: 246 seconds]
FreeBirdLjj has joined #lisp
elderK has joined #lisp
Josh_2 has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
lumm has quit [Quit: lumm]
t58 has joined #lisp
lumm has joined #lisp
cyberoctopi has quit [Ping timeout: 276 seconds]
hhdave has joined #lisp
nicball has joined #lisp
nicball has quit [Remote host closed the connection]
nicball has joined #lisp
mindCrime has joined #lisp
dale_ has joined #lisp
ring has joined #lisp
dale_ is now known as dale
nicball has quit [Remote host closed the connection]
pfdietz has quit [Ping timeout: 256 seconds]
pfdietz has joined #lisp
ring has quit [Ping timeout: 258 seconds]
longshi has quit [Ping timeout: 246 seconds]
anewuser has joined #lisp
ring has joined #lisp
Tristam has quit [Ping timeout: 244 seconds]
fade has joined #lisp
fade is now known as Fade
ring has quit [Ping timeout: 258 seconds]
<jsatk>
Thanks for the kind replies and investigation sjl & p_l. (I'm actually using sjl's "A Road to Common Lisp" article to learn)
<jsatk>
My computer went to sleep and lost connection so I may have lost some chat history. Was their ever a resolution?
<jsatk>
And as far as I can tell it is not causing me any issues.
<jsatk>
I'm new and learning so I assume all warnings and errors are my fault at this stage.
<jsatk>
Glad to see it's not.
<p_l>
jsatk: yeah, just run it as normal - some warnings are expected, because some implementations are bit more strict about what they see as "code smells" and sometimes you get a warning on "hey, I couldn't figure how to optimize that part, sorry"
<p_l>
jsatk: I have personally used compiler warnings about unsuccessful optimization as guide when optimizing code :)
kdas_ has joined #lisp
<jsatk>
$ sbcl --load ~/.vim/pack/minpac/start/vlime/lisp/start-vlime.lisp 👈 This is all I'm running and it produces the aforementioned errors.
<jsatk>
And thanks p_l.
<selwyn>
p_l: sometimes i get remarks from SBCL about the 'cost' of various operations. does this usually indicate that the 'code smells?' or is it not possible to conclude anything without investigating more
cosimone has quit [Quit: WeeChat 2.3]
kushal has quit [Remote host closed the connection]
Folkol has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<vms14>
depends on whether you have a better choice
ring has joined #lisp
<jsatk>
"it depends" is the answer to most programming questions.
longshi has joined #lisp
gbiesiad has joined #lisp
ring has quit [Ping timeout: 245 seconds]
<sjl_>
jsatk: yeah this is just a usocket problem that is already fixed, but the fix unfortunately just missed the cutoff for the latest quicklisp dist
<vms14>
jsatk: xD
<vms14>
everything are ifs after all
<vms14>
is*
<vms14>
my english sucks like my code
* vms14
cries
ring has joined #lisp
kajo has quit [Ping timeout: 276 seconds]
<jsatk>
sjl_: excellent. Will ignore. Thank yoU!
Nilby has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
FreeBirdLjj has quit [Remote host closed the connection]
<pjb>
jsatk: #lisp is logged; type /topic for urls.
ring has quit [Ping timeout: 246 seconds]
ring has joined #lisp
cosimone has joined #lisp
nowhereman has joined #lisp
ring has quit [Ping timeout: 250 seconds]
<fivo>
Does anybody know if there is a function in asdf that returns all the systems defined in a directory and its subdirecotries?
<Xach>
fivo: no
<Xach>
fivo: there is no function like that, but there are ways you could write it yourself
X-Scale has quit [Ping timeout: 246 seconds]
<jsatk>
I'm doing the Vlime tutorial and I'm like grinning ear to ear. It boggles my mind that this old-as-hell language has such a nice and mature way to work with it (that doesn't require an IDE). My day-to-day work is modern web stuff (React, Node, Python, etc). Why don't those have tools this mature? 😢
<jsatk>
pjb: thank you.
Arcaelyx has quit [Ping timeout: 276 seconds]
ring has joined #lisp
ring has quit [Remote host closed the connection]
v88m has joined #lisp
cage_ has joined #lisp
ring has joined #lisp
<White_Flame>
selwyn: those are just "notes", not warnings or anything. It's just telling you that there are still runtime checks & generic handler calls being made, in situations where it does have extra optimization steps that it can't there due to type uncertainty
<White_Flame>
*can't use there
fivo has quit [Quit: WeeChat 1.9.1]
akovalenko has joined #lisp
scymtym has quit [Ping timeout: 268 seconds]
rippa has joined #lisp
nanoz has joined #lisp
ring has quit [Ping timeout: 246 seconds]
kdas_ is now known as kushal
X-Scale has joined #lisp
Jesin has quit [Quit: Leaving]
ring has joined #lisp
kajo has joined #lisp
hhdave has quit [Ping timeout: 245 seconds]
slac-in-the-box has quit [Ping timeout: 245 seconds]
vms14 has quit [Quit: WeeChat 2.3]
ring has quit [Ping timeout: 250 seconds]
aautcsh has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
gbiesiad has quit [Quit: gbiesiad]
gbiesiad has joined #lisp
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
cosimone has quit [Quit: WeeChat 2.3]
gbiesiad has quit [Quit: gbiesiad]
nirved has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
nirved_ has quit [Ping timeout: 250 seconds]
karlosz has joined #lisp
rumbler31 has joined #lisp
rumbler3_ has joined #lisp
<selwyn>
thank you White_Flame
<White_Flame>
and I believe those notes only appear when you set SPEED to >1
Kundry_Wag has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 244 seconds]
Kundry_Wag has joined #lisp
Xizor has joined #lisp
Kundry_Wag has quit [Ping timeout: 255 seconds]
selwyn has quit [Remote host closed the connection]
warweasle is now known as warweasle_afk
anewuser has quit [Ping timeout: 246 seconds]
stacksmith has quit [Remote host closed the connection]
aindilis has quit [Ping timeout: 276 seconds]
Jesin has joined #lisp
karlosz has quit [Quit: karlosz]
nowhereman has quit [Ping timeout: 250 seconds]
rumbler31 has joined #lisp
rumbler3_ has quit [Ping timeout: 268 seconds]
scymtym has joined #lisp
aautcsh has joined #lisp
cyberoctopi has joined #lisp
cosimone has joined #lisp
nanoz has quit [Ping timeout: 246 seconds]
sauvin has quit [Read error: Connection reset by peer]
warweasle_afk is now known as warweasle
rumbler3_ has joined #lisp
rumbler31 has quit [Ping timeout: 245 seconds]
kdas_ has joined #lisp
aindilis has joined #lisp
kushal has quit [Ping timeout: 256 seconds]
pankajgodbole has quit [Ping timeout: 258 seconds]
kdas_ is now known as kushal
ebrasca has quit [Remote host closed the connection]
warweasle has quit [Quit: later]
cosimone1 has joined #lisp
selwyn has joined #lisp
cosimone1 has quit [Client Quit]
cosimone has quit [Quit: WeeChat 2.3]
varjag has joined #lisp
Jesin has quit [Quit: Leaving]
orivej has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
nowhereman has joined #lisp
Jesin has joined #lisp
vlatkoB has quit [Remote host closed the connection]
atgreen has quit [Ping timeout: 246 seconds]
gravicappa has quit [Ping timeout: 246 seconds]
cosimone has joined #lisp
cosimone has quit [Client Quit]
cosimone has joined #lisp
Lord_of_Life has quit [Ping timeout: 255 seconds]
Lord_of_Life has joined #lisp
Arcaelyx has joined #lisp
jprajzne_ has quit [Quit: jprajzne_]
cage_ has quit [Remote host closed the connection]
lavaflow_ has quit [Read error: Connection reset by peer]
<dim>
can I rely on (probe-file (make-pathname :defaults "/Users/dim/dev/temp/pgloader-issues/926/DNORDOC.DBF" :type "dbt")) #P"/Users/dim/dev/temp/pgloader-issues/926/DNORDOC.DBT" being portable?
<dim>
notice how the pathname type has been rewritten in all-caps
nowhereman has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
<pjb>
dim: Use :case :common or :case :local with :case :local, it will be upcased depending on the file system (actually the implementations do it randomly).
<katco>
is there a standard way of interspersing two lists together, e.g. `(intersperse '(1 2 3) '(a b c))` => `(list 1 a 2 b 3 c)`?
<pjb>
no implementation check to see what file system a given component will be indexed in.
<pjb>
(mapcan (function list) '(1 2 3) '(a b c)) #| --> (1 a 2 b 3 c) |#
<pjb>
OOps, sorry:
<pjb>
(cons (mapcan (function list) '(1 2 3) '(a b c)) #| --> (1 a 2 b 3 c) |#
<dim>
I read that “truename may be used to account for any filename translations performed by the file system.”
<pjb>
(cons 'list (mapcan (function list) '(1 2 3) '(a b c))) #| --> (list 1 a 2 b 3 c) |#
<pjb>
dim: not truename, but make-pathname.
<katco>
pjb: perfect! i thought there was something clever with `oddp` or something, but i like this much better :)
<pjb>
If you use :case :common then the case should not be changed (and since it should be case insensitve, I'd expect it to be upcased, but implementations can do whatever they want with physical pathnames (and some do it with logical pathname, which is not conforming).
<pjb>
).
<pjb>
katco: this will still walk the resulting list twice. (cons 'list (loop :for x :in '(1 2 3) :for y :in '(a b c) :collect x :collect y)) #| --> (list 1 a 2 b 3 c) |# walks the result only once.
<dim>
pjb: if I just use make-pathname, the pathname type is down cased as I enter it in my code, if I then use truename or probe-file on the resulting pathname, then the case is adjusted to the one of the file I have on-disk
<katco>
in my case i'm looking for clarity over performance. i didn't want to get into a `loop`
<pjb>
katco: ok.
<dim>
I like that behavior as I can hard-code lower case pathname type and then let the implementation figure it out, it seems, but I would like to know if I'm just lucky here...
<katco>
what i'm actually trying to do is build a list of arguments interspersed with commas
<dim>
it might be that my local file system is case independant too?
<dim>
a quick test shows that it's case dependent, I can create two files named a and A
<pjb>
dim: well, since you have a physical pathname here, first make-pathname makes in an implementation dependent way. Then it's used to find a file, which may involve symbolic links, then truename rebuilds a path using the file system. So if you have a case insensitive file system, you may get case transformations in both functions.
<katco>
e.g. `(intersperse "," '(a b c))` => `(list 'a "," 'b "," 'c)`
<dim>
I don't feel like what I see is a general case, rather something specific to using CL on a Macos file syste
lavaflow_ has quit [Read error: Connection reset by peer]
eschatologist has quit [Ping timeout: 264 seconds]
lavaflow_ has joined #lisp
eschatologist has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
jmercouris has quit [Remote host closed the connection]
atgreen has joined #lisp
jprajzne_ has joined #lisp
altgray has joined #lisp
<sjl_>
katco: quickutil has interleave and riffle that you could use/copy
<katco>
sjl_: ah cool. hey btw :)
<sjl_>
hi :)
<katco>
finally got the irc bridge on matrix working properly, so now i can chat ;p
<sjl_>
Oh nice.
edgar-rft is now known as world
world is now known as edgar-rft
oni-on-ion has joined #lisp
altgray has quit [Remote host closed the connection]
mindCrime has quit [Ping timeout: 258 seconds]
cosimone has quit [Quit: WeeChat 2.3]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
saravia has quit [Remote host closed the connection]
LiamH has quit [Quit: Leaving.]
<Josh_2>
o rip
<Bike>
just have a script that loads everything and then dies, and load it from your implementation running in the terminal.
<Bike>
or use one of the tools that do that. i don't know about them.
<Josh_2>
alrighty
<Josh_2>
I'll try that
<Josh_2>
Okay that worked thanks Bike
<Bike>
glad to help
rumbler3_ has quit [Read error: Connection reset by peer]
rtypo has joined #lisp
rumbler31 has joined #lisp
zotan has quit [Ping timeout: 250 seconds]
zotan has joined #lisp
Bike has quit []
jprajzne_ has quit [Ping timeout: 244 seconds]
<Josh_2>
Welll saving the image works, but the program doesn't work as a standalone program :(
<oni-on-ion>
'the program does not work as a standalone program' ... so is it a program at all?
caltelt has joined #lisp
<Josh_2>
It's a program that runs, however it does not behave the same way as it does in Sly
<Josh_2>
I have a function that I use to load up my system which is how I start it up in sly I don't have to do anything other than change my package and it'll function normally
karlosz has joined #lisp
<Josh_2>
however I load the system save the image and then it doesn't function the same Q_Q, seems the UDP connections aren't working
Oddity has quit [Ping timeout: 252 seconds]
rumbler3_ has joined #lisp
<Josh_2>
well idk
<oni-on-ion>
hmm. i think there are special ways to handle file system handles and sockets and such
<Josh_2>
eh
<Josh_2>
doesn't matter, another day I'll fix it, I'll submit my work without the image
<oni-on-ion>
ok =)
rumbler31 has quit [Ping timeout: 244 seconds]
Nilby has joined #lisp
Oddity has joined #lisp
rumbler31 has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
<pjb>
Josh_2: notably, you need to specify your toplevel function.
<Josh_2>
Well I didn't have a top level function
<pjb>
In it you will be able to start your servers, or connect to them.
<Josh_2>
I didn't want a top level I just needed the image to function the same as it would have in sly, but it didn't
<pjb>
Images don't save threads. So it needs to restart with a toplevel function. By default it's just the REPL.
<Josh_2>
Yes, the repl is fine
<Josh_2>
There is a function that I call to start the servers, which I did in the image but it doesn't behave the same as it does in Sly
<Josh_2>
I don't know I don't really have time to figure it out right now :(
<pjb>
But then you need to call your program manually from the REPL each time you reboot the lisp image.
<Josh_2>
Yes
<Josh_2>
which for the purpose was just fine, if I was actually shipping the application then it is not
<pjb>
Then there may be differences because of the initialization of global variables and other global resources.
<pjb>
You need to write an init function and add code in it to initialize stuff, instead of just defvar/defparameter.
<Josh_2>
ahh
<pjb>
You cannot initialize everything in defvar/defparameter.
<Josh_2>
bit of a pita
<Josh_2>
That's pretty much what was happening :P although I don't have many globals just an IP address
<pjb>
You should take care of pathnames: pathnames are created at read time with #P"…" but readtime occurs at compilation-time. path are different at compilation time and at run-time.
<Josh_2>
No paths are used in the actual program
<pjb>
But be careful for other things like that.
<Josh_2>
I normally generate pathnames using make-pathname etc
<pjb>
It's not how, it's when.
aindilis has quit [Ping timeout: 246 seconds]
<Josh_2>
O right
<Josh_2>
Well I don't know I will look at it another time as I wouldn't mind actually putting this app and the server on google playstore
<Josh_2>
has to work to do that :P
ring has joined #lisp
<longshi>
pjb: thx!
<pjb>
Josh_2: for example, perhaps you're using CFFI (at least indirectly) to use UDP.
<pjb>
Josh_2: then you need to reload the libraries in your init function, since they may be different each time you reboot your lisp image.
random-nick has quit [Read error: Connection reset by peer]
notzmv has quit [Ping timeout: 246 seconds]
ring has quit [Ping timeout: 250 seconds]
longshi has quit [Quit: WeeChat 2.4]
<Josh_2>
Hmm that sounds like a complete pita
angavrilov has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
idlus_ has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
idlus has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 255 seconds]
_whitelogger has joined #lisp
rumbler3_ has joined #lisp
zcid has quit [Ping timeout: 252 seconds]
zcid has joined #lisp
rumbler31 has quit [Ping timeout: 245 seconds]
<pjb>
Josh_2: it is: you're mixing two completely different philosophies, that of image-based development, and that of file-based unix development.
<pjb>
Josh_2: There's a reason we say BOOTING a lisp image. It's really a virtual machine with another operating system. And the VM needs to interface with the host VM. It's not simple.
<oni-on-ion>
but udp is network ? even though it has the name unix, how else to talk to non-lisps without extern I/O ?
<pjb>
oni-on-ion: we use sockets, thru a C unix library.
<oni-on-ion>
yep.
<katco>
does anyone have any opinions on `cl-ana`?