dddddd has quit [Remote host closed the connection]
xuxuru has quit [Quit: xuxuru]
Kundry_Wag has quit [Remote host closed the connection]
jasmith has joined #lisp
Josh_2 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
hhdave has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
subroot has joined #lisp
hhdave has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
anewuser has quit [Ping timeout: 260 seconds]
anewuser has joined #lisp
robotoad has quit [Quit: robotoad]
anewuser has quit [Read error: Connection reset by peer]
nicht has joined #lisp
nicht has quit [Max SendQ exceeded]
smasta has joined #lisp
light2yellow has quit [Quit: light2yellow]
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
subroot has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
k4rtik has joined #lisp
k4rtik has quit [Changing host]
k4rtik has joined #lisp
logicmoo has quit [Ping timeout: 240 seconds]
buffergn0me has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
dmiles has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag_ has joined #lisp
robotoad has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
jibanes has quit [Ping timeout: 240 seconds]
jibanes has joined #lisp
pierpa has quit [Quit: Page closed]
rumbler31 has quit [Remote host closed the connection]
smasta has quit [Quit: WeeChat 2.1]
smasta has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
fluke` has quit [Read error: Connection reset by peer]
fluke` has joined #lisp
Kundry_Wag has joined #lisp
EvW has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
karlosz has joined #lisp
<beach>
Good morning everyone!
Bike has quit [Quit: Lost terminal]
karlosz has quit [Ping timeout: 244 seconds]
skapata has quit [Remote host closed the connection]
karlosz has joined #lisp
pierpal has joined #lisp
<blep-on-external>
hello beach
<blep-on-external>
how do i get all the class slots of a class? i've tried sb-mop:class-slots but it doesn't have applicable methods for the symbol or an instance of the class
<beach>
blep-on-external: Either you have TABs in your code that pastebin can not handle, or you line starting with COLLECT is incorrectly indented.
jasmith has quit [Quit: Leaving]
k4rtik has joined #lisp
Kundry_Wag has joined #lisp
isospin has joined #lisp
raynold has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag_ has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
caltelt has quit [Ping timeout: 244 seconds]
k4rtik has quit [Ping timeout: 240 seconds]
kaun has joined #lisp
EvW1 has joined #lisp
daniel-s has joined #lisp
Kundry_Wag_ has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
brettgilio has quit [Quit: Leaving]
Kundry_Wag has quit [Ping timeout: 260 seconds]
kaun has quit []
pagnol has joined #lisp
Inline has quit [Quit: Leaving]
mooshmoosh has quit [Ping timeout: 244 seconds]
sauvin has joined #lisp
EvW1 has quit [Ping timeout: 240 seconds]
rippa has joined #lisp
mange has quit [Ping timeout: 268 seconds]
pagnol has quit [Ping timeout: 244 seconds]
Smokitch has joined #lisp
dcluna has quit [Read error: Connection reset by peer]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
dcluna has joined #lisp
brettgilio has joined #lisp
dmiles has quit [Ping timeout: 240 seconds]
dmiles has joined #lisp
brettg_ has joined #lisp
brettgilio has quit [Ping timeout: 240 seconds]
kerframil has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
k4rtik has joined #lisp
brettg_ has quit [Quit: Leaving]
vlatkoB has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
elfmacs has joined #lisp
robotoad has quit [Quit: robotoad]
Kundry_Wag has joined #lisp
k4rtik has quit [Ping timeout: 260 seconds]
<shrdlu68>
"In general, Common Lisp is a type-safe language. A Common Lisp compiler is responsible for inserting dynamic checks for operations whose type safety cannot be proven statically. However, a programmer may indicate that a program should be compiled with a lower level of dynamic type-checking." -- What does (safety 0) do?
nirved has joined #lisp
<shrdlu68>
Does it mean I won't get the usual "var is of type X, expecting type Y"?
<beach>
shrdlu68: Depends on the implementation.
<beach>
shrdlu68: Array bounds checks may be omitted.
SaganMan has quit [Ping timeout: 264 seconds]
<beach>
shrdlu68: It may believe you when you say something is a fixnum, and act accordingly.
<shrdlu68>
Hmm, meaning one could get a segfault?
<pillton>
The standard allows array bounds checks to be omitted at safety 3.
<beach>
Oh, definitely.
<beach>
pillton: Oh, OK.
<beach>
shrdlu68: Yes, definitely segmentation faults are possible.
<pillton>
"Except as explicitly specified otherwise, the consequences are undefined if these type restrictions are violated."
Kundry_Wag has quit [Ping timeout: 240 seconds]
<pillton>
The standard defines no exceptional situations for aref.
<beach>
Yeah, that surprises some people.
<pillton>
It surprised me. SBCL made me lazy.
<White_Flame>
also, a big ol' "In general," in the beginning of shrdlu68's quote leaves leeway there, too
<pillton>
Even using ELT on a list is unsafe.
<pillton>
"Should signal an error of type type-error if index is not a valid sequence index for sequence. "
flamebeard has joined #lisp
<pillton>
Anyway, what the standard allows and what sane people do are two different things.
<shrdlu68>
I should pay closer attention to exception types, never noticed array out of bounds exception was not standard.
<pillton>
Oh, I am not implying that the standard is insane.
<pillton>
Well, not all of it.
<pillton>
I digress.
<White_Flame>
sanity is relative to time frames. Pathnames, for instance, are kind of insane nowadays
<beach>
The purpose of WSCL is to clarify many such situations, like requiring errors to be signaled in safe code.
<pillton>
I must admit. I have never really understood the definition of safe code given clhs 1.4.4.3.
<beach>
Oh, you are putting too much interpretation into the word.
<beach>
The definition is that SAFETY is 3.
<beach>
It's like "simple" rewrite systems. There is nothing simple about them.
<pillton>
Well, that solves that mystery.
surya has joined #lisp
<pillton>
Thank you.
<beach>
Sure.
<beach>
But I understand what you feel. Hence WSCL.
SaganMan has joined #lisp
<shka_>
UB area is CL is large
<shka_>
writing portable code is not super easy
<shka_>
so, yeah, WSCL makes sense
brettgilio has joined #lisp
brettgilio has quit [Max SendQ exceeded]
makomo has joined #lisp
brettgilio has joined #lisp
makomo has quit [Client Quit]
makomo has joined #lisp
scymtym has joined #lisp
milanj has joined #lisp
<p_l>
Hmm, large UB? Anyone got a metric for that?
makomo has quit [Ping timeout: 240 seconds]
shrdlu68 has quit [Remote host closed the connection]
makomo has joined #lisp
Domaldel has joined #lisp
Domaldel has quit [Remote host closed the connection]
<akkad>
there is sbcl, and nothing else. portability a non-issue
<beach>
Hard to quantify of course, but it is probably worse than most people think after a casual read of the Common Lisp HyperSpec. But I am guessing it is not as bad as some languages like C.
shrdlu68 has joined #lisp
angavrilov has joined #lisp
<phoe>
akkad: d'oh, other implementations are used as well
mflem has quit [Read error: Connection reset by peer]
<jackdaniel>
what is awesome lisp? also, that is pretty dumb advice, unless provided as a simplified instruction for a real newbies.
<jackdaniel>
if we didn't care about portability, but "just write" for sbcl there wouldn't be a need for a standard and we'd be in a similar situation python or clojure are
<jackdaniel>
that is - specification defined by implementation
<phoe>
akkad: sbcl and ccl on x8664, ecl on android and abcl on JVMs
<jackdaniel>
clisp on minix3; ecl on haiku :)
<jackdaniel>
and lispworks on producation (that's what I've been told)
<jackdaniel>
;p getting back to my (hopefully portable) toys
nullman has quit [Ping timeout: 240 seconds]
vlatkoB has joined #lisp
brettgilio has quit [Quit: Leaving]
nullman has joined #lisp
SaganMan has quit [Ping timeout: 240 seconds]
makomo has quit [Ping timeout: 240 seconds]
buffergn0me has joined #lisp
Deknos has joined #lisp
shrdlu68 has joined #lisp
d4ryus1 is now known as d4ryus
chiyosaki has joined #lisp
saki has quit [Ping timeout: 260 seconds]
al-damiri has quit [Quit: Connection closed for inactivity]
hhdave has joined #lisp
<beach>
jackdaniel: The concept of a standard that is independent of implementations and of the organizations that supply implementations is pretty hard to grasp, especially these days, when single-implementation languages and benevolent-dictator languages are not only commonplace, but also used by industry projects that think of themselves as being serious.
chiyosaki has quit [Ping timeout: 244 seconds]
<jackdaniel>
I like to look at standards from the humanism standpoint
<jackdaniel>
I can imagine our civilization getting doomed; only printed standards and programs survived
<jackdaniel>
and some alien civilization recreating virtual machine to run our "heritage"
<jackdaniel>
of course I'm half-joking here, but looking at standards this way may help making the topic a little easier to grasp
<beach>
You have a vivid imagination. :)
trittweiler has joined #lisp
<jackdaniel>
thank you
shrdlu68 has quit [Ping timeout: 264 seconds]
<beach>
But, and I know I have said this before, for any industry project that thinks of itself as being serious, using a language with an independent standard is a must, or else they must take precautions and figure out what to do if the "language" they have chosen should disappear, quit being maintained, or be altered in some major way.
shrdlu68 has joined #lisp
<beach>
They might have to hire compiler experts then. And they probably don't even know where to find one, nor what to pay such a person.
hhdave has quit [Ping timeout: 244 seconds]
Deknos has left #lisp [#lisp]
hhdave has joined #lisp
<dim>
beach: what about companies using their own home-grown and home-steered projects/language, such as Google with Go or Mozilla with Rust (I think), or Oracle with Java?
<ebrasca>
They are big.
<beach>
dim: That's fine because they will then have hired people who are capable of maintaining that stuff.
<shka>
and not so smart if you ask me!
saki has joined #lisp
nowhere_man has joined #lisp
shrdlu68 has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
shifty has joined #lisp
<shrdlu68>
t/ex
shrdlu68 has quit [Client Quit]
<aeth>
akkad, jackdaniel: I find a good compromise between painful portability and no portability is to write for one implementation and then test it on one or two supported others. Technically, they could all violate the standard in the same way, but at least you're not tied to *one*
<aeth>
It's pretty easy to run on both SBCL and CCL. On the other hand, ABCL and CLISP are probably the hardest to support.
Folkol_ has quit [Ping timeout: 264 seconds]
<Cymew>
Aren't CLISP that old crap that should just go home and die?
<Cymew>
Hmm. "Isn't"
<aeth>
CLISP is... unusual. I think its fixnum is 48 bits. Its long float is arbitrary precision. etc.
<beach>
Cymew: What is the point of such utterances?
<aeth>
ABCL is more excusably unusual. It has to run on the JVM.
<aeth>
If you *really* want to be portable, test on them.
<dim>
I'm still missing the ABCL facility to create a .jar from a .asd
<Cymew>
beach: If that is the old implementation I'm thinking of, I think it is such a corner case that it can be disregarded for compatibility reasons.
<beach>
Cymew: That is no excuse for inflammatory phrases like your first one.
<Cymew>
I probably should have been clearer, yes.
<dim>
as soon as that's possible, I'll have a look at having pgloader.jar and also using JDBC on that platform, that'd be great really for supporting some commercial databases and other niche ones
<aeth>
Cymew: CLISP is the interpreted implementation that's semi-active (no new release in a long time, but not dead), but tons of resources from 2000-2010 recommended it so it'll live for a long time.
daniel-s has quit [Remote host closed the connection]
<White_Flame>
I don't recall CLISP ever being characterized as being incompatible
<aeth>
It's also possible that it'll be active again because it's not dead.
<White_Flame>
the 3 major things is that it's slower than native compiled implementations, it has fast bigmath, and it's easy to get running on new/unsupported platforms
<Cymew>
White_Flame: I have read descriptions of its implementation of CLOS to be very peculiar.
<beach>
Cymew: karlosz is in fact writing a Cleavir-based compiler for CLISP as a GSoC project.
<Cymew>
Interesting idea.
<aeth>
I'd say that the most annoying thing about CLISP is that it doesn't support single-float and double-float specialized arrays. When a specialized array isn't supported, you just get T arrays instead. *Tons* of libraries assume float arrays (or byte arrays) even though the standard only requires bit and character arrays. Those libraries will (slowly) run in CLISP, but without any sort of benefit in the type system.
<aeth>
Implementations with long-float (not just CLISP) also have an interesting issue with pi. pi is technically long-float, but in most implementations that's also a double-float so some people erronously assume pi is a double-float. So CLISP has the opposite issue there, where it supports something (long-float) that most popular implementations don't.
<aeth>
s/long-float/a long-float larger than a double-float/
<aeth>
(don't replace "pi is technically a long-float" with that substitution, though.)
<aeth>
(CLISP does support byte arrays, so I might have been unclear there. I was just saying that that's another thing libraries assume.)
BitPuffin has joined #lisp
<White_Flame>
as specialized vectors or simple arrays? :-P
<White_Flame>
that's a problem I keep hitting. Half the libs want specialized VECTOR, the other half want specialized SIMPLE-ARRAY
buffergn0me has quit [Ping timeout: 260 seconds]
<_death>
when I started learning lisp I used clisp on windows (and sbcl on linux) .. it was slow, but usable for many tasks.. it also has a small image size
<aeth>
White_Flame: a (simple-array single-float (*)) is a (vector single-float *) afaik (but not the other way around afaik)
<aeth>
_death: And there's the right answer for what you do NOT want to use SBCL for. When you need a small image size!
<_death>
it also has a nice manual
<White_Flame>
yeah, flexi-streams will build a vector for me, then I need to convert to simple-array to give it to the websocket lib
orivej has quit [Ping timeout: 260 seconds]
<_death>
flexi-streams has many faults.. some of them can be fixed without creating backwards compatibility issues, but that particular one I'm not sure
<aeth>
A simple-array is usually what you want if you even remotely care about performance (assuming you're not using one of the features that a nonsimple array has). It gives more guarantees as to the structure of the thing.
<aeth>
At least a 1D simple-array.
smasta has quit [Ping timeout: 256 seconds]
<White_Flame>
yep, I think a real failing of the spec is that simple-vector cannot be specialized
<White_Flame>
however, when you think about it, when you're dynamically building up a buffer from a stream, the backing data can't be simple
igemnace has quit [Remote host closed the connection]
<aeth>
Yes it can. You could e.g. just have a fixed size.
nowhere_man has quit [Remote host closed the connection]
<aeth>
You would need some way to communicate that it's only meaningful up to a certain index. A general library should probably just use the 2nd return value to do it, but I'd personally put it in a struct to store the value.
nowhere_man has joined #lisp
<aeth>
Obviously this is probably going to waste space (but also risk running out of space), but make things faster.
<aeth>
A tradeoff.
<White_Flame>
and re-copy to larger ones manually, or keep a chain of them, etc
<White_Flame>
because you don' tknow the size ahead of time
pagnol has joined #lisp
<White_Flame>
could be 16 bytes, could be 16MB
<aeth>
You could even have the user be in control
<aeth>
i.e. feed in the array, if it's too large, then allow the user to continue
<aeth>
So you as the user would be checking the 2nd return value
Smokitch has joined #lisp
Kundry_Wag has joined #lisp
<aeth>
s/if it's too large/if the data is too large for the array/
Kundry_Wag has quit [Ping timeout: 256 seconds]
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
chiyosaki has joined #lisp
saki has quit [Ping timeout: 268 seconds]
saki has joined #lisp
nowhere_man has quit [Remote host closed the connection]
kerframil has joined #lisp
nowhere_man has joined #lisp
cods has joined #lisp
froggey has quit [Ping timeout: 240 seconds]
froggey has joined #lisp
froggey has quit [Changing host]
froggey has joined #lisp
cods has quit [Changing host]
cods has joined #lisp
Smokitch has quit []
saki has quit [Ping timeout: 240 seconds]
_cosmonaut_ has joined #lisp
saki has joined #lisp
mrm is now known as l
l is now known as mrm
Smokitch has joined #lisp
lumm has joined #lisp
housel has quit [Remote host closed the connection]
housel has joined #lisp
elfmacs has quit [Ping timeout: 256 seconds]
Smokitch has quit []
igemnace has joined #lisp
xuxuru has joined #lisp
brettgilio has joined #lisp
<lthms>
hi
<beach>
Hello lthms.
<beach>
lthms: Are you new here? I don't recognize your nick.
<lthms>
I am indeed, I am here thanks to borodust
<beach>
Oh, OK.
<beach>
Welcome then.
<lthms>
thanks!
<White_Flame>
aeth: needing human involvement in a communications crossbar doesn't seem like the greatest idea...
<White_Flame>
"oh, I need to wait for the admin to notice the server's sldb window before my response gets returned"
xuxuru has quit [Quit: xuxuru]
<phoe>
Afternoon
Kundry_Wag has joined #lisp
<beach>
Hello phoe.
<phoe>
Hey beach - been a while.
<phoe>
I got sucked up by various things to do in life.
<phoe>
(again)
<beach>
Oh!
<beach>
Sorry to hear that (I guess).
<lthms>
i was wondering, has anyone here tried to write some async database code in common lisp? do you have anything to advice?
<phoe>
lthms: what kind of database do you mean?
<lthms>
anyone really, I don't have any strong opinion on the matter
<phoe>
beach: I'm alive, I just did things that I didn't really enjoy doing. The stuff that's required to function and such, but nothing really enjoyable.
varjag has joined #lisp
<phoe>
lthms: that's a pretty big question when it comes to choosing databases though; what are your needs? what kind of data will you store? what functionality for modifying and retrieving it will you need? how is your data modeled and structured?
<White_Flame>
lthms: threads, messages, just the same as any other language. Just make sure your DB connector library is threadsafe
<phoe>
because there are object stores in pure Lisp, there are bindings to various SQL and NoSQL databases out there.
<White_Flame>
lthms: depending on your workload, maybe put your requests into a job queue and have some fixed number of DB connections pulling from it
<White_Flame>
but again, that's no different in Lisp than any other language
<phoe>
well, yeah, I've been using postgres recently and it's just a matter of making ten connections to the database, and suddenly you can have ten DB queries running at once.
nowhere_man has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Ping timeout: 276 seconds]
<lthms>
phoe: which lib did you use to use postgres? I saw there are plenty
<phoe>
lthms: postmodern
<phoe>
I saw it used very commonly around here
brettgilio has quit [Remote host closed the connection]
<antoszka>
Yeah, I second postmodern.
brettgilio has joined #lisp
brettgilio has quit [Remote host closed the connection]
<lthms>
okay, I will try to have a look. Thanks!
<phoe>
lthms: no problem
<phoe>
ask us any questions you might have
markoong has joined #lisp
random-nick has joined #lisp
random-nick has quit [Remote host closed the connection]
random-nick has joined #lisp
vlatkoB_ has joined #lisp
random-nick has quit [Client Quit]
random-nick has joined #lisp
random-nick has quit [Read error: error:1408F10B:SSL routines:SSL3_GET_RECORD:wrong version number]
vlatkoB has quit [Ping timeout: 265 seconds]
random-nick has joined #lisp
housel has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 244 seconds]
quazimodo has joined #lisp
raynold has quit [Quit: Connection closed for inactivity]
Smokitch has joined #lisp
kerframil has left #lisp ["Leaving"]
pagnol has quit [Ping timeout: 260 seconds]
AetherWind has quit [Quit: Leaving]
SaganMan has joined #lisp
mathrick has quit [Ping timeout: 276 seconds]
random-nick has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
<loke>
ebrasca: cat?
<loke>
You want to cat the first 10 bytes of /dev/sdc?
<ebrasca>
How to read files like /dev/sdc1 or /dev/random with pure common lisp?
<loke>
ebrasca: What you did should work
<loke>
it doesn/t
<loke>
?
<ebrasca>
#<SB-SYS:FD-STREAM for "file /dev/sdc1" {10052C9813}> is not a binary input stream.
<ebrasca>
I like to make my fat32 portable.
<loke>
ebrasca: (with-open-file (s #p"..." :element-type '(unsigned-byte 8)) ...)
Kundry_Wag has joined #lisp
<ebrasca>
loke: Thank you.
Kundry_Wag has quit [Ping timeout: 265 seconds]
varjag has quit [Ping timeout: 276 seconds]
ebrasca has quit [Ping timeout: 244 seconds]
milanj has joined #lisp
ebrasca has joined #lisp
brettgilio has joined #lisp
nowhere_man has joined #lisp
varjag has joined #lisp
shrdlu68 has joined #lisp
angular_mike_ has quit []
varjag has quit [Ping timeout: 260 seconds]
elfmacs has joined #lisp
shrdlu68 has quit [Ping timeout: 248 seconds]
brettgilio has quit [Remote host closed the connection]
angular_mike_2 has joined #lisp
random-nick has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
pagnol has joined #lisp
random-nick has joined #lisp
shrdlu68 has joined #lisp
jmercouris has joined #lisp
<jmercouris>
I'm trying to take a long string, and split it into stringths of a max length, but only at word boundaries
<jmercouris>
so something like "this is a very long string" could split at "a"
pierpal has quit [Quit: Poof]
<jmercouris>
rather than splittin in between "ve" and "ry" from "very"
<jmercouris>
s/splittin/splitting
pierpal has joined #lisp
<jmercouris>
any lib anyone know of? or will I have to implement this?
Posterdati has quit [Ping timeout: 265 seconds]
<Xach>
jmercouris: i don't know of a public library
<jmercouris>
Interestingly enough, I am asking because I want to make "pargraphs" of text in Vecto
<Xach>
I have done that so many times for my graphics toys.
<jmercouris>
Do you have a snippet you can share?
igemnace has quit [Ping timeout: 260 seconds]
<Xach>
The general strategy I use is to categorize characters as breakable, then add words, and when a threshold is reached, go back to the last breakable character.
<TMA>
jmercouris: if it is meant for human consumption, I recomend you to look up the algorithm used in TeX.
<Xach>
So a space is breakable, in some contexts a hyphen is breakable
<jmercouris>
TMA: it is meant for humans, but not really, it is just a legal requirement, nobody reads it
<dlowe>
I managed to work that out for a tiny irc client I wrote. I needed something to break long titles in a tooltip
<dlowe>
antoszka: bugs :D
<antoszka>
ah
<dlowe>
nothing, actually
<dlowe>
(?: starts a non-capturing group
<dlowe>
(?= is a positive lookahead
<dlowe>
The main work is done by .{0,79}(?=\s+|$) which says, basically, any number of characters up to 79 which is followed by a space or end of line.
stnutt has quit [Ping timeout: 260 seconds]
acolarh has quit [Ping timeout: 240 seconds]
stnutt has joined #lisp
brettgilio has quit [Quit: Leaving]
<jackdaniel>
mm, regexp
thuffir has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
stnutt has quit [Ping timeout: 276 seconds]
orivej has joined #lisp
stnutt has joined #lisp
Folkol_ has joined #lisp
acolarh has joined #lisp
stnutt has quit [Ping timeout: 260 seconds]
warweasle has joined #lisp
stnutt has joined #lisp
<dlowe>
\S{0,79} captures the case where there wasn't any space, so it just breaks it at the boundary
patlv has joined #lisp
Inline has joined #lisp
Posterdati has joined #lisp
kajo has quit [Ping timeout: 240 seconds]
karlosz has joined #lisp
PinealGlandOptic has quit [Quit: leaving]
isospin has left #lisp ["ERC (IRC client for Emacs 26.1)"]
_cosmonaut_ has joined #lisp
sjl_ has joined #lisp
karlosz has quit [Quit: karlosz]
kuwze has joined #lisp
pagnol has quit [Ping timeout: 240 seconds]
patlv has left #lisp ["Leaving"]
pfdietz has quit []
surya_ has quit [Remote host closed the connection]
crsc has joined #lisp
elfmacs has quit [Ping timeout: 240 seconds]
jmercouris has quit [Remote host closed the connection]
jmercouris has joined #lisp
Folkol_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jmercouris>
how can I do (loop for item in list do ...) and also have an index? e.g. a count of how many elements I've iterated?
<jmercouris>
is there something in the loop macro, or do I need a separate counter?
flamebeard has quit []
<beach>
(loop for item in list for index from 0 do...)
<jmercouris>
Thanks
<beach>
Sure.
<jmercouris>
I literally just figured it out just before you said it
<jmercouris>
I didn't realize that you could have multiple for clauses
<TMA>
jmercouris: add another for clause: (loop for i in '(a b c) for j from 1 collect (cons i j))
<jmercouris>
and you know this because of this line: [name-clause] {variable-clause}* {main-clause}*?
<beach>
jmercouris: Yes.
<jmercouris>
because the * means 0 or more
<beach>
No, because main-clause follows variable-clause in the order.
<beach>
The order is important unless the notation is used that says it isn't.
<beach>
Standard BNF again.
<jmercouris>
Yes, yes
<jmercouris>
Sorry my thoughts weren't well formed
<jmercouris>
but Yes, I get it
<jmercouris>
and then a main clause can be composed of: main-clause::= unconditional | accumulation | conditional | termination-test | initial-final ?
<jmercouris>
which are then also defined below
<beach>
You got it.
<jmercouris>
Aha, I got it indeed
<jmercouris>
Okay, I finally know how to read this page
<beach>
Great!
<jmercouris>
only about 16 or so months in :D
<jmercouris>
maybe less, not sure
<jmercouris>
Thank you!
<beach>
Anytime.
<beach>
I consider it an investement.
<beach>
investment
<jmercouris>
Maybe I'll write a blog post then :P
<jmercouris>
perhaps help some others who have no idea what that stuff means
thuffir has joined #lisp
Smokitch has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
scymtym_ has joined #lisp
jack_rabbit has quit [Quit: Leaving]
<beach>
The latter point was what I was referring to.
k4rtik has quit [Ping timeout: 240 seconds]
<jmercouris>
gotcha, it is good at least that there is a chat log to persist some domain knowledge
<jmercouris>
even if other publications are never made
scymtym has quit [Ping timeout: 276 seconds]
<beach>
I guess so. In this case, though, there is no additional information compared to the Common Lisp HyperSpec.
FreeBirdLjj has joined #lisp
fikka has joined #lisp
<beach>
YAY! My Common Lisp implementation of Doug Lea's allocator algorithm just passed the test consisting of 10 million randomly generated ALLOCATE and FREE operations.
thuffir has quit [Ping timeout: 240 seconds]
<shka>
beach: goooooooooood
<beach>
I use two basic operations, one for reading a memory location and one for writing a memory location. In the test, I am simulating those operations by reading and writing to a Common Lisp vector.
<beach>
In a real system, those would be replaced by special operators that actually read and write memory.
<beach>
So much for the idea that it is impossible to write memory allocators, garbage collectors, etc., in Common Lisp.
DingoSaar has joined #lisp
<zigpaw>
I wonder how lisp machines had gc implemented?
<beach>
I am guessing in a similar way. They must have had Lisp function able to access raw memory.
<beach>
But the GC technique they used was not great if I understand things right.
<beach>
There has been considerable progress in garbage collection since, mainly thanks to Java.
<shka>
it was 80s
<shka>
don't expect to much
<beach>
I think I read somewhere that it was faster to reboot than to wait for the GC.
<shka>
impossible
<shka>
lisp machines took forever to boot
<beach>
I guess I must be misremembering then.
robotoad has joined #lisp
josemanuel has joined #lisp
edgar-rft has joined #lisp
MoziM has quit [Quit: WeeChat 2.1]
MoziM has joined #lisp
ravndal has quit [Quit: WeeChat 2.1]
ravndal has joined #lisp
nimiux_ has quit [Ping timeout: 244 seconds]
lumm_ has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
lumm has quit [Ping timeout: 256 seconds]
joast has quit [Quit: Leaving.]
lumm_ is now known as lumm
nimiux has joined #lisp
pagnol has joined #lisp
karlosz has joined #lisp
thuffir has joined #lisp
Achylles has joined #lisp
housel has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
<phoe>
sigh
mathrick has joined #lisp
Achylles has quit [Remote host closed the connection]
thuffir has quit [Ping timeout: 240 seconds]
<phoe>
I wanted to chain individual tasks together into a bigger flow
<phoe>
And I ended up yak shaving a separate library for that
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
nowhere_man has quit [Ping timeout: 260 seconds]
joast has joined #lisp
jasom has quit [Ping timeout: 245 seconds]
jasom has joined #lisp
skapata has joined #lisp
eli_oat has joined #lisp
pagnol has quit [Ping timeout: 244 seconds]
k4rtik has joined #lisp
pseudonymous_ has joined #lisp
FreeBirdLjj has joined #lisp
karlosz has quit [Quit: karlosz]
thuffir has joined #lisp
pjb has joined #lisp
zmt00 has joined #lisp
fikka has joined #lisp
swampflared has quit [Ping timeout: 256 seconds]
FreeBirdLjj has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 244 seconds]
mflem has joined #lisp
igemnace has joined #lisp
jmercouris has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
thuffir has quit [Ping timeout: 240 seconds]
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
zmt01 has joined #lisp
raynold has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
zmt00 has quit [Ping timeout: 240 seconds]
jmercouris has joined #lisp
swampflared has joined #lisp
zmt01 has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
hhdave has quit [Ping timeout: 268 seconds]
shka_ has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
zmt01 has joined #lisp
cage_ has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
bjorkintosh has joined #lisp
swampflared has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
thuffir has joined #lisp
jmercouris has quit [Remote host closed the connection]
Tristam has quit [Ping timeout: 264 seconds]
FreeBirdLjj has joined #lisp
Tristam has joined #lisp
Tristam has quit [Excess Flood]
Tristam has joined #lisp
silverbeard00 has joined #lisp
m00natic has quit [Remote host closed the connection]
thuffir has quit [Ping timeout: 240 seconds]
Kaisyu has quit [Quit: Connection closed for inactivity]
silverbeard00 has quit [Quit: BitchX-1.2.1-377-gd4c6123 -- just do it.]
milanj has quit [Quit: This computer has gone to sleep]
graphene has quit [Read error: Connection reset by peer]
graphene has joined #lisp
thuffir has joined #lisp
thuffir has quit [Ping timeout: 260 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
milanj has joined #lisp
thuffir has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
thuffir has quit [Ping timeout: 260 seconds]
thuffir has joined #lisp
kaun has joined #lisp
j0ni has joined #lisp
graphene has quit [Read error: Connection reset by peer]
lumm_ has joined #lisp
graphene has joined #lisp
PJ_ has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
zooey has quit [Remote host closed the connection]
varjag has joined #lisp
zooey has joined #lisp
lumm has quit [Ping timeout: 240 seconds]
lumm_ is now known as lumm
fikka has quit [Ping timeout: 264 seconds]
pierpal has joined #lisp
<PJ_>
I am considering learning common lisp, as I really like the lisp paradigm. However, I am starting to do a lot more high-level GPU work, what are the recommended GPU options for common lisp that are readily maintained? Also is openacc a possibility?
<stacksmith>
CEPL if you are talking about rendering...
<PJ_>
not really rendering, ie not gaming/images etc. More compute on the GPU, linear algebra and other big compute
thuffir has quit [Ping timeout: 260 seconds]
<TMA>
PJ_: you need to use GPU driver libraries that have C (or C++) in mind. anything else is an uphill battle -- and that includes the popular python bindings for the machine learning on GPU
kuwze has quit [Ping timeout: 252 seconds]
<PJ_>
@TMA thanks, that seems to be my main barrier to entry. Currently doing a lot of deeplearning, machine learning and general data analysis in python. This is great, but I would like to
<TMA>
PJ_: it can be done in common lisp, the interactive development is certainly great, but it has its cost too
<PJ_>
use the expressiveness of lisp in some cases. Dabbled in clojure and I liked the lisp way :), but GPUs are becoming more and more prevalent.
lumm has quit [Ping timeout: 240 seconds]
pagnol has joined #lisp
<TMA>
PJ_: nowadays it is similar to the driver support early this century: if you wanted to use the hardware, you had to use microsoft windows or write your own. today the gpu support for non-c/c++ languages is the same: write your own;; it has been done already, but do not expect mainstream-level support available
blackwolf has joined #lisp
<phoe>
Is there a SET-SUM function anywhere? Something that's an analogue of SET-DIFFERENCE.
<phoe>
(set-sum '(1 2 3) (2 3 4)) ;=> (1 2 3 4)
<phoe>
Something perhaps more efficient than REMOVE-DUPLICATES APPEND.
<phoe>
I was thinking that it would be named SET-UNION for some reason.
thuffir has joined #lisp
_cosmonaut_ has quit [Ping timeout: 240 seconds]
<pjb>
PJ_: have a look at cl-cuda.
<pjb>
phoe: it's called UNION !
<pjb>
and of course, there's also INTERSECTION.
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<pjb>
phoe: that said, if you want more efficiency, use bit-vectors or integers.
<pjb>
(logior #b0111 #b1110) #| --> 15 |# and (bit-ior #*0111 #*1110) #| --> #*1111 |# are basically O(1).
<PJ_>
@pjb cl-cuda looks great, it does seem more lower level though, if there isn't a higher level alternative, then it seems that may be the way to go. Just more stuff to learn :)
<phoe>
I have a graph described by a list of edges. Which library-and-function should I use to check if the graph contains cycles?
<phoe>
Oh right, the graph's directed.
varjagg is now known as varjag
thuffir has joined #lisp
lumm has joined #lisp
<kaun>
Can the runtime detect trivial cycles in a linked list?
<phoe>
kaun: what do you mean, runtime?
<phoe>
And what do you mean, trivial cycles?
<jasom>
PJ_: you may also consider looking at clasp, which was specifically designed for allowing lisp to drive C++ libraries (I've not used it myself though)
<kaun>
noob here, so, I assumed you can build a circular list using cons.
<pjb>
err, I'm wrong, find-cycles uses find-shortest-path, not topological-sort.
<pjb>
kaun: but phoe meant just graphs ;-)
<kaun>
doing a circular buffer with wrap-around
<kaun>
i was riffing off his question.
<pjb>
(cl:list-length '(a b . #1=(c d e))) #| --> 5 |# (com.informatimago.common-lisp.cesarum.list:list-lengths '(a b . #1=(c d e))) #| --> 5 ; 0 |#
<kaun>
his/her, sorry.
<pjb>
(cl:list-length '(a b . #1=(c d e . #1#))) #| --> nil |# (com.informatimago.common-lisp.cesarum.list:list-lengths '(a b . #1=(c d e . #1#))) #| --> 2 ; 3 |#
random-nick has quit [Ping timeout: 244 seconds]
<pjb>
so you may prefer list-lengths, if you need to know where the cycle begins, and how long it is.
<kaun>
ok. cool, thanks.
<pjb>
phoe: it will depend on whether you want to find the cycles, or just to know if there are some.
NoNumber has left #lisp ["ERC (IRC client for Emacs 25.2.2)"]
<pjb>
slyrus: keep reading and try: (if (let ((match (match-re …))) (report-match match) (setf match (find-next match)) match) (do-it)) ;-)
thuffir has quit [Ping timeout: 244 seconds]
<pjb>
slyrus_: python is just broken, they will have to write PEP forever.
<pjb>
Who would have believed they already have more than 572 of them!?!?
<pjb>
The max PEP number is 3333. There are only 972 symbols exported from CL!
jeosol has joined #lisp
<pjb>
(there are holes, but still).
<pjb>
And they dare call it a language for beginners!
<shka_>
python is weirdly designed
nowhere_man has joined #lisp
<shka_>
not sure if it is actually designed
thuffir has joined #lisp
<dlowe>
are you referring to Python, the excellent compiler for Common Lisp?
k4rtik has quit [Ping timeout: 276 seconds]
gector has quit [Read error: Connection reset by peer]
<dlowe>
because that's on topic :p
<shka_>
eeeeee no
<jeosol>
morning guys
<shka_>
besides there was no compiler of common lisp called python as far i can tell
<shka_>
because there was no common lisp back then
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
nickenchuggets has joined #lisp
<dlowe>
the cmucl native code compiler is called Python
fikka has joined #lisp
<dlowe>
far preceding other popular uses
<shka_>
oh, ok
<jeosol>
is anyone here running a cl-web application with multiple users (requiring management of user permissions, control access, etc)? there is a preference for django but I will prefer CL is possible. This is will be production use.
<shka_>
jeosol: cl-web is some sort of framework?
<jeosol>
I wanted to consult the oracle before proposing anything ... :-)
<jeosol>
btw, I know of caveman2 and radiance
<dlowe>
jeosol: Reply hazy. Try again later.
<shka_>
didn't use caveman2 myself, radiance is cool
<dlowe>
jeosol: j/k
<jeosol>
shka_: thanks.
<jeosol>
would prefer an option that would handle a complicated piece of backend software.
fikka has quit [Ping timeout: 244 seconds]
<sukaeto>
I've been pretty happy with caveman2
orivej has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
<jeosol>
sukaeto: thanks for the input. Are you using this in some type production code?
<sukaeto>
jeosol: yes
<sukaeto>
it's an internal tool, so it doesn't have a ton of users
<sukaeto>
but it holds up quite nicely
<sukaeto>
since it's easy to use different backends with clack, it makes development convenient
<sukaeto>
you can just start a background thread using hunchentoot in your REPL, but set up workers using fcgi in prod
orivej has joined #lisp
thuffir has quit [Ping timeout: 264 seconds]
random-nick has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Smokitch has quit []
EvW has quit [Ping timeout: 240 seconds]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
sjl_ has quit [Ping timeout: 260 seconds]
<jeosol>
sakaeto: ok, it's the "setting workers piece" I'll need to learn/get into.
<jeosol>
also good to know caveman2 hold's nicely for your case.
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
makomo has joined #lisp
shka_ has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
sjl_ has joined #lisp
sendai_ has joined #lisp
DingoSaar has quit [Remote host closed the connection]
DingoSaar has joined #lisp
FreeBirdLjj has joined #lisp
azimut has quit [Ping timeout: 268 seconds]
<aeth>
White_Flame: Not human involvement at runtime, human involvement at programmer time. I meant the user of the library, not the user of the program.
hph^ has quit [Remote host closed the connection]
hph^ has joined #lisp
hph^ has quit [Max SendQ exceeded]
hph^ has joined #lisp
hph^ has quit [Max SendQ exceeded]
hph^ has joined #lisp
hph^ has joined #lisp
hph^ has quit [Max SendQ exceeded]
MoziM has quit [Ping timeout: 260 seconds]
hph^ has joined #lisp
hph^ has quit [Max SendQ exceeded]
FreeBirdLjj has quit [Ping timeout: 265 seconds]
MoziM has joined #lisp
DingoSaar has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
k4rtik has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
scymtym_ has quit [Ping timeout: 240 seconds]
vlatkoB_ has quit [Remote host closed the connection]