dacoda has quit [Remote host closed the connection]
robdog_ has quit [Ping timeout: 252 seconds]
nanoz has joined #lisp
smokeink has joined #lisp
nanoz has quit [Ping timeout: 250 seconds]
<Xach>
eminhi: no
iAmDecim has joined #lisp
<no-defun-allowed>
depends on the context, i think DO would be better for looping, but it does expand to TAGBODY in the end
<aeth>
eminhi: In most implementations DO will macroexpand to block over let over tagbody and DO* will macroexpand to block over let* over tagbody, e.g. it's pretty straightforward in SBCL with this: (macroexpand-1 `(do ((x 42) (y 1 (1+ y))) ((> y x) (+ y x)) (format t "~D ~D~%" x y)))
<Xach>
in this case "better" is entirely subjective
<Xach>
DO looks gross so don't use it!
<aeth>
(It actually has two TAGBODYs in SBCL's macroexpansion of DO because DO-FOO forms have an implicit TAGBODY so you can write your own labels/GOs in there for more complicated iterations.)
<eminhi>
I want to reason with something more abstract than TAGBODY. and I really dont want to target loop.
<aeth>
eminhi: If what you want is ultimately BLOCK over LET over TAGBODY over TAGBODY then DO (or DO* for LET*) can save a lot of lines in your macro
<aeth>
If you want something more complicated (e.g. MULTIPLE-VALUE-BIND) then you'd have to work with TAGBODY directly, or you'd have to work with someone else's more advanced macro.
<aeth>
(Although, to be fair, I don't think LOOP handles multiple value bindings, either.)
Essadon has quit [Quit: Qutting]
<aeth>
Xach: If you put it in a macro then no one has to know that you use DO
<wkelly>
aa
<wkelly>
er, sorry
<aeth>
wkelly: I read that as a scream at the idea of people using DO
<wkelly>
haha
angavrilov has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 250 seconds]
<PuercoPop>
How would you phrase the relationship between the method and the specialized parameter? e.j. "The EMACS-INSPECT method that specializes in HASH-TABLE"?
<Bike>
the emacs-inspect method specialized on hash-table, proably
<PuercoPop>
Also can someone with access to SLIME check if inspecting the resulting hash-table from the following expression breaks for them?
<Bike>
when i try to inspect it i get an error "The value .."
<Bike>
not amazing.
<PuercoPop>
So its the same bug that in sly
<PuercoPop>
Basically the problem is that it applies < to complex numbers, that only applies to reals
eminhi_ has joined #lisp
<Bike>
yes, i see it in the method. unfortunate.
<PuercoPop>
I'm going to recommend to change the typep to real. However I'm wondering it would make sense to implement an ad-hoc order
<PuercoPop>
like by the real part first and the imaginary part as a tie-braker
<Bike>
or just by magnitude. but really, limiting to reals seems fine
slyrus has quit [Quit: slyrus]
<aeth>
PuercoPop: Distance from 0 (assuming it's on the real-imaginary plane) with the real part as a tie breaker could be another way to sort complex.
eminhi has quit [Ping timeout: 250 seconds]
<aeth>
So magnitude then real?
<aeth>
(Or the other way around, of course.)
Mr-Potter has quit [Ping timeout: 268 seconds]
<aeth>
You could do magnitude then angle between [0, 2 * pi)
<PuercoPop>
Bike: aeth yeah magnitude its better, it plays better with only real numbers.
<aeth>
It looks like the angle is called PHASE
<aeth>
There's probably a way to combine ABS and PHASE so it gets the regular sorting order on reals as well, e.g. (phase 1) is 0.0 and (phase -1) is pi
<PuercoPop>
aeth: I've opened the issue on the SLIME issue tracker but the fix only for Sly, maybe you can send a PR that orders numbers that way?
<drmeister>
Given a quicklisp system - is there a way to get the dependency graph before quicklisp starts compiling stuff?
<aeth>
hmm... Backwards sort of PHASE's angle and then ABS would work for complex in a way that also works on reals. i.e. if PHASE is the same, tiebreak with abs (since it's float you wouldn't be able to use =, though).
<aeth>
(obviously it's faster to have a typecase and only do this for complex, but you could still encounter things like #C(1d0 0d0) and #C(-1d0 0d0))
mindCrime has joined #lisp
nirved has quit [Ping timeout: 252 seconds]
MightyJoe has quit [Remote host closed the connection]
<aeth>
PuercoPop: Maybe something like this but without = (since you can't really use = on floats)? Sorts by angle then magnitude in a way that behaves like < if the imagpart is 0. (defun complex-< (x y) (if (= (phase x) (phase y)) (< (abs x) (abs y)) (> (phase x) (phase y))))
<aeth>
There's probably a name for something like this because sorting complex is not a new problem.
fikka has quit [Ping timeout: 272 seconds]
<Bike>
it's pretty easy to prove there's no total order, and that's about where things usually end
<aeth>
Bike: This seems like a weaker issue, though: can we produce a function that works with #'sort?
<Bike>
anything's possible with the power of imagination
pfdietz has joined #lisp
esper0s has joined #lisp
anewuser has joined #lisp
SlashLife has joined #lisp
<Xach>
drmeister: in some cases, yes. in all cases, no.
<drmeister>
Hi Xach - thanks for following up.
<Xach>
drmeister: .asd files are loaded and can run arbitrary lisp code, including loading and building other things. also :defsystem-depends-on is a problem.
<drmeister>
Right arbitrary code. What if they don't - if they play nice.
<Xach>
drmeister: then you can look at the relationships between systems without much trouble.
<Xach>
drmeister: also, quicklisp precompiles info about those relationships, so if every system is from quicklisp, you can query quicklisp's indexes instead of asdf's.
<Xach>
but that doesn't work on non-quicklisp systems.
<drmeister>
What about local-projects?
<drmeister>
Are those considered as from quicklisp?
<Xach>
drmeister: no.
<Xach>
those are found and loaded via asdf.
<Xach>
quicklisp adds some stuff to asdf to teach it how to find them
<Xach>
drmeister: with quicklisp, i compile and load everything, and record what actually gets loaded, and use that to find the de facto relationships.
<Xach>
that's when compiling the indexes for a dist
elderK has quit [Ping timeout: 246 seconds]
<drmeister>
I'm trying to speed up our build for the Cando chemistry code.
<drmeister>
We have the clasp build down to about 30 min by forking every compile-file that we can.
graphene has quit [Remote host closed the connection]
<drmeister>
Then we build the Cando quicklisp systems and it drops back to serial mode and takes an hour - ugh.
mindCrime has quit [Ping timeout: 240 seconds]
<drmeister>
I'm thinking that I should load everything with quickload and then determine the system dependencies once everything is loaded and save the dependency graph to use the next time we build.
graphene has joined #lisp
<drmeister>
I'd like to compile systems in parallel as much as possible.
<Xach>
that sounds like something fun to try
<drmeister>
POIU would be nice - but it's broken. A faster compiler would be nice - but... llvm.
fikka has joined #lisp
dale has quit [Quit: dale]
<aeth>
drmeister: The problem with compiling systems in parallel is that some systems change globals as part of their compilation process, even though they probably shouldn't do that and should leave that to the user (except for pushing to *FEATURES* and a few other niche cases)
lmy9900 has joined #lisp
<drmeister>
I'll find out soon enough
lmy9900_ has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
<drmeister>
If I quickload systems from the leaves in to the root in separate forks it will compile all of the source code once and then I can quickload the root and it will hopefully all work.
lucasb has quit [Quit: Connection closed for inactivity]
<drmeister>
I'm going to change compile-file so that it compile-files into a temporary file and then atomically renames it to the target.
<pfdietz>
The advantage of compiling things in parallel is you can fail when people do that (which is wrong, as what happens when you reload precompiled fasls into a new image?)
<pfdietz>
If you've already compiled a system, you can just load the fasls, right? So if the compile process caused some side effect that you're depending on, you won't get that just by loading the fasls.
groovy2shoes has joined #lisp
<pfdietz>
Because you won't be compiling the source.
lmy9900__ has joined #lisp
lmy99____ has quit [Ping timeout: 250 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
lmy9900_ has quit [Ping timeout: 240 seconds]
arescorpio has joined #lisp
fikka has joined #lisp
lmy9900_ has joined #lisp
lmy990___ has joined #lisp
lmy9900__ has quit [Ping timeout: 250 seconds]
lmy9900__ has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
lmy9900_ has quit [Ping timeout: 245 seconds]
lmy9900_ has joined #lisp
lmy990___ has quit [Ping timeout: 250 seconds]
<drmeister>
I see - I'll hope for the best.
<pfdietz>
In general, any global change that you depend on should go into an eval-when that causes it to be performed when the fasl is loaded as well.
lmy9900__ has quit [Ping timeout: 268 seconds]
<drmeister>
How does one walk the tree of dependency for a loaded asdf system?
<drmeister>
I'm looking at asdf-viz - it visualizes these things but I can't make hide nor hair of it.
fikka has joined #lisp
<drmeister>
Hmm, it uses cl-dot. Investigating...
lmy9900 has joined #lisp
lmy9900__ has joined #lisp
lmy9900_ has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 246 seconds]
lmy990___ has joined #lisp
lmy9900 has quit [Ping timeout: 250 seconds]
lmy9900 has joined #lisp
lmy9900__ has quit [Ping timeout: 250 seconds]
eminhi_ has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
lmy990___ has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
dot's a program for spitting out SVGs from edges of a graph, so half the program would probably just be flattening the tree of dependencies
<rk[ghost]>
pillton: thanks much. that saved me grepping thru a bunch of files to see how i used it in a project (who knows which one, long enough ago) :P
fikka has joined #lisp
edgar-rft has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
Inline has quit [Quit: Leaving]
pw_ has quit [Remote host closed the connection]
pw_ has joined #lisp
sauvin has joined #lisp
vlatkoB_ has quit [Remote host closed the connection]
vlatkoB has joined #lisp
robotoad has quit [Ping timeout: 250 seconds]
robotoad has joined #lisp
frgo has quit [Remote host closed the connection]
fikka has joined #lisp
elderK has joined #lisp
<elderK>
Lo all :)
<elderK>
equwal: My screens aren't rotatable.
fikka has quit [Ping timeout: 250 seconds]
<elderK>
equwal: I have seen some people do that though, in the past.
<equwal>
hi
<equwal>
Are we talking about emacs?
<elderK>
No.
<equwal>
What do you mean by that?
<elderK>
The problems I have are independent of any editor.
<elderK>
I'm confused - I'm not sure what you're talking about now :D
<equwal>
Why did you hail me?
<elderK>
Because you left me a message? :D
<equwal>
I did?
<equwal>
What did I say in it?
<elderK>
Something about rotating stuff.
<elderK>
:P
<equwal>
uh
<elderK>
I've switched clients - it may have been a long long time ago. I didn't check the timestmap :P
<elderK>
Let's just forget it all. My bad :)
<equwal>
I can't remember. I have a vague memory, probably I was talking about how in emacs you can get a library to rotate the in-frame windows.
<equwal>
So only error check something that you think should be legal but which requires special treatment.
<elderK>
Right, so in that case I'd specify "Slots are of the form (name type &key (count 1)).
<elderK>
And I'd check that name, type are symbols and that count is a non-negative integer.
<elderK>
And any error generated because they fed in gibberish, is their own
<elderK>
:P
<equwal>
The point of my suggestion is that you wouldn't check any of that since it is a waste of your effort and isn't meaningful anyway. The only reason you might check is if you want to make sure that your program fails in a specific way when that happens.
<equwal>
For example, to avoid a silent failure mode.
<beach>
Good morning everyone!
<equwal>
Hi beach
<splittist>
good morning beach
<elderK>
Good morning, Beach!
fikka has joined #lisp
<equwal>
Turns out swapping () and [] on your keyboard is a pain.
JohnMS_WORK has joined #lisp
<equwal>
Though I was just going to modify my emacs init file, but now I am programming udev and systemd.
fikka has quit [Ping timeout: 245 seconds]
<no-defun-allowed>
are you changing it everywhere?
eponym has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
would xmodmap do enough?
guest has joined #lisp
<equwal>
Hasn't worked with GNOME in my experience, since GNOME has it's own incomplete system for keybindings.
<ebrasca>
good morning
drewes has joined #lisp
<no-defun-allowed>
cause just in emacs is 4 lines of elisp, and ctrl-caps swapping was 2 in xmodmap so i imagine it's not too hard
<equwal>
So you have to change the keybinds on hotplug of the keyboard, which requires watching Udev with a systemd script.
<no-defun-allowed>
nasty
guest has quit [Max SendQ exceeded]
guest has joined #lisp
<equwal>
I tried in elisp, seemed more difficult than the above nasty.
<equwal>
For example, using #'insert works, but subverts paredit.
guest has quit [Remote host closed the connection]
<equwal>
1 hour reading documentation > 1 hour on stackoverflow
frgo has quit [Ping timeout: 272 seconds]
frgo has joined #lisp
terpri has quit [Quit: Leaving]
fikka has joined #lisp
Guest76455 has quit [Ping timeout: 268 seconds]
frgo has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 250 seconds]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
robotoad has quit [Quit: robotoad]
jetchisel has quit [Ping timeout: 250 seconds]
fikka has joined #lisp
dddddd has joined #lisp
robdog has joined #lisp
angavrilov has joined #lisp
groovy2shoes has quit [Excess Flood]
JohnMS_WORK has quit [Ping timeout: 240 seconds]
groovy2shoes has joined #lisp
heisig has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
JohnMS_WORK has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
fikka has joined #lisp
nanoz has joined #lisp
frgo has joined #lisp
varjag has joined #lisp
frgo has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 250 seconds]
fikka has quit [Ping timeout: 250 seconds]
groovy2shoes has quit [Excess Flood]
groovy2shoes has joined #lisp
nirved has joined #lisp
hajovonta has joined #lisp
<hajovonta>
hello
<beach>
Hello hajovonta.
xkapastel has joined #lisp
<hajovonta>
hi beach
<hajovonta>
long time no see :)
<beach>
So where have you been?
<hajovonta>
work issues, family issues... I currently don't have a desk at home and did no CL recently :(
<beach>
Sorry to hear that.
yvy has joined #lisp
<hajovonta>
I couldn't find a way to incorporate CL into my daily job in the past year. We hopefully get a new assignment for next year though, and I'm optimistic.
Zaab1t has joined #lisp
Zaab1t has quit [Remote host closed the connection]
igemnace has quit [Quit: WeeChat 2.3]
<beach>
Good luck!
fikka has joined #lisp
dddddd has quit [Ping timeout: 250 seconds]
hjudt has quit [Ping timeout: 250 seconds]
<hajovonta>
thanks..
fikka has quit [Ping timeout: 268 seconds]
kajo has quit [Ping timeout: 268 seconds]
frgo has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
stacksmith has quit [Ping timeout: 252 seconds]
frgo_ has quit [Read error: Connection reset by peer]
frgo has joined #lisp
dddddd has joined #lisp
frgo_ has joined #lisp
frgo has quit [Remote host closed the connection]
jochens has joined #lisp
jochens has quit [Remote host closed the connection]
jochens has joined #lisp
fikka has joined #lisp
Lycurgus has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 244 seconds]
lnostdal has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
jsc has joined #lisp
jsc is now known as status402
ebrasca has quit [Remote host closed the connection]
fikka has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
yvy has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
hhdave has joined #lisp
hhdave_ has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
igemnace has joined #lisp
hhdave has quit [Ping timeout: 244 seconds]
hhdave_ is now known as hhdave
shrdlu68 has quit [Ping timeout: 250 seconds]
<sindan>
hajovonta what are you thinking of doing with CL job-wise?
gxt has quit [Quit: WeeChat 2.3]
fikka has joined #lisp
jochens_ has joined #lisp
frgo_ has quit [Remote host closed the connection]
Mr-Potter has joined #lisp
jochens has quit [Ping timeout: 250 seconds]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
lucasb has joined #lisp
<hajovonta>
sindan: I think many system engineering type assignments give possibilities to develop something in CL
<hajovonta>
sindan: I rather write some controlling software in CL than in bash
<sindan>
hajovonta: just curious, CL is wonderful but it's far too powerful and flexible for many managers' taste, and if they know anything about software development, they know that the developer market is not big, therefore they resent having critical systems dependant on just one person, but maybe you knew that already
<sindan>
I would if I had to attend to many other things, too, but maybe you are lucky
lemoinem is now known as Guest21217
lemoinem has joined #lisp
<ogamita>
Yes, anytime you start writing #!/bin/bash quick, type ^W^W usr/local/bin/clisp -ansi -q -E utf-8 instead.
Guest21217 has quit [Ping timeout: 246 seconds]
<ogamita>
equwal: what pain do you have in swapping [] with ()? (apart the need to adapt to the new layout?)
<sindan>
bash is a horrible choice anyway, I'd choose python for anything now over, say, 0 lines
esper0s has quit [Remote host closed the connection]
<aeth>
bash can do in 5 lines what Python would need dozens for
<aeth>
I think a language doesn't get a conciseness advantage over bash until 100 lines or so (but you probably want to go away from bash before that point)
<hajovonta>
sindan: you are right, they won't let me write critical systems, but there are many tedious tasks involved, like installing, configuring and integrating components, and chances are that procedures require manual effort, where CL can step in, to save time (for myself)
<hajovonta>
that's why I said system engineering, because software development is where you develop something that others will use
<heisig>
sindan: I would be more enthusiastic about Python if it were not about 50x slower than CL. Furthermore, I find it extremely hard to write Python programs that do not contain subtle errors.
<hajovonta>
heisig: care to share pointers on that topic? My colleagues are enthusiastic about Python.
<heisig>
In my benchmarks, Python is always 20-200 times slower than Common Lisp code. The 50x I mentioned was when comparing adventofcode solutions with one of my colleagues.
<heisig>
But that is not the biggest problem of Python. The big problem is that the language has so many pitfalls.
<Cymew>
All the world is enthusiastic about python, as it's everyones darling for some reason. It's dog slow, and Ruby is even slower. But, this is seriously off topic.
<jdz>
[My only $0.02 of off-topic material] My bet is that people like Python because of the many libraries, which means they only have to write glue code.
aindilis has quit [Read error: Connection reset by peer]
<hajovonta>
heisig: I'm interested in looking at your performant CL code. I sometimes need to improve my CL code performance, but struggle to do so
Younder has quit [Remote host closed the connection]
<hajovonta>
at hackerrank, the requirements of completion are some 10x higher for CL code than for say Java or C++
<Cymew>
hajovonta: Have you tried to use some kind of profiler?
<hajovonta>
Cymew: no, but I use SBCL and I know it has a profiler, but don't know exactly how to use it or what to look for
<Cymew>
There are some good articles online about how to use it.
<Cymew>
Check those out, it is well worth it.
<hajovonta>
I'm interested
aindilis has joined #lisp
<aeth>
hajovonta: most things are caught by SBCL when you (declare (optimize (speed 3))) in a function
<Cymew>
In general, you want to find where in the code you spend most time, and figure out why.
igemnace has quit [Read error: Connection reset by peer]
lvmbdv has quit [Quit: brb update]
<hajovonta>
I know the basic principles, like look for tight loops, and don't optimize code sections that don't contribute much to the time elapsed, but usually stuck with optimizing the identified parts
igemnace has joined #lisp
<heisig>
hajovonta: Maybe I should write a blogpost about how to write fast Common Lisp code over Christmas :) But the examples that I mentioned were not even optimized code. Baseline CL beats Python by orders of magnitude.
<Cymew>
I've found the profiler usually tell me my code spend time in a place which makes me go "huh?" and then realize that I can pre-calculate data and do some inline DECLARE.
fikka has quit [Ping timeout: 250 seconds]
<Cymew>
heisig: Please do! That would be fun to read.
orivej has joined #lisp
aindilis has quit [Ping timeout: 246 seconds]
ealfonso has quit [Read error: Connection reset by peer]
<Cymew>
Surprisingly often you really don't optimise at all, just rethink, after seeing the profiler output. But, maybe that says more about me being bad at using the best algorithm from the start... ;=)
<sindan>
I have profiled some SBCL code of mine, and the results also make me wonder. IIRC most of the time is used in consing thousands or millions of times, it's quite unexpected
<sindan>
heisig: would like to read some advanced post (meaning it doesn't have to be a boring "primer") on how to optimize CL code
<ogamita>
aeth: this is plain wrong. Any programming languages is a clear win from 0 lines of bash, just because bash has no data structure.
<ogamita>
aeth: when you start having to implement first class arrays, structures, trees, anything in bash, you explode the LOC!
drewes has joined #lisp
<ogamita>
(and let not me start talking about error handling in sh or bash!)
leo_song has joined #lisp
<sindan>
bash is to cobble together two or three utilities, it barely does arithmetic, when I see bash scripts in the hundreds of lines I wonder what is on the author's mind. And yes, they are going to bomb on any mistake, unless you read the return code of everything you do and do if() error handling sprinkled all over the logic... a nightmare no matter how one tries to go about bash
<sindan>
and I would not write long programs in python (meaning well behaved, efficient system programs), but as glue code it's unmatched because there are libraries for everything.
Kaisyu has quit [Quit: Connection closed for inactivity]
status402 has quit [Read error: Connection reset by peer]
status402 has joined #lisp
figurelisp has joined #lisp
<sindan>
heisig: care to mention some of your troubles with python?
jellopudding has quit [Ping timeout: 245 seconds]
<beach>
For one thing, it doesn't have an independent standard, so it is not such a great idea to choose it for a serious commercial project.
<ogamita>
beach: You're confusing the name and the essence of the thing. Here statement is just a non-terminal name in a grammar. It's definition is that of a form, and a form is an expression . The only things that are executable in lisp are expressions.
<beach>
Hence the `:)'.
<ogamita>
I jumped on the link…
heisig has quit [Remote host closed the connection]
jello_pudding has quit [Ping timeout: 250 seconds]
jello_pudding has joined #lisp
<sindan>
Not many points against then...
jellopudding has joined #lisp
jello_pudding has quit [Remote host closed the connection]
<beach>
"It can ruin your company, but hey, that's just one point against"
<sindan>
beach: point to technical things instead of trying to be witty with no substance
<beach>
No substance? Interesting point of view.
<sindan>
or, with substance only known to you, which must be extremely funny
<beach>
So I am the only one that knows that it has no independent standard?
<sindan>
I hope you only program in Java or Ada then
<sindan>
Well, typical #lisp: still, no valid criticism. And you reply, if any, still won't be valid criticism, just more snarky comments
<jackdaniel>
as of standards, I don't see a big practical difference between finished standard (like CL), and finished reference implementation (like python2), given both are freely available and won't change.
m00natic has joined #lisp
<beach>
I am sorry to hear that.
<sindan>
jackdaniel: true, but the stink of aristocratic pretentions about lisp here never goes away.
micro has quit [Ping timeout: 245 seconds]
micro has joined #lisp
<jackdaniel>
sindan: I must warn you (for the last time), please do not try to offend people on this channel
<sindan>
I am not trying, it seems. It looks like I am suceeding. I asked about technical points. I only get personal opinions, at best.
Lycurgus has joined #lisp
<_death>
if you keep to technical questions, you will get technical answers
kajo has joined #lisp
<sindan>
I did, and I do not.
heisig has joined #lisp
shrdlu68 has joined #lisp
<jackdaniel>
to make myself clear: "no big difference" was *not* about quality and under the assumption, that said reference implementation has a written specification of how it behaves. my point was that both a) won't change; b) may be reimplemented; the only difference is that one has a "standard" sticker
<heisig>
sindan: Sorry, I was having lunch. Are you still around and want to hear my thoughts about Python? (Btw, I use Python myself, especially when I intend to share the code with my coworkers afterwards).
<_death>
thoughts about python seems like a discussion for #lispcafe
<heisig>
_death: You are absolutely right.
<sindan>
heisig: I'd like to, let's head there then
<_death>
unless it's Python the Lisp compiler :)
<jackdaniel>
or python2 implementaiton in common lisp (we have one ;-)
v0|d has quit [Read error: Connection reset by peer]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
Demosthenex has quit [Ping timeout: 244 seconds]
gravicappa has joined #lisp
joga has joined #lisp
fikka has joined #lisp
nowhere_man has joined #lisp
<ogamita>
sindan: the problem is that you don't understand the consequences. We start from a very small number of apparently "small" things, such as no independent standard, statements, significant whitespaces, no multi-line lambda, but the consequences are huge. If you're not experimented, you may not forsee them and understand.
<ogamita>
sindan: but basically, any one of those items (or the mess with lexical scopes), would be already redhibitory.
<ogamita>
sindan: we could probably go on and find hundreds of problems, but it's no use, once there's already one disqualifying problem.
<sindan>
ogamita: thanks for some points. Down at #lispcafe I was saying that python is not to teach CS concepts. It's a language to get things done, admirably put together considering what it attempts to cover.
<sindan>
And the hyperspec is full of footnotes about quirks, I don't have to mention then dozens of them. We like lisp and program around its quirks.
<ogamita>
ok
ebrasca has joined #lisp
smokeink has quit [Remote host closed the connection]
ebrasca has quit [Remote host closed the connection]
smokeink has joined #lisp
jochens_ has quit []
ebrasca has joined #lisp
frgo has quit [Read error: Connection reset by peer]
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
nirved is now known as Guest6998
nirved has joined #lisp
Guest6998 has quit [Ping timeout: 252 seconds]
Demosthenex has joined #lisp
nanoz has quit [Ping timeout: 250 seconds]
fikka has quit [Ping timeout: 250 seconds]
gxt has joined #lisp
<Odin->
Quirks are one thing, not doing something about structural messes is another.
<Odin->
For a good long while Lisp didn't do lexical scoping.
<Odin->
That was fixed.
Demosthenex has quit [Ping timeout: 272 seconds]
<Odin->
Python doesn't seem to want to go more than halfway to a fix.
kajo has quit [Ping timeout: 252 seconds]
gxt has quit [Ping timeout: 245 seconds]
Demosthenex has joined #lisp
gxt has joined #lisp
fikka has joined #lisp
Bike has joined #lisp
milanj has joined #lisp
lmy9900 has joined #lisp
frgo has joined #lisp
nanoz has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<p_l>
Python is a mess, especially once you look into how it's done
<xificurC>
well this was fun to read. not. Let me ask something more on topic. I've seen people link to the OUT macro from ytools several times. However I don't see the package (ytools) in quicklisp. Is anyone using it? Is there a fork with a different name where the OUT macro is available? Or does everyone just stick to FORMAT?
ebrasca has quit [Remote host closed the connection]
SaganMan has joined #lisp
<_death>
I have an OUT macro inspired by the YTools one.. it's not in quicklisp though
nolanv has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 244 seconds]
smokeink has quit [Remote host closed the connection]
<xificurC>
interesting, thanks
nolanv has joined #lisp
wilfredh has joined #lisp
<elderK>
_death: That's pretty neat :)
fikka has joined #lisp
<elderK>
_death: Also, unrelated: When I see your name, I think of Death, The Grim Reaper from Terry Pratchett's Discworld series :)
<elderK>
I wonder, do you have a black garden, too? :D
<_death>
Binky likes to stroll there
<elderK>
:) Heh
figurelisp has quit [Ping timeout: 250 seconds]
<elderK>
On another tangent: I wonder how many CL / Scheme programmers there are in the world. Like, those capable of writing CL / Scheme in a professional capacity.
<elderK>
I have specified "CL" and "Scheme" rather than "Lisp", because I don't want to include say, AutoLisp or Emacs Lisp :P
<elderK>
"Perhaps there is some Great Filter, that extinguishes most programmers before they become truly enlightened?" :P
<elderK>
Or perhaps the majority of the Lisp programmers are hidden somewhere, sleeping. Hibernating maybe :P
fikka has quit [Ping timeout: 250 seconds]
<elderK>
Or perhaps, the majority of programmers in the world are simply too young, too naive, too immature? And the Great Lispers are waiting for us to wisen before bestowing us with their knowledge? :D
CrazyEddy has quit [Remote host closed the connection]
status402 has quit [Ping timeout: 268 seconds]
status402 has joined #lisp
<dlowe>
It's a somewhat unpopular opinion but I think the mystique of lisp is misplaced and actively harmful to its popularity
<_death>
there are some quantities that could help estimating.. e.g., number of quicklisp installs (Xach publishes quicklisp data every now and then.. guess he could log IP addresses or User-Agent for better estimates..), number of github users with CL repos, or committers to CL repos, number of lisp subreddit subscribers, number of stackoverflow users asking/answering CL questions, etc.
<ogamita>
xificurC: the only criterial for quicklisp is that it should have an asd file and compile without error on sbcl.
<elderK>
It would be interesting to get like some hard numbers on: How many people say, install some CL implementation, tinker with it for a little, then leave it behind. Of the number that do, you know, play for awhile and leave it behind, some fraction of them will have taken something neat from the language, from whatever dialect they may have used. Then the other, I assume the larger fraction, will simply leave it behind with nary another thought.
<dlowe>
there's no point in gathering such statistics if they aren't actionable
<elderK>
It's like recently I learned that one of the people who inspired me originally to look into Lisp, actually doesn't seem to think it's useful for day-to-day stuff. That amazes me. Instead, he believes that it has a lot of lessons to offer, things to learn and take from.
<ogamita>
elderK: in a professional capacity, is the strong criteria in your question. Not lisp…
<dlowe>
I believe that's one of the "lisp mystique" problems.
<jdz>
elderK: that sounds much like the "advice" from ESR.
<elderK>
jdz: It was from defmacro :)
<shka__>
dear lisp
<elderK>
dlowe: I'm not sure it's necessarily a Lisp problem - but more an FP one. Languages such as Standard ML or Haskell have "mystique" too. Although, I'd imagine Haskell is somewhat more popular than Lisp. Of course, that's just my intuition - I have nothing to support that claim.
<ogamita>
elderK: given the statistics on the age pyramid of lisp programmers, we could assume that you need 20 years experience in programming to become a professional lisper. That's about the age when a lot of programmers switch to something else.
<shka__>
i heared some time ago advice to avoid using print-object for printing unreadable stuff, however, it is ok if implementaiton is wrapped in the print-unreadable-object macro, isn't it?
* beach
was going to say that it doesn't seem to be the case that any great knowledge is required in order to program professionally, but he won't because he will surely be contradicted.
<ogamita>
elderK: otherwise, given that half the programmers are newbies with less than 5 years, yes, the majority are simply too young.
<elderK>
Well, that's perhaps one reason I've been investing so much time over the past month. I've been investigating / playing with Lisp on and off for damn near ten years - but never made the "jump." But, I've been getting more and more... not sick of - something else - of C and C++.
<elderK>
I've always figured: If I was going to move to something other than C or C++, I'd move to Lisp rather than something like Python or Scala or *shudder* Java.
<pfdietz>
I'm not sure it takes more time to master Lisp than it does to master C++. The latter seems to be rather complex these days.
<beach>
shka__: That sounds like strange advice.
<elderK>
shka__: I use print-unreadable-object inside of print-object often
* pfdietz
has been reading about C++ exception handling redesigns.
<elderK>
I've seen print-object defined that way in many repositories online.
<ogamita>
elderK: I think he's misdirected. you can verify it yourself, by translating some non-trivial lisp program you wrote, into Java or C. Try to keep the lisp style.
<elderK>
pfdietz: I agree with you - I think CL is much smaller and much more understandible as a language these days compared to C++. That being said, it's one thing to "understand the language" and another to apply it well.
<dlowe>
pfdietz: C++ is all about finding a functional subset and only using that.
<elderK>
ogamita: For many years, I wrote C and C++ code in a way that could construed as "more functional than average"
<ogamita>
You can do something. It certainly gives better C programs IMO. But it's hard for the author, because so much infrastructure is lacking (no GC, no conditions, etc). And coworkers are always complaining…
<elderK>
dlowe: Iono. "Idiomatic" C++ changes with every revision. More and more, it involves making good use of TMP, too, in some capacity. You don't need TMP and stuff to deliver a good product, of course. And what is "idiomatic" differs depending on who you speak to, but, by and large, it seems to be heading in that direction. And has been, for quite some time.
shifty has quit [Ping timeout: 250 seconds]
<elderK>
ogamita: I agree with you.
<ogamita>
elderK: and you quickly reach the point where you would just use libecl.so…
notzmv has joined #lisp
<elderK>
Iono. I spent a lot of time last year and earlier this year, "modernizing" my C++ capabilities. I spent a /massive/ amount of time experimenting with template metaprogramming and studying a vast number of libraries involving it, as well as others generally thought of as representing "great modern C++." I completed that process with an increased appreciation for CL and Lisp in general.
<elderK>
I mean, I've appreciated Lisp's qualities for a long time. But, learning and tinkering with C++ TMP for /real/ work, well, it left me desperately wanting to do such metaprogramming in something like CL.
* dlowe
brushes the C++ converation over to #lispcafe
* elderK
hops on over
fikka has joined #lisp
<beach>
ogamita: That's not idiomatic C though.
<PuercoPop>
I want to prefix with 0s a number. From reading 22.3.2.2 my understanding is that (format nil "~2,0D" 1) should work. However I get 0 is not a character
<beach>
PuercoPop: '0
<PuercoPop>
ahh with quote! I was trying #\0
<PuercoPop>
thanks beach!
<beach>
Sure.
<shka__>
beach: i thought so, but i thought that i better check with #lisp
<beach>
Yes, that's always good to do.
<beach>
You still have to filter, though. Not everybody here gives good advice.
<shka__>
btw, i ended up with ICD codes as a trie
jochens has joined #lisp
<shka__>
or rather: prefix tree
<xificurC>
was that a good advice? :) Don't filter, remember who gives bad advice
<shka__>
xificurC: hmmm :P
lmy9900 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
shka__: OK.
<shka__>
now i can finally clean my data properly :-)
FreeBirdLjj has joined #lisp
steiner has quit [Remote host closed the connection]
lmy9900 has joined #lisp
hajovonta has quit [Remote host closed the connection]
<pfdietz>
suffix trees are a data structure I've repeatedly used over the years.
lmy9900 has quit [Max SendQ exceeded]
Inline has joined #lisp
nirved is now known as Guest43567
Zaab1t has joined #lisp
nirved has joined #lisp
lmy9900 has joined #lisp
* beach
even wrote a paper about suffix trees, around 1985 or so.
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<ogamita>
PuercoPop: note that you can use V: (format nil "~2,VD" #\0 1) #| --> "01" |#
aindilis has joined #lisp
dale has joined #lisp
Guest43567 has quit [Ping timeout: 252 seconds]
shrdlu68 has quit [Quit: WeeChat 2.2]
<pfdietz>
Using cl-string-match right now, although I wish it was on a git site I could do pull requests on.
<ogamita>
Also, that would depend on the kernel. linux, darwin/
<ogamita>
?
Demosthenex has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<beach>
I guess I'll ask in #sbcl.
<heisig>
I already asked :)
vtomole has joined #lisp
<beach>
Oh, thanks.
<dim>
I want to ask if it works in CCL, as a reference point, but it might be that you're working on something that is tightly coupled with SBCL at the moment?
<beach>
It shouldn't be tightly coupled with SBCL.
<beach>
I might try CCL.
<dim>
my current trick is to develop interactively using one and build images and run tests with the other, and I've got used to using CCL interactively in the SLIME REPL by default, and SBCL for saving images and running tests
<dim>
of course using (sb-ext:restrict-compiler-policy 'debug 3) in ~/.sbclrc makes the experience of interactive development almost the same using either one of those, I still have a slight preference for CCL in interactive mode
<beach>
I see. Thanks.
<dim>
I like using defstruct, for instance, because I'm lazy, and CCL knows how to redefine them on the fly in a way that mostly works
mindCrime has joined #lisp
<beach>
What is the current release of CCL for x86-64?
<dim>
(ccl:rebuild-ccl :full t) once you have the pre-requisites
<beach>
How would that help?
<beach>
Oh, you mean find and fix the bug first?
<dim>
I don't know that you want to do that, but yeah, that would be the idea
<beach>
Could turn out to be tricky.
<dim>
rme from CCL mentionned that they have projects to make their compiler smarter, because it's quite dumb to this day, and maybe, maybe SICL would help, longer term
<dim>
could turn out to be 10 mins of your time, or a week, nobody knows
xificurC has joined #lisp
<beach>
I may have a look, but I have no great hopes of finding the problem.
<dim>
anyway I'm having too many ideas, and I'm playing with your time here, sorry about that, I'll go back to fixing bugs in my job's software written in C now :/
fikka has joined #lisp
<beach>
Oh, sorry to hear that.
<dim>
yeah I know... I don't think that in this instance I could have convinced the team to use CL instead, even Python was out the picture because not everyone there knows how to program in Python... and in truth our main software (an extension to PostgreSQL, named Citus, providing distributed query planning etc) has to be written in C anyway
<dim>
I considered building PL/CL (we have PL/Python, PL/C, PL/...) a couple times, but I'm not knowlegeable enough yet to make that happen: we would need a background worker running the CL image and then lighter CL processes in the PostgreSQL backends where you could run local things and communicate with the central image, I guess
<dim>
sounds too much work for my limited time/energy
edgar-rft has quit [Quit: Leaving]
razzy has quit [Ping timeout: 250 seconds]
Demosthenex has quit [Ping timeout: 246 seconds]
Demosthenex has joined #lisp
<ogamita>
dim: you could do this plugin with libecl.so.
<ogamita>
I don't think you'd need a backgroud worker (unless that's how pl languages are made).
status402 has quit [Quit: status402]
Demosthenex has quit [Ping timeout: 250 seconds]
Demosthenex has joined #lisp
robotoad has joined #lisp
<dim>
yeah a PL doesn't need that, I was more thinking in terms of the developer experience of running CL code, usually you expect a long-lived CL image where you can host things that outlive a PostgreSQL transaction
cage_ has joined #lisp
flazh has quit [Ping timeout: 268 seconds]
robotoad has quit [Client Quit]
robotoad has joined #lisp
Demosthenex has quit [Ping timeout: 240 seconds]
Demosthenex has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
rumbler31 has joined #lisp
Zaab1t has quit [Ping timeout: 268 seconds]
marvin2 has quit [Ping timeout: 272 seconds]
rumbler31 has quit [Ping timeout: 250 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
gigetoo has quit [Ping timeout: 268 seconds]
gigetoo has joined #lisp
LiamH has joined #lisp
anewuser has quit [Ping timeout: 246 seconds]
nicksmaddog has quit [Ping timeout: 272 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
anewuser has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
Mr-Potter_ has joined #lisp
Mr-Potter_ has quit [Remote host closed the connection]
Mr-Potter_ has joined #lisp
Mr-Potter has quit [Ping timeout: 272 seconds]
<elderK>
ogamita: I wish there was like, an embeddable CL where it was easy to like, disable certain functionality. Not just by say, providing a REPL that itself provided less functionality but by actually fundamentally disabling certain stuff.
<elderK>
Say, for sandboxing purposes.
<elderK>
My inexperience is showing here, as I imagine you can achieve the same without actually requiring the ability to like, "disable parts of CL"
Zaab1t has joined #lisp
anewuser has quit [Quit: anewuser]
jochens has quit [Remote host closed the connection]
hhdave has quit [Ping timeout: 240 seconds]
dacoda has joined #lisp
shka_ has joined #lisp
<dim>
sandboxing CL might be a nice byproduct of beach work of first class environments, if I'm following/understanding correctly what he's doing here
<beach>
You are right.
<pjb>
elderK: I guess you could take ecl sources, and #ifndef each functionality you want to be able to disable.
gxt has quit [Ping timeout: 250 seconds]
sword has joined #lisp
gigetoo has quit [Ping timeout: 268 seconds]
gigetoo has joined #lisp
<shka_>
that would be rather useful
<shka_>
racket sandboxing is pretty cool feature
dacoda has quit [Remote host closed the connection]
nowhere_man has quit [Ping timeout: 252 seconds]
gxt has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
marvin2 has joined #lisp
sauvin has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 268 seconds]
vlatkoB has quit [Remote host closed the connection]
m00natic has quit [Remote host closed the connection]
Demosthenex has quit [Ping timeout: 246 seconds]
vlatkoB has joined #lisp
Demosthenex has joined #lisp
v0|d has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
eminhi has quit [Ping timeout: 268 seconds]
nanoz has quit [Ping timeout: 240 seconds]
meepdeew has joined #lisp
SaganMan has quit [Quit: WeeChat 1.6]
varjag has joined #lisp
<emaczen>
beach: you can run SBCL without immobile code
<meepdeew>
Anyone know where to find which gnu texinfo font commands appear in info readers?
<meepdeew>
Most seem to "specify font changes in the printed manual and (where possible) in the HTML output."
fikka has joined #lisp
<meepdeew>
I know there's @emph, which surrounds text with underscores, which I am using, but I'm looking for an alternative to @strong{..}, which puts asterisks around text because it could collide with ear-muffed CL variable names.
graphene has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
xvx has joined #lisp
eminhi has joined #lisp
emaczen has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
milanj has quit [Quit: This computer has gone to sleep]
Demosthenex has quit [Ping timeout: 250 seconds]
Demosthenex has joined #lisp
edgar-rft has joined #lisp
shka_ has quit [Ping timeout: 272 seconds]
rumbler31 has joined #lisp
gxt has quit [Ping timeout: 252 seconds]
meepdeew has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 250 seconds]
xvx has quit [Read error: Connection reset by peer]
Zaab1t has quit [Quit: bye bye friends]
fikka has joined #lisp
<phoe>
What is a way to graph ASDF dependencies of a given system?
<dim>
I just made a McCLIM vizualisation for AdventOfCode of yesterday
<dim>
I'm so happy with it ;-)
<phoe>
dim: show me!
cage_ has quit [Remote host closed the connection]
<no-defun-allowed>
It's federated Twitter at best.
<dlowe>
Mastodon is federated twitter.
<dlowe>
there's other federated things.
<no-defun-allowed>
Something like that. Not very exciting.
<dlowe>
Just wanted to know for following purposes
<dim>
yeah sorry not there yet, I like the idea of distributed social networks though, so someday I'll have a deeper look at it
<jackdaniel>
dim: looks nice :)
<no-defun-allowed>
It's not really that distributed any more than, say, email is.
<jackdaniel>
no-defun-allowed: I find central entities processing my data way more exciting too :)
<no-defun-allowed>
No, I don't like that jackdaniel.
<dim>
jackdaniel: thanks! well (clim:compose-in clim:+green3+ (clim:make-opacity 0.3)) is doing the trick for me, overlapping is pretty obvious given that
<no-defun-allowed>
Mastodon is about as distributed as email is. You can send a message from server A to server B but if you only have an account on A and A goes down you can't transfer it to B.
<jackdaniel>
no-defun-allowed: me niether, just saying it is more exciting (like plain email is boring but gmail is exciting etc)
<jackdaniel>
dim: sorry, I'm fairly busy right now and other things wait in the pipe
<jackdaniel>
however I like how little of the code there is
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
pierpal has joined #lisp
<phoe>
Sigh - I really "enjoy" the feeling that I finally sit down to write some Lisp again, start tweaking my old game project again, and I end up noticing that I need to yak shave again to get that one more thing from the language that I need.
<phoe>
"Enjoy", as in, I both like and dislike it. I'm really ambivalent towards it.
<dim>
well stupid me it takes about that time to compute the numbers that are displayed, so I don't think the drawing actually has anything to do about the lag here, sorry about that jackdaniel
gxt has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<phoe>
MOP question: I have a method and a list of arguments. How can I check if the list of arguments I have suits the method specializers?
<phoe>
I know what I want to do, I just need to find the proper function for that.
milanj has joined #lisp
<Bike>
(every #'typep arguments (method-specializers method)), i guess
<Bike>
oh, but also eql specializers.
<Bike>
probably something annoying then. i don't think mop exposes a "does this method work" function for you.
<phoe>
Hm.
<phoe>
Well, that behavior is a required part of generic function dispatch, so I expect it would be available somewhere.
<Bike>
in ecl, at least, it is an internal function
<phoe>
If it's not in mop, I'll check moptilities.
<fortitude>
phoe: what about using COMPUTE-APPLICABLE-METHODS and seeing if the method in question is a member of the result?
<Bike>
compute-applicable-method is what does it. that particular solution sounds mildly annoying though.
<Bike>
not a function in sbcl either. it's part of compute-applicable-methods-using-types.
angavrilov has quit [Remote host closed the connection]
<phoe>
I've made a moptilities ticket for including that predicate. I think it's a good idea to add it there.
<Bike>
there's also a small possibility of other kinds of specializers. someone was working on that in sbcl i think.
<phoe>
Hm. Does MOP account for the possibility of other kinds of specializers?
<Bike>
it doesn't include a specializedp or anything
<Bike>
so, no, not meaningfully
<phoe>
I think I might safely treat these as very implementation-defined experimental stuff then.
pierpal has joined #lisp
<Bike>
yeah just thought i'd mention it
emaczen has joined #lisp
<eminhi>
Are there any style rules for using check-* and assert-* for naming? They are very visibly highlighted.
<phoe>
eminhi: a common rule I've found is to place them as high in function bodies as possible.
<phoe>
They are used for validation of function inputs, and are often also used as typechecks in modern implementations.
<phoe>
For instance, (defun foo (x) (check-type x integer) ...)
<phoe>
Or even (defun foo (x) (assert (typep x 'integer)) ...) that is very roughly equivalent to the former.
<phoe>
Type checks, I mean, uhh.
<phoe>
Type optimizations.
flazh has joined #lisp
<phoe>
The compiler can infer that if control reaches ..., it must have been because X was an integer, so it can generate code optimized for integers.
<fortitude>
phoe: AMOP has SPECIALIZER-DIRECT-METHODS/ADD-DIRECT-METHOD & co defined for specializer metaobjects
<fortitude>
which makes me think there is a protocol in there somewhere
<pfdietz>
Internally, SBCL uses "aver" instead of assert. The difference is assert has some baggage involving restarts that imposes an implementation overhead.
<phoe>
aver expands to more or less (unless test (error ...)), right?
<eminhi>
phoe: Yes, I've seen them mostly the first form in any &body code. Thanks.
<pfdietz>
I think. The condition had better be there so the compiler can propagate it forward.
<pfdietz>
(macroexpand '(sb-int:aver x)) ==> (if x nil (sb-impl::%failed-aver 'x))
<phoe>
eminhi: They are also used (or at least I use them) right after variable binding.
<phoe>
but, yes, basically, that's what you describe - first forms in &body code.
yvy has joined #lisp
kooga has joined #lisp
<Bike>
fortitude: there's not enough to use them widely. things in mop that are based on specializers are like that just so classes and eql specializers both work.
<pfdietz>
And sb-impl::%failed-aver has return type NIL, which means it cannot return, and the compiler takes advantage of that.
gurmble is now known as grumble
actuallybatman has quit [Ping timeout: 250 seconds]
<beach>
emaczen: How can I do that?
lmy9900 has joined #lisp
lmy9900 has quit [Client Quit]
Lycurgus has quit [Ping timeout: 268 seconds]
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
<emaczen>
beach: give me a second, I think it might be a option
frgo has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
yvy has quit [Read error: Connection reset by peer]
kajo has joined #lisp
<emaczen>
beach: I think you have to do it via a customization when you install SBCL
<emaczen>
If you read the INSTALL file at section 2.2
<emaczen>
there are --with and --without arguments to make.sh
<emaczen>
I did something similar a few months ago
<emaczen>
I can't remember 100% if it was just disabling the low level debugger or if it was completely removing immobile code
<emaczen>
You could probably search the IRC logs
mindCrime has quit [Ping timeout: 268 seconds]
Demosthenex has quit [Ping timeout: 268 seconds]
nowhere_man has joined #lisp
v0|d has quit [Ping timeout: 272 seconds]
shifty has joined #lisp
Demosthenex has joined #lisp
v0|d has joined #lisp
<dim>
can I loop maximizing the cdr of a cons and return the car of it?
<phoe>
I don't get it - return a list of CARs and maximizing the CDRs?