jfrancis has quit [Remote host closed the connection]
<black_13>
because I want to write for customer who use windows
jfrancis has joined #lisp
<black_13>
pillton: why do people like you do what you do?
<pillton>
What did I do?
jfrancis has quit [Ping timeout: 240 seconds]
<black_13>
i say i need x and you say why not abandon x and you choose y
<black_13>
i like linux but ...
<pillton>
CFFI works from ECL. CFFI allows you to load a shared object library and invoke functions inside it.
terpri has joined #lisp
<black_13>
in windows
<black_13>
?
<pillton>
Which, in my opinion, satisfies "foreign in a dll from ecl".
<black_13>
excelsior
<pillton>
What does "excelsior" mean?
<pillton>
black_13: I have used CFFI on windows to invoke foreign functions. The only thing that I haven't done is tried cffi:load-foreign-library on windows.
<duncan_bayne>
Possibly stupid question: is there an idiomatic way of accessing data in lists that are neither alists nor plists? Specifically, in the form: '(("Name" ("first" "Duncan" "last" "Bayne")) ("Phone" ("area" "01" "number" "123456")))
<White_Flame>
you can generally use FIND for custom cases, but many of these functions have :key or :test style optional parameters to configure what you want
<White_Flame>
of course, each nested layer will require another application of FIND
<White_Flame>
(or whichever function you use)
<White_Flame>
there generally isn't a single function for deep traversal using multiple keys
<White_Flame>
but that's what DEFUN is for ;)
uberman has joined #lisp
uberman has quit [Max SendQ exceeded]
uberman has joined #lisp
<White_Flame>
the Alexandria library has WHEN-LET* which allows you to cascade multiple forms, continuing if each step yields non-NIL
<White_Flame>
that's often handy for writing deep traversals
<duncan_bayne>
White_Flame: thanks - that was the sanity-check I needed, I'm new to CL and was afraid I was missing something. Happy to roll my own here
<duncan_bayne>
Just didn't want to reinvent the wheel :)
<beach>
duncan_bayne: It *IS* an alist.
<beach>
No need to roll your own.
<White_Flame>
yes, for ("Name" ("first" "Duncan" "last" "Bayne")), the CAR is "Name" and the CDR is (("first" "Duncan" "last" "Bayne"))
<White_Flame>
so it's fully compatible with a-list functions
<White_Flame>
also, to be more idiomatic, you should probably use symbols, like (:first "Duncan" :last "Bayne") or something
<White_Flame>
also also, there's #clnoobs which is more appropriate for learning the basics
varjagg has joined #lisp
<duncan_bayne>
Right I'll head off to #clnoobs, because my attempts to use a-list functions on that structure have so far been failures
<duncan_bayne>
Thanks :)
<beach>
duncan_bayne: Probably because you didn't supply the :test keyword argument.
<beach>
duncan_bayne: But I showed it to you in my example.
<pillton>
What is the difference between #lisp and #clnoobs?
<White_Flame>
#lisp is easier to find/guess
phenoble has joined #lisp
slyrus1 has joined #lisp
* beach
is not sure why he is ignored by duncan_bayne.
<pillton>
You are too nice.
varjagg has quit [Ping timeout: 260 seconds]
<beach>
Hmm.
<duncan_bayne>
beach: Sorry, didn't mean to be ignoring you, have been looking into your example
<pillton>
Maybe lisp is like coffee baristas. You need to find the really old and grumpy baristas to get a good coffee.
<jackdaniel>
black_13: like any other foreign function. I'd use cffi, but ffi interfaces are documented too (ECL's FFI has an API defined in UFFI)
flamebeard has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
d4ryus1 is now known as d4ryus
<jackdaniel>
black_13: if you have doubts, you may want to see examples/ directory
<jackdaniel>
fyi all examples are BSD-licensed, so you may freely use them
<jackdaniel>
without any serious license implications
karlosz has quit [Ping timeout: 252 seconds]
<jackdaniel>
(rest of the ECL is licensed under LGPL-2.1+0
xaotuk has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 252 seconds]
MickyD has quit [Remote host closed the connection]
<White_Flame>
if your keys were symbols, then you wouldn't need to override :test
<duncan_bayne>
White_Flame: yes; this list is being returned by a library that is deserializing it from JSON
<White_Flame>
ah
<White_Flame>
the library might also have transforms that it can apply to object keys, where you could intern the strings into symbols, preferrably changing their case to Lisp default
<flip214>
so it should be (:phone (:area "01" :number "123456"))
Kundry_Wag has quit [Ping timeout: 240 seconds]
<duncan_bayne>
flip214: yes, because the assoc example provided by beach returns a list of strings, which doesn't play nice with getf
<black_13>
if had a function "void foo(void);" defined in a .dll and had normal exports and this was built using visual studio how would i call
<jackdaniel>
do you expect me to read the documentation for you?
<jackdaniel>
first you load the library (see cffi's doc) then you call defcfun (see cffi doc)
jason_m has joined #lisp
<jackdaniel>
(defcfun "foo" :void) ; should create function foo which could be called like CL-REPL> (foo)
<black_13>
thanks
igemnace has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<black_13>
the docs are terse and opaque when first look a them
jason_m has quit [Client Quit]
<jackdaniel>
often another good resource on how to use things is reading tests/ or examples/
klm2is has joined #lisp
<black_13>
you mean in the ecl sources
FreeBirdLjj has joined #lisp
<black_13>
how do you compile the these from msvc
<black_13>
these from msvc
eli_oat has joined #lisp
<jackdaniel>
I mean cffi sources or any library you want to use
<jackdaniel>
compilation from msvc is covered in documentation
eli_oat has quit [Client Quit]
FreeBirdLjj has quit [Ping timeout: 252 seconds]
<jackdaniel>
while I understand that reading documentation may be a demanding task for various reason, that's why documentation is written - so a person who wrote it doesn't have to explain things over and over again
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
palmtree has joined #lisp
palmtree has quit [Client Quit]
fikka has joined #lisp
<black_13>
its funny a couple days ago I though what great guy who did ecl
<black_13>
but your really a jerk
wheelsucker has quit [Remote host closed the connection]
damke has joined #lisp
xaotuk has joined #lisp
matijja has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 248 seconds]
schjetne has quit [Remote host closed the connection]
black_13 has quit [Quit: Page closed]
LiamH has joined #lisp
<jackdaniel>
it's not a nice thing to say
octobanana has quit [Read error: Connection reset by peer]
Princess17b29a has quit [Quit: ZNC 1.6.3+deb1 - http://znc.in]
<jackdaniel>
but at least someone *thought* I'm a nice guy :)
pierpal has quit [Ping timeout: 240 seconds]
zaquest has quit [Quit: Leaving]
<heisig>
black_13: You are not being polite. jackdaniel is actually a great guy.
fikka has joined #lisp
<dlowe>
people come to help on IRC because a) they want to know something they can't find in the manual, b) they don't want to read the manual, c) they need emotional support while trying to use your thing
<jackdaniel>
thanks heisig :)
zaquest has joined #lisp
Kundry_Wag has joined #lisp
Bike has joined #lisp
kmurphy4 has joined #lisp
pierpal has joined #lisp
<TMA>
If insults are to be meted out, it shall be done with dignity, style and proper grammar.
Kundry_Wag has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 252 seconds]
zaquest has quit [Remote host closed the connection]
LiamH has quit [Ping timeout: 256 seconds]
zaquest has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
nowhere_man has joined #lisp
zaquest has quit [Remote host closed the connection]
karswell has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
karswell_ has joined #lisp
LiamH has joined #lisp
jmercouris has joined #lisp
zaquest has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
siraben has joined #lisp
warweasle has joined #lisp
mindCrime has joined #lisp
mindCrime has quit [Remote host closed the connection]
mindCrime has joined #lisp
terpri has quit [Ping timeout: 248 seconds]
pierpal has joined #lisp
matijja has joined #lisp
xificurC has joined #lisp
mooog has joined #lisp
AetherWind has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
damke has joined #lisp
pierpal has joined #lisp
tomsen has quit [Ping timeout: 276 seconds]
damke_ has quit [Ping timeout: 252 seconds]
BitPuffin has joined #lisp
foom2 has joined #lisp
AetherWind has quit [Quit: IRC for Sailfish 0.9]
__rumbler31 has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
SenasOzys has joined #lisp
foom has quit [Ping timeout: 260 seconds]
Guest53120 has quit [Remote host closed the connection]
foom2 is now known as foom
jmercouris has quit [Ping timeout: 240 seconds]
foom is now known as foom2
foom2 is now known as foom
jmercouris has joined #lisp
mooog has quit [Ping timeout: 264 seconds]
plertrood has joined #lisp
jfrancis has joined #lisp
milanj has joined #lisp
deng_cn has quit [Remote host closed the connection]
deng_cn has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
tomsen has joined #lisp
oleo has joined #lisp
plertrood has quit [Quit: ERC (IRC client for Emacs 26.1)]
oleo is now known as Guest75639
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
heisig has quit [Quit: Leaving]
Arcaelyx has joined #lisp
Guest75639 is now known as stormy
stormy is now known as reaper
reaper is now known as pepper
cage_ has joined #lisp
pepper is now known as clim
mindCrime has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
orivej has joined #lisp
clim is now known as omicron
omicron is now known as lambda
lambda is now known as golden_ratio
makomo has joined #lisp
__rumbler31 has quit [Ping timeout: 264 seconds]
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
dyelar has joined #lisp
jmercouris has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
makomo has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 256 seconds]
tylerdma1e has quit [Ping timeout: 260 seconds]
jmercouris has joined #lisp
Cymew has joined #lisp
dyelar has quit [Quit: Leaving.]
matijja has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
_cosmonaut_ has quit [Ping timeout: 260 seconds]
priyadarshan has joined #lisp
nika_ has joined #lisp
Cymew has quit [Ping timeout: 276 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
himmAllRight has quit [Ping timeout: 256 seconds]
himmAllRight has joined #lisp
fikka has joined #lisp
lumm has quit [Quit: lumm]
lnostdal has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 252 seconds]
rumbler31 has quit [Remote host closed the connection]
lnostdal has joined #lisp
igemnace has quit [Quit: WeeChat 2.1]
SenasOzys has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
johnvonneumann has joined #lisp
johnvonneumann is now known as Guest10566
schweers has quit [Ping timeout: 240 seconds]
SenasOzys has joined #lisp
fikka has joined #lisp
lnostdal has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 260 seconds]
slyrus2 has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
fikka has joined #lisp
beginner_supreme has joined #lisp
<beginner_supreme>
Hey all, curious if high-performance compilers create contiguous objects when given element-type, so for (make-array n :element-type some-object/struct), the rough equivalent in C would be: malloc(n * sizeof(some-object/struct));
Tristam has quit [Ping timeout: 256 seconds]
Tristam has joined #lisp
<beginner_supreme>
Is this sort of contiguous allocation done at all for these types of expressions (not just for arrays) or are only pointers contiguous, having an extra indirection
smurfrobot has joined #lisp
warweasle has quit [Quit: be back later]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<copec>
I'm not sure if all compilers do, but the presumption is that you are giving it sufficient information so that it can.
<stylewarning>
beginner_supreme: in Common Lisp, usually will not be allocated necessarily like that
<beginner_supreme>
But I wonder how it is in real implementations...
<copec>
If you have reached a point that that is important enough, I would consult the specific implementation docs and/or source
<beginner_supreme>
Oh I see
Khisanth has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Remote host closed the connection]
<stylewarning>
beginner_supreme: it'll be more like: void **array = malloc(n * sizeof (void *))
<stylewarning>
beginner_supreme: followed by n allocations of the objects, which will inadvertently be contiguous
<stylewarning>
(but they may not remain contiguous
SenasOzys has joined #lisp
ircleuser has joined #lisp
<beginner_supreme>
I see, alright then
capisce has joined #lisp
ebrasca` has joined #lisp
minion has quit [Disconnected by services]
minion has joined #lisp
sword```` has joined #lisp
aindilis` has joined #lisp
kmurphy4_ has joined #lisp
<beginner_supreme>
For the future, are such inquiries suitable for this channel or must I refer them to #clnoobs?
grumblr has joined #lisp
pierpal has quit [Ping timeout: 248 seconds]
<copec>
I think you're okay either way beginner_supreme
himmAllRIght17 has joined #lisp
<beginner_supreme>
Okay cool
uint_ has joined #lisp
lnostdal has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
<copec>
I tend to ask in clnoobs first, and reflect the question in here or one of the other CL channels if I can't get an answer. There are some pretty knowledgable people in there though, it's not newb on newb action
damke_ has joined #lisp
Folkol has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
jmercouris has quit [Ping timeout: 240 seconds]
ioa_ has joined #lisp
megalography has quit [Ping timeout: 260 seconds]
_krator44- has joined #lisp
himmAllRight has quit [*.net *.split]
damke has quit [*.net *.split]
MichaelRaskin has quit [*.net *.split]
kmurphy4 has quit [*.net *.split]
trittweiler_ has quit [*.net *.split]
capisce_ has quit [*.net *.split]
aindilis has quit [*.net *.split]
sword``` has quit [*.net *.split]
Guest80598 has quit [*.net *.split]
ioa has quit [*.net *.split]
uint has quit [*.net *.split]
ebrasca has quit [*.net *.split]
oldtopman has quit [*.net *.split]
_krator44 has quit [*.net *.split]
eschatologist has quit [*.net *.split]
grumble has quit [*.net *.split]
alandipert has quit [*.net *.split]
kmurphy4_ is now known as kmurphy4
pierpal has joined #lisp
eschatologist has joined #lisp
grumblr is now known as grumble
alandipert has joined #lisp
giraffe has joined #lisp
giraffe is now known as Guest23105
makomo has joined #lisp
vlatkoB has quit [Remote host closed the connection]
dented42 has joined #lisp
SenasOzys has quit [Ping timeout: 260 seconds]
gravicappa has joined #lisp
vlatkoB has joined #lisp
Kyo91` has quit [Ping timeout: 248 seconds]
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
oldtopman has joined #lisp
trittweiler_ has joined #lisp
SenasOzys has joined #lisp
Khisanth has joined #lisp
damke_ has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
innovati has joined #lisp
karswell_ has quit [Remote host closed the connection]
terpri has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
al-damiri has joined #lisp
megalography has joined #lisp
DemolitionMan has joined #lisp
<White_Flame>
beginner_supreme: garbage collectors can clump together data references by their nature. you can stack-allocate in CL (dynamic-extent). and of course, type-specified vectors as you mentioned
xaxaac has joined #lisp
<beginner_supreme>
So the allocated objects themselves would be contiguous, but would the vector would still contain pointers to those objects, not the objects themselves. Right?
<beginner_supreme>
I mean that is good enough, if the gc places objects together this way.
<stylewarning>
beginner_supreme: the vector would contain pointers
dddddd has joined #lisp
<beginner_supreme>
Understood!
<White_Flame>
vectors of numbers, characters, etc, can often be packed together. Vectors of structs and such might not
<White_Flame>
vectors of cons lists pretty much won't
ircleuser has quit [Ping timeout: 276 seconds]
<White_Flame>
of course, you need to specialize its type as you create it to try to gain such advantages
warweasle has joined #lisp
clintm has joined #lisp
<dlowe>
even if you have a vector of structs, they're not going to be laid out in memory like they would in C
<White_Flame>
you might get the struct slots themselves, but structs themselves don't use special packed representations. If the slot value fits in a machine word, it'll be in the struct. Else it'll be a pointer
<White_Flame>
erm, you might get a typed vector to hold a linear array of the struct slots themselves...
<makomo>
dlowe: is that guaranteed or just something that's not really done by compilers or something else?
<White_Flame>
no guarantees
<White_Flame>
the vast majority of this sort of thing is left up to the implementation
lumm has joined #lisp
<White_Flame>
so no, CLHS doesn't bar optimizations like this
<makomo>
so hypothetically, you *could* have a vector in which the structs are laid out contigiously without any indirection
Bike has joined #lisp
<makomo>
contiguously*
<White_Flame>
yes
<makomo>
right
<makomo>
and what happens to this vector if you redefine the struct?
<White_Flame>
but since dereferencing is though standard functions, as the number of types of backends to those functions increases, so does the amount of type testing & dispatch
varjag has joined #lisp
<White_Flame>
redefining structs generally yells at you in any case
<makomo>
as in, it's undefined/impl-def by the standard or?
<Bike>
redefinition is undefined
<White_Flame>
CLOS objects can be defined to migrate to new versions of their class. instantiated structs keep their old structure around if you re-defstruct
<White_Flame>
(in practice)
<stylewarning>
the real problem imo is the meaning of (setf (aref packed-array i) new-struct)
<makomo>
Bike: and redefinition of CLOS classes is defined i guess?
<stylewarning>
how referencing/pointers/etc work. You would need typed pointers into typed arrays
Cymew has joined #lisp
<Bike>
It is, yes
fikka has quit [Ping timeout: 240 seconds]
<White_Flame>
makomo: and this is why C-style optimizations are very warily handled in CL
<White_Flame>
at least, memory/layout optimizations
<White_Flame>
because things can change
<stylewarning>
array-of-structs has always been on my CL wishlist though!
<stylewarning>
it would be so cool if (UPGRADED-ARRAY-ELEMENT-TYPE S) == S for a structure type S
<makomo>
White_Flame: mhm, i see
<Bike>
array of structs messes with eq semantics
<Bike>
but it would be nice, yes
<White_Flame>
stylewarning: I'm sure you could use FFI stuff to do custom memory management
<White_Flame>
even without talking to foreign code
<Bike>
that would be less nice
<stylewarning>
White_Flame: gr0ss :)
<White_Flame>
you asked for it ;)
<stylewarning>
I'd even be happy with a super special struct type, like array of packed words or something
<stylewarning>
I want to make types like RGB triples
noffle has left #lisp ["WeeChat 1.9-dev"]
<White_Flame>
yeah, an extended cons cell with >2 slots is something I've mused about on occasion
<aeth>
arrays of structs, typed lists (this is trivial to do yourself from structs, but it won't be as efficient), and typed hash tables are on my wish list, as well as type declarations behaving everywhere like in SBCL (permits gradual typing) and being able to declare specific optimizations (like TCO or fast floating point) rather than general categories
<Bike>
i think maclisp called that a hunk.
<aeth>
Add all of the stuff on the list I just gave and CL is a good competitor for something like C# or Java
<aeth>
In fact, it's probably capable of superior performance to Java at that point.
<aeth>
e.g. (setf (array-row-of-4 foo 32) (array-of-4 some-array)) ; essentially copies the first four elements of an array (no checking, so it's faster) into the first four elements of the array row 32
<aeth>
It does this by essentially decomposing things into multiple values.
<aeth>
Unfortunately, this isn't a perfect substitute for arrays-of-structs because all items have to be of the same type (which could be T, I guess)
<aeth>
(It's not really copying, either, but if you're doing specialized arrays (numbers or characters) you don't really notice.)
<stylewarning>
aeth: I've faked it by defining things like (define-struct-array <defstruct options>) which just creates a struct-of-arrays
Cymew has quit [Ping timeout: 265 seconds]
svillemo1 has joined #lisp
<stylewarning>
aeth: It at least makes things a bit more efficient, even if you're not reaping all of the rewards of having a single object or having a lot of memory locality.
milanj has joined #lisp
<aeth>
I have a define-struct-of-arrays, too
fikka has joined #lisp
svillemot has quit [Ping timeout: 265 seconds]
python476 has joined #lisp
python476 has quit [Client Quit]
python476 has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<beginner_supreme>
The point made about how avoiding indirection by not having an vector of pointers would require typed pointers for pointer arithmetic is a nice point..
smurfrobot has joined #lisp
SenasOzys__ has joined #lisp
SenasOzys has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 265 seconds]
warweasle_ has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<copec>
Have you used clasp much aeth?
warweasle has quit [Ping timeout: 265 seconds]
<beginner_supreme>
Thanks again guys. Till next time
beginner_supreme has quit []
kmb_ has quit [Quit: kmb_]
vtomole has joined #lisp
kmb_ has joined #lisp
kmb_ has quit [Client Quit]
<aeth>
copec: I tried 2-3 times to get it through roswell, which I use to test in various implementations, but after failing 2-3 times (and it's a long, C++ compile) I don't want to try again via roswell
pierpal has quit [Ping timeout: 256 seconds]
rumbler31 has joined #lisp
SenasOzys__ has quit [Ping timeout: 256 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Kundry_Wag has joined #lisp
rumbler31 has quit [Ping timeout: 255 seconds]
Kundry_Wag has quit [Remote host closed the connection]
fikka has joined #lisp
nickenchuggets has joined #lisp
blt has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
dented42 has joined #lisp
asarch has joined #lisp
MichaelRaskin has joined #lisp
scymtym has quit [Ping timeout: 256 seconds]
shka_ has quit [Ping timeout: 276 seconds]
svillemo1 is now known as svillemot
SenasOzys__ has joined #lisp
cage_ has quit [Quit: Leaving]
himmAllRIght17 has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
blt has joined #lisp
blt has joined #lisp
blt has quit [Changing host]
smurfrobot has joined #lisp
klm2is has joined #lisp
warweasle has joined #lisp
himmAllRIght17 has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
warweasle_ has quit [Ping timeout: 260 seconds]
bbobb has quit [Quit: bbobb]
isBEKaml has joined #lisp
kmurphy4 has quit [Quit: kmurphy4]
smurfrobot has quit [Remote host closed the connection]
tomsen has joined #lisp
scymtym has joined #lisp
<copec>
Is there a list of modern CL tools everybody should know about?
<antoszka>
copec: https://common-lisp.net/ <- that might be another starting point, probably also worth idling less here and on #clnoobs and #lispgames
<copec>
thanks!
smurfrobot has joined #lisp
rumbler31 has joined #lisp
xaxaac has quit [Quit: Leaving]
smurfrobot has quit [Ping timeout: 260 seconds]
tomsen has quit [Ping timeout: 276 seconds]
pierpal has quit [Ping timeout: 255 seconds]
hhdave has joined #lisp
rpg has joined #lisp
rpg has quit [Client Quit]
rpg has joined #lisp
vtomole has quit [Quit: Page closed]
warweasle_ has joined #lisp
warweasle has quit [Ping timeout: 255 seconds]
varjag has quit [Ping timeout: 256 seconds]
inoperable has joined #lisp
smurfrobot has joined #lisp
robotoad has joined #lisp
octobanana has joined #lisp
TCZ has joined #lisp
smurfrobot has quit [Ping timeout: 276 seconds]
asarch has quit [Quit: Leaving]
emacsomancer has joined #lisp
EvW has quit [Ping timeout: 255 seconds]
virtualdemon has quit [Quit: leaving]
eudoxia has joined #lisp
python476 has quit [Remote host closed the connection]
pierpal has joined #lisp
ioa_ is now known as ioa
isBEKaml has quit [Quit: Leaving.]
smurfrobot has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<aeth>
awesome-cl isn't. as akkad hinted, it's not selective enough
<aeth>
e.g. it lists GCL (literally dead) and CLISP (practically dead) under implementations
hjek has joined #lisp
pfdietz has joined #lisp
<aeth>
If you had a way to sort https://www.quicklisp.org/beta/releases.html by category you'd get basically the same result. A list of everything, but with no way of telling if it's actually up to date, worth using, etc.
<akkad>
aeth: you must be old, this is AWESOME cl!
<akkad>
hip lisp was already taken.
* akkad
is old, and agrees 100%
<akkad>
"does it load under the big 4?"
* akkad
would recommend Common Lisp Recipes as a much better vetted list of libraries
hjek has quit [Ping timeout: 240 seconds]
<aeth>
Library selection is a tricky thing. There isn't really one Common Lisp. It's a very multi-paradigm language. Sure, you can definitely write code that's not "Lispy", but even if the code is "Lispy" there's many different valid styles.
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
moei has joined #lisp
<aeth>
Lisp is not even necessarily a dynamically typed language! SBCL did gradual typing years before it was cool.
black_13_ has joined #lisp
<black_13_>
what steps do you have to take to use cffi in ecl