Kundry_Wag has quit [Remote host closed the connection]
Essadon has quit [Quit: Qutting]
warweasle has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
aydio has quit [Quit: WeeChat 2.2]
ryan_vw has quit [Ping timeout: 240 seconds]
benjamin-l has joined #lisp
Jesin has joined #lisp
anamorphic has joined #lisp
dale has quit [Quit: dale]
<anamorphic>
How do symbol property lists typically get used?
<no-defun-allowed>
they don't
<no-defun-allowed>
it's just an old leftover from old lisps
sjl_ has quit [Quit: WeeChat 2.2-dev]
ebrasca has joined #lisp
<White_Flame>
discussed this pretty recently, but in old code that I've seen, consider a normal hashtable scenario holding a symbol->value mapping. If you have no hash tables but only symbol plists, then the usage is symbol-plist ->(table-name value)
<White_Flame>
so there is no central object holding the table. The symbol keys are just annotated with the table named entries in the plist. It's a pretty good way of avoiding plist key clashes
<anamorphic>
So I was playing with this: (defun magic-keyword (keyword) (setf (fdefinition keyword) #'(lambda (hash-table) (gethash keyword hash-table)))), which lets you use (:foo hash-table) like in Clojure... Is that kind of thing likely to cause a mess in subtle ways?
<White_Flame>
I can't see anything at simple glance of the spec that would clash with that use
<White_Flame>
(defun :foo () ...) also seems to work
<White_Flame>
at least on my SBCL
<White_Flame>
it does go against common style in terms of what keywords are for, but I don't think there'd be a technical problem with it
shifty has joined #lisp
nowhere_man has joined #lisp
lnostdal has joined #lisp
Roy_Fokker has quit [Read error: Connection reset by peer]
anamorphic has quit [Ping timeout: 240 seconds]
Lycurgus has joined #lisp
warweasle has quit [Quit: tired. I want to go to bed.]
lumm has quit [Quit: lumm]
warweasle has joined #lisp
ym has quit [Quit: Leaving]
marusich has joined #lisp
<drduck>
Are there any good networking books that are lisp themed?
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<drduck>
Or is Python the de-facto networking language now?
<no-defun-allowed>
what kind of networking?
<nisstyre>
what, why would Python be de-facto for networking?
<nisstyre>
the best networking book is TCP/IP Illustrated
<nisstyre>
volume 2 covers C code
<no-defun-allowed>
afaik usocket is pretty close to C while remaining useful
<no-defun-allowed>
you can use SOCKET-STREAM and it's just another lisp stream
ryan_vw has joined #lisp
<drduck>
I thought tcp/ip illustrated was outdated.
xkapastel has joined #lisp
<nisstyre>
drduck: no, there's an updated version
<nisstyre>
also the protocols haven't changed much anyway
<nisstyre>
that's kinda the point, it's a layered system
marusich has quit [Quit: Leaving]
astronavt has joined #lisp
astronavt has quit [Remote host closed the connection]
holycow has joined #lisp
pierpal has joined #lisp
anewuser has joined #lisp
pierpal has quit [Ping timeout: 252 seconds]
pierpal has joined #lisp
Ekho- is now known as Ekho
pierpal has quit [Ping timeout: 246 seconds]
nowhere_man has quit [Ping timeout: 252 seconds]
nowhere_man has joined #lisp
luis has joined #lisp
ryan_vw has quit [Ping timeout: 245 seconds]
Josh_2 has quit [Remote host closed the connection]
cylb has joined #lisp
cylb has quit [Ping timeout: 272 seconds]
Jachy has joined #lisp
dddddd has quit [Remote host closed the connection]
pierpal has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
ggole has joined #lisp
<leo_song>
Speaking about network, is there portable way of avoiding the read hanging on the unfinished line other than READ-CHAR-NO-HANG?
<leo_song>
(with better performance)
beizhia has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
<stylewarning>
leo_song: no
<stylewarning>
leo_song: dip into your OS! :D
<leo_song>
stylewarning: Em... That's what I'm doing.
nanozz has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
ryan_vw has joined #lisp
<aeth>
leo_song: I'm actually exploring an alternative
<aeth>
leo_song: you have to write it yourself on top of read-char-no-hang, obviously
nanozz has quit [Ping timeout: 246 seconds]
<leo_song>
Better to write a new one over the system calls when dealing with GBs of data other than the READ-CHAR-NO-HANG
igemnace has quit [Quit: WeeChat 2.3]
<beizhia>
Anyone got some good resources for introducing other coders to Lisp? Going to be giving a little talk to a bunch of php and JS coders. I
<beizhia>
I'm working up some examples myself, but any other input is welcome
<leo_song>
Make a real cl-php?
<beizhia>
0_0
<beizhia>
I'm not that good yet!
<leo_song>
<?lisp (format t "<p>Hello World</p>") ?>
<aeth>
In addition to something web, of course. If you have the time for several demos.
<aeth>
Only do graphics if you have control over the hardware, of course. Who knows what drivers a random machine has.
<beizhia>
Oh ya, those would be pretty rad. I'd be showing it from my machine, so that's all cool
<leo_song>
beizhia: I think build a "cl-php" over hunchentoot should cost less than 1000 lines of code, and much faster than real PHP
<beizhia>
I do want to keep it around 30 mins of demo time, so its probably more of a core concepts of the language sort of thing
<beizhia>
definitely gonna watch through all these CEPL vids myself though, so thanks aeth
<aeth>
leo_song: if you mean implementing PHP in CL, it's probably not 1000 lines. cloc says I have 763 lines of .lisp and .scm code in my Scheme implementation in CL and it's only about 40% complete. And Scheme's one of the closest languages to CL (and one of the smallest specified languages)
<leo_song>
aeth: nop, I mean PHP as method
<leo_song>
as I said: <?lisp (format t "<p>Hello World</p>") ?>
<aeth>
leo_song: Oh, you mean PHP-style evaluation of CL within HTML?
<beizhia>
I was planning on working in CL-WHO
<beizhia>
Once I go over the whole code-is-data idea.
<leo_song>
aeth: yes, one of my freind did a similar thing in Node.js during the internship, he said it's very handy
vlatkoB has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<leo_song>
beizhia: I think a very important point is telling people Common Lisp is actually simpler than their languages
arescorpio has joined #lisp
<beizhia>
leo_song: Agreed. I do also have to make them comfortable with the syntax (or lack thereof)
<beizhia>
Apparently Lisp is ugly compared to php >_>
meepdeew has joined #lisp
<leo_song>
>_<
<beizhia>
this is what I'm working with here hah
mrblack has quit [Remote host closed the connection]
Bike has quit [Quit: Lost terminal]
<no-defun-allowed>
sbcl is notably faster than node.js, even without fancy cee bindingd
<no-defun-allowed>
*bindings
<aeth>
no-defun-allowed: depends
<aeth>
no-defun-allowed: SBCL is faster if you know how to write fast code
<aeth>
A total beginner will probably write something that's faster on node.js
bendersteed has quit [Remote host closed the connection]
beizhia has quit [Ping timeout: 264 seconds]
pierpal has joined #lisp
k-hos has joined #lisp
potatonomicon has quit [Ping timeout: 246 seconds]
anewuser has joined #lisp
jmercouris has joined #lisp
phenoble has joined #lisp
<jmercouris>
what is the difference between a stream and "gray" stream?
<beach>
A Gray stream is a stream. It is named after David Gray, so it has nothing to do with the color.
<beach>
A Gray stream is a CLOS-based protocol for the lowest level of a stream.
<jmercouris>
beach: can you unpack that explanation a little bit for me
<beach>
Reading a character or a byte, writing a character or a byte, checking EOF.
<jmercouris>
so it is a protocol based on the implementation of some defmethods required to be considered "gray"
<beach>
So the programmer can define a class that works like an arbitrary stream.
<jmercouris>
and those are some of those methods that you listed
<jmercouris>
okay I see
<beach>
Then the programmer defines methods on that class like trivial-gray-stream:read-char etc.
<jmercouris>
so it is one programmers specification of what functionality a stream object should support
<jmercouris>
and why might I want to conform to this protocol? are there supporting libraries that expect gray stream conforming objects?
<beach>
Yes, for example, you can write a stream that returns random characters and never reaches EOF.
<beach>
SBCL and probably most other Common Lisp implementations accept Gray streams as arguments for stream functions, like READ.
<jmercouris>
I see
<jmercouris>
and what are the advantages over a regular stream object?
<jmercouris>
is the API to implement a regular stream object much more complex?
<beach>
Try to return random characters from a regular stream!
<beach>
The protocol for implementing regular streams is not exposed.
<jmercouris>
ah okay
<jmercouris>
that was going to be my next question
<beach>
So you are in implementation-specific territory.
<jmercouris>
I was going to ask if there is a stream class that I might inherit from
<beach>
That won't be necessary.
<jmercouris>
so to fill in this gap, David Gray came up with this protocol
<beach>
If you implement all the required methods, then any class will do.
<jmercouris>
and more or less everyone just agrees that it is okay
nirved is now known as Guest27509
Guest27509 has quit [Killed (leguin.freenode.net (Nickname regained by services))]
<beach>
Yes, except that it did not become part of the standard.
<jmercouris>
the same way fare came up with ASDF
nirved has joined #lisp
<jmercouris>
right, ASDF is also not part of the standard, right?
<beach>
Similar, yes.
<beach>
Correct.
<beach>
The difference is that Gray Streams actually existed when the standard was written.
<beach>
ASDF did not.
<jmercouris>
Ah, I see
<jmercouris>
and I assume again it was probably a time/money issue that prevented its integration into the specification?
<beach>
Possibly performance as well.
<beach>
A generic function is called for each character/byte read.
<jmercouris>
I can see why that would be expensive
<jmercouris>
so what happens if you only implement part of the protocol, let's say you only implement the byte reading methods
<jmercouris>
can you still say that you have a gray stream type object?
<jmercouris>
or must you implement the whole protocol?
<beach>
You only have to implement the methods that are actually called.
<jmercouris>
for example, in places where SBCL allows gray streams, will it cause issues, or would it just try to work, and if a method doesn't exist- then raise a signal
<jmercouris>
ok, that makes sense
<beach>
In Common Lisp you don't "raise a signal". You "signal a condition".
<jmercouris>
yes, I'm still not understanding off signals and conditions
Zaab1t has joined #lisp
<jmercouris>
I've read the PCL chapter three times now, and I still don't get it
<jmercouris>
I'm hoping that when I get to it in a Gentle introduction that I'll finally understand
<jmercouris>
s/off/of - my keyboard is a bit wonky
<beach>
There are no signals in Common Lisp. The only "signal" in the Common Lisp HyperSpec is a verb.
<jmercouris>
so in the same sense that a functional call is not a noun, but an action?
zxcvz has joined #lisp
<beach>
You can use "call" as a noun. "This call to this function produced a list."
<jmercouris>
by that same logic couldn't you say "this signal in this function produced a condition"?
<jmercouris>
I'm not trying to be pedantic, just trying to understand what you mean
<beach>
Here is an example of use of Gray streams: In Second Climacs, I nead to READ the contents of an editor buffer. But the buffer is not a stream. It has a complex structure. So I create a Gray stream that is acceptable as a stream to the Common Lisp implementation, and that knows about the structure of the buffer, so that it keeps the current line and column in its instance.
<beach>
jmercouris: It is not that important.
<jmercouris>
ok
<jmercouris>
so when you say "the buffer is not a stream", you basically mean the buffer is not a contiguous block of data that can be easily read from?
pierpal has quit [Read error: Connection reset by peer]
<jmercouris>
and so you hide that complexity behind a stream object that knows from where to fetch the various parts that compose the buffer to make it appear as if it is one contiguous block, or a file or something, something that a normal stream could read
<beach>
Furthermore, in Second Climacs, I keep a cache of expressions already read, indexed by position. If a call to READ is made with such a position, I return the cached object, and advance the position beyond the characters of the object.
<beach>
jmercouris: I mean, it is not a stream in that it is not (typep <buffer> 'stream) so it can't be used to READ from.
<jmercouris>
okay, I see, it is some other, unsupported type, so you had to implement a gray stream to treat it as a stream
<beach>
Exactly.
<jmercouris>
and why exactly might you want to do this? where did you need to read the buffer contents as a stream?
<pjb>
jmercouris: no, to write a listserv, you need very little. You can hook it to an email address with an entry in the aliases file, and it can send back email using sendmail with run-program.
<jmercouris>
pjb: I am just wondering why mailman is such a massive program, there must be more to it somehow
<pjb>
jmercouris: alternatively, you can use smtp directly, but you don't need imap o pop3.
<jmercouris>
one sec, brb
<pjb>
jmercouris: no, you can wonder. C programs (or most other programming languages actually) are about 30 times more verbose than lisp.
<pjb>
jmercouris: they don't have memory management, error handling, generic functions, a dumb type system, etc, so there is a lot of code duplication.
pierpal has quit [Read error: Connection reset by peer]
<beach>
pjb: On what information did you base than number 30?
orivej has joined #lisp
elderK has joined #lisp
<pjb>
beach: when I started programming 100% in CL, I translated my library (which was originally written in Modula-2, and later translated into C), into CL. And between the modules that were useless in CL, and the more concise code for the rest, I got that number.
pierpal has joined #lisp
<beach>
I am not saying it's wrong. I just wanted to know whether it is published somewhere.
<pjb>
It's just a data point.
<beach>
Got it.
<pjb>
But when you see real C code, this is about the ratio… It's horrible.
asymptotically has joined #lisp
<pjb>
Look for example openssl. For ASN.1 data structures, they have actually a single "generic" set of functions, but they have macros to generate wrappers for them, with the specific C types. So their man page have 30 functions for 1 feature! https://manpages.debian.org/testing/libssl-doc/d2i_ASN1_TYPE.3ssl.en.html
<pjb>
All those functions are actually only the 6 in the synopsis…
<pjb>
While the brain cells of the C programmers are busy handling errors, managing memory, and avoiding buffer overflow, they forget about sound software engineering rules and proper design. While the code of libssh looks cleaner than eg. FreeBSD, there are still quite a number of functions that are bigger than a screen height.
<jmercouris>
if you were to implement a listserv in CL with administration portal, what would it look like?
<pjb>
jmercouris: you mean, a web site?
<jmercouris>
Yes
<pjb>
I would make a postgres database. Then there would be a program to receive the email and process commands or diffuse messages. And a hunchentoot program to manage the administration.
<jmercouris>
so you wouldn't receive the mail in CL, you'd use something like offlineimap?
<holycow>
jmercouris: thanks for your work on next browser dude
<pjb>
Since the "process commands" is actually just another interface to to the adminstration module, perhaps this could be a separate server (used by both the email processing and the hunchentoot), or you could merge all three in a single lisp image/unix process.
<jmercouris>
holycow: no problem :) it is my pleasure to work on it, I just hope to be able to do more
<pjb>
jmercouris: No, You would put entries in aliases.
<jmercouris>
pjb: what does it mean to "put entries in aliases"?
<jmercouris>
is there some nix convention I am unaware off?
<jmercouris>
I'm sure there are many I am unaware off, but I mean, in this context
<pjb>
And mailman adds such a set for each maillist.
<pjb>
The | means redirect the email to a program.
<jmercouris>
oh I see
<jmercouris>
so if the system gets an email at mailman-admin it'll invoke /var/lib/mailman/mail/mailman with the args admin mailman?
<pjb>
jmercouris: an alternative would be to define a transport in postfix, so you could directly use a running server. With the alias, you would write a little program that would connect to the running server, if you don't want to launch a new program for each message.
<pjb>
Yes, and with the message on stdin.
<pjb>
jmercouris: there are alternatives of course.
DGASAU has joined #lisp
<jmercouris>
Yeah, I'm just not sure what to do
<jmercouris>
because I know that mailman sucks, out of personal experience, and I just want something that just works with minimal configuration, hence why I was thinking of writing my own in CL
lumm has joined #lisp
<pjb>
For example, you could implement a SMTP server (without the sophisticated options, it's quite simple). Then you can either hook it behind postfix, or directly on the internet if the machine is used only for your listserv. This would let you do fine filtering when receiving the enveloppe, even before receiving the message.
<jmercouris>
but the size of mailman was making me reconsider
<pjb>
jmercouris: I agree. The old listserv was much better. And it could send you files!
random-nick has quit [Remote host closed the connection]
doubledup has joined #lisp
lumm has quit [Remote host closed the connection]
random-nick has joined #lisp
lumm has joined #lisp
aydio has joined #lisp
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<pjb>
Actually, this is just a command system interface. You have different ways to give commands: by sending emails, thru the web, at the unix shell, perhaps thru irc, etc. So you just need a lisp REPL to receive the commands (using a lisp REPL allows you to script those commands too!), and to hook the various user interface to to the same REPL system.
robotoad has quit [Ping timeout: 252 seconds]
<pjb>
There are a few algorithms you need to recover or reproduce from listserv or mailman, about the managing of addresses to avoid loops, process bounces (just a different command), etc.
robotoad has joined #lisp
anewuser has quit [Quit: anewuser]
varjag has joined #lisp
robotoad has quit [Ping timeout: 272 seconds]
nirved has quit [Read error: Connection reset by peer]
nirved has joined #lisp
nirved has quit [Client Quit]
fsmunoz has quit [Read error: Connection reset by peer]
nirved has joined #lisp
jcowan has quit [Quit: Connection closed for inactivity]
heisig has quit [Quit: Leaving]
papachan has quit [Ping timeout: 246 seconds]
scymtym has quit [Ping timeout: 240 seconds]
lavaflow has quit [Ping timeout: 252 seconds]
frodef has joined #lisp
Lycurgus has quit [Quit: Exeunt]
lumm has quit [Ping timeout: 245 seconds]
lumm has joined #lisp
Zaab1t has quit [Ping timeout: 264 seconds]
robotoad has joined #lisp
Zaab1t has joined #lisp
aydio has quit [Quit: WeeChat 2.2]
pyx has joined #lisp
pyx has quit [Client Quit]
rumbler31 has joined #lisp
<flip214>
beach: thank you!
<flip214>
phoe: got it, how quick do you need a result? would monday or tuesday suffice?
elderK has quit [Quit: Connection closed for inactivity]
<anamorphic>
Do I need to wrap a defparameter in some kind of eval-when in order for it's binding to be seen from within a macro?
<pjb>
anamorphic: clhs defparameter says: If a defvar or defparameter form appears as a top level form, the compiler must recognize that the name has been proclaimed special. However, it must neither evaluate the initial-value form nor assign the dynamic variable named name at compile time.
<pjb>
So yes.
<|3b|>
(or LOAD it before the macro is expanded)
<anamorphic>
Ah OK. So (eval-when (:load-toplevel :compile-toplevel? I'm not sure if I need :execute
<pjb>
:execute is needed if you load the source.
<|3b|>
you generally want all 3 if any
<pjb>
But if you define it at compilation-time, compute the value at compilation time, perhaps it cannot work if you load only the source? Or perhaps you can also compute the value when just loading the source. Depends on your program.
lumm has quit [Ping timeout: 272 seconds]
<pjb>
For example, when you define functions to be used by macro, you usually don't need them at run-time (unless you plan to use the macro at the REPL, say). In that case, you can skip the :load-toplevel situation.
<pjb>
So the compilation-time function don't take space at run-time (unless you load the source of course).
<pfdietz>
If you use the macro in another file those functions better have been loaded, though.
<pfdietz>
I think.
<phoe>
flip214: phoe@disroot.org
<pjb>
It's true, that an implementation could fork a different compilation environment for each compile-file that is not within the same with-compilation-unit. Ie it could throw away compilation-time definitions :-)
nly has quit [Read error: Connection reset by peer]
<pjb>
In that case, loading the compiled files between compile-file would be essential, and you'd have to include :load-toplevel for those functions.
<pjb>
So, as |3b| saidk.
younder has joined #lisp
<anamorphic>
That makes sense. Thanks for the explanation
noark9 has quit [Quit: noark9]
nly has joined #lisp
eddof13 has joined #lisp
<|3b|>
if you skip loading the files you use in macros, you will probably eventually be annoyed when you try to fix something interactively that uses it :)
eddof13 has quit [Client Quit]
HighMemoryDaemon has joined #lisp
<|3b|>
*loading the functions i mean
orivej has quit [Ping timeout: 246 seconds]
<HighMemoryDaemon>
Does a pathname (ex. #p"~/Documents") offer any benefits over a regular string? In Quickproject's make-project function, I noticed that regular strings work too.
<|3b|>
many places that expect a pathname will accept a namestring as well
<|3b|>
main place i can think of it would matter is things that try to guess intent from types, for example something that would interpret a string as input, and a pathname as name of file containing input
Kundry_Wag has quit [Remote host closed the connection]
atgreen_ has joined #lisp
orivej has joined #lisp
atgreen has quit [Ping timeout: 246 seconds]
noark9 has joined #lisp
fikka has joined #lisp
Kundry_Wag has joined #lisp
<HighMemoryDaemon>
Interesting. Also, what is the name for things like #p, :, #', etc?
<flip214>
phoe: already sent to the github mail address, resending now
asarch has joined #lisp
<|3b|>
: is just part of the symbol syntax in the reader, with no real name. #p and #' are reader macros
pierpal has joined #lisp
<emaczen>
What happens with the memory management of pointers (with CFFI) and multiple threads (with bordeaux-threads)?
<|3b|>
(specifically # is a dispatching reader macro, with p and ' being specific instances of that particular dispatching reader macro)
<phoe>
flip214: didn't get it yet
<phoe>
emaczen: nothing
<emaczen>
For example, If I create a pointer on a thread, then use it in the main thread, where does it need to be freed?
<phoe>
unless you free it, it's not freed
<phoe>
anywhere I think
<|3b|>
a lot of CL syntax is actually reader macros, including things like (
<|3b|>
so you can change how they are read if you want to
<emaczen>
phoe: How does the main thread even know about the pointer?
<|3b|>
symbols (including the : or :: ) and numbers are built into the reader syntax though, so you can't really change how those are read without just parsing everything yourself
<scymtym>
|3b|: #\: is called "package marker" in this context
atgreen_ has quit [Ping timeout: 246 seconds]
<anamorphic>
emaczen, don't all threads share the same heap within a process?
<emaczen>
anamorphic: I don't know
<emaczen>
anamorphic: If that is true, it would answer my question here.
<emaczen>
anamorphic: but it doesn't explain why I seem to leak more memory with multiple threads then not
<|3b|>
scymtym: thanks, thought there probably was actually a name after i wrote that, but forgot to go look it up
<emaczen>
In lisp what generally is allocated on the stack vs heap?
<anamorphic>
sounds implementation specific
asymptotically has quit [Quit: Leaving]
<|3b|>
(and to clarify for original asker, #\ is another dispatching reader macro on # that reads a character, so #\: reads as the character : and in general that's how we'd talk about characters when talking about CL. i skipped them previously to try to simplify the answers)
Lycurgus has quit [Quit: Exeunt]
sjl has joined #lisp
<anamorphic>
...man I always end up regretting writing functions with "dwim" in the name
<emaczen>
Well, what can I reasonably expect?
<emaczen>
I would guess make-instance allocates on the heap
<emaczen>
but that is about my only guess
<pjb>
That said, we could as well talk about the character "a": (character "a") #| --> #\a |# ;-)
<anamorphic>
emaczen, so what are you trying to do?
<pjb>
or the character a: (character '\a) #| --> #\a |# (character 'a) #| --> #\A |#
wooden` has joined #lisp
actuallybatman has quit [Read error: Connection reset by peer]
actuallybatman has joined #lisp
scymtym has quit [Ping timeout: 252 seconds]
Roy_Fokker has joined #lisp
wooden` is now known as wooden
hiroaki has joined #lisp
Oladon has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
ryan_vw has joined #lisp
noark9 has quit [Quit: noark9]
HighMemoryDaemon has quit [Ping timeout: 246 seconds]
pierpal has quit [Ping timeout: 246 seconds]
atgreen_ has joined #lisp
lumm has joined #lisp
makomo has joined #lisp
lumm has quit [Read error: Connection reset by peer]
<phoe>
emaczen: pass it as a variable
scymtym has joined #lisp
frodef has joined #lisp
<phoe>
flip214: got it, thanks
fikka has quit [Ping timeout: 246 seconds]
HighMemoryDaemon has joined #lisp
random-nick has quit [Remote host closed the connection]
eddof13 has joined #lisp
warweasle has joined #lisp
random-nick has joined #lisp
<HighMemoryDaemon>
In my projectname.asd file, is there a good way to use a system that is in a folder of my project? Ex. 'pathnames-lib/pathnames.asd'. I could symlink it to my ~/common-lisp folder but I'd prefer not to.