Stanley00 has quit [Read error: Connection reset by peer]
Stanley|00 has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
EvW has joined #lisp
contrapunctus has joined #lisp
Alfr_ has joined #lisp
Alfr has quit [Ping timeout: 260 seconds]
_paul0 has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
paul0 has quit [Ping timeout: 272 seconds]
mrchampion has quit [Ping timeout: 265 seconds]
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
galex-713 has joined #lisp
<beach>
I started watching a talk by Robert Virding entitled "On Language Design", and I think the next time someone suggests a revision of the Common Lisp standard, I'll point them to that presentation.
<beach>
"Be very careful when making changes suggested by users" * They often don't see the whole picture of the changes they suggest. * They often don't know what they really need. * They often want help with a solution; not [with] solving a problem.
galex-713 has quit [Remote host closed the connection]
galex-713 has quit [Quit: No Ping reply in 240 seconds.]
kapil_ has joined #lisp
miasuji has joined #lisp
sts-q has joined #lisp
galex-713 has joined #lisp
brj has quit [Ping timeout: 265 seconds]
<contrapunctus>
Ironic, in the context of a language which is famous for trusting that the user knows best.
<contrapunctus>
(And that it should be possible for the user, if they wish, to get involved the design of the language.)
brj has joined #lisp
<no-defun-allowed>
Arguably a user is expected to involve themselves by "extending" a language via macros.
skapata has quit [Quit: Leaving]
<beach>
Not really ironic. The users get involved by experimenting, using the existing features of the language, and only after extensive experimentation and user experience is the new proposal considered for standardization.
<beach>
I think this idea was even documented somewhere.
<beach>
As I recall, CLOS was such a feature.
<borei>
im not sure if im on right direction or not, so i need some advise. Im working on the client for rados/ceph, and im hitting the following problem. To dump lisp object (instance of class) i need to pack object into flat array. I didn't find better solution then to use CFFI. I don't know lisp so deep and if there is "pure lisp" solution for that problem.
frost-lab has joined #lisp
<no-defun-allowed>
That is a very strange solution, and it sounds like it would get very unportable very quickly, should it depend on the memory layout of standard instances.
<no-defun-allowed>
What do you need to dump?
<borei>
from the technical stand point - all data stored in slots.
<bhartrihari>
The conforming code will always work, and the very useful non-conforming code can be made to work when it arises. Hence gaining from both the sides.
<bhartrihari>
I think it's a fine barbell strategy. Instead of finding a balance in the middle, it balances two extremes—a safe side (conforming code), and the unsafe (and volatile) side (non conforming code but with useful features, eg. OS threads).
<borei>
i'll give you example - let say you say chemical element (which represented by clos class), let say it is helium.
<no-defun-allowed>
You could store a sequence of readers for the slots you need to dump (or slot names, but readers are a much better approach should you want to modify your representation later), and then iterate over that to get the values to dump.
refpga has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
<borei>
slots are - mass, charge, number of electrons, symbol (He) and long name (helium) that info need to go to ceph object
contrapunctus has joined #lisp
<borei>
didn't get idea with readers.
<no-defun-allowed>
Supposing a class definition like (defclass element () ((mass ... :reader mass) (charge ... :reader charge) ...)), you could have a macro like (define-output-format element (mass charge electrons symbol name)) which expands to something that eventually calls your serialisation code.
mrchampion has joined #lisp
gravicappa has joined #lisp
<borei>
how it will be packing string (name) and double (mass) to the uniformed data ?
<borei>
im losing idea
<no-defun-allowed>
That may be a property of the values stored (values have types in Lisp), or you may extend define-output-format to include types, like (define-output-format element (mass double) (charge double) (electrons unsigned-integer) (symbol string) (name string))
emacsomancer has quit [Read error: Connection reset by peer]
<borei>
ok, i have type, and i can use it (and actually im using it) but i don't see solution excepts (setf (mem-ref buffer :int 0) charge)
<borei>
then im dumping buffer to ceph object
<borei>
knowing size of data stored in slot, im using proper offset and loading all data from all slots
<borei>
and buffer was created as foreign-alloc
<borei>
bottom line - very C-approach.
<no-defun-allowed>
So, what kind of format are you writing, and what consumes it?
<borei>
there are a lot of things that are hardcoded
<borei>
but you should get an idea
<borei>
that pack function is preparing object header
emacsomancer has joined #lisp
<borei>
it loads number of slots, and slots sizes into buffer
<no-defun-allowed>
Does a C library consume that structure?
<borei>
yes, then i can dump that buffer to ceph
<no-defun-allowed>
Right, well I don't have much to say about producing C structures.
<borei>
i'd be more then happy to avoid C-like data representation - but i can't find lisp way to load data of different type into allocated memory
miasuji has quit [Ping timeout: 240 seconds]
Blukunfando has joined #lisp
orivej has joined #lisp
<beach>
This talk by Robert Virding is quite interesting. He i an Erlang language developer, but the talk is about general principles, and he might as well talked about Common Lisp as an example of good design. Furthermore, his example of what NOT to do, fits very well with how C++ is "designed".
<beach>
*He is
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
emacsomancer has quit [Read error: Connection reset by peer]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
gioyik has joined #lisp
Stanley|00 has quit [Remote host closed the connection]
mason has joined #lisp
emacsomancer has joined #lisp
shka_ has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
toorevitimirp has joined #lisp
iissaacc has quit [Remote host closed the connection]
iissaacc has joined #lisp
toorevitimirp has quit [Client Quit]
toorevitimirp has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
Stanley00 has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
ex_nihilo has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
gioyik has quit [Read error: Connection reset by peer]
gioyik has joined #lisp
Alloc has quit [Ping timeout: 265 seconds]
Alloc has joined #lisp
bocaneri has joined #lisp
_whitelogger has joined #lisp
shangul has joined #lisp
gioyik has quit [Quit: WeeChat 2.9]
orivej has joined #lisp
kiroul has quit [Ping timeout: 256 seconds]
iissaacc has quit [Ping timeout: 240 seconds]
Alloc has quit [Ping timeout: 240 seconds]
Alloc has joined #lisp
Alloc has quit [Ping timeout: 260 seconds]
iissaacc has joined #lisp
Alloc has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
borei has quit [Ping timeout: 260 seconds]
<p_l>
beach: he also made a lisp for erlang, based on CL (though not compatible and without the same standard library - the point was to enable writing in Lisp on the Erlang's Open Telecom Platform)
iissaacc has quit [Ping timeout: 265 seconds]
Necktwi has quit [Ping timeout: 260 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
iissaacc has joined #lisp
refpga has quit [Ping timeout: 272 seconds]
refpga has joined #lisp
mangul has joined #lisp
Nilby has joined #lisp
shangul has quit [Ping timeout: 256 seconds]
Necktwi has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
Psycomic has joined #lisp
karlosz has quit [Quit: karlosz]
supercoven has joined #lisp
sonologico has joined #lisp
<beach>
p_l: Oh, I see! No wonder! :)
iissaacc has quit [Remote host closed the connection]
iissaacc has joined #lisp
Qudit314159 has joined #lisp
iissaacc has quit [Ping timeout: 256 seconds]
Qudit314159 has quit [Remote host closed the connection]
narodism has joined #lisp
pve has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
Stanley00 has quit []
iissaacc has joined #lisp
jonatack has quit [Ping timeout: 260 seconds]
frost-lab has quit [Quit: Connection closed]
<lukego>
yeah Robert is an old-school Lisp dude since before Erlang.
<beach>
I had no idea. Thanks for this information.
rgherdt has joined #lisp
madage has quit [Ping timeout: 240 seconds]
madage has joined #lisp
random-nick has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<phoe>
I have written a few things in Lisp Flavored Erlang, I even attempted a swank server once
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
<phoe>
it's a nice non-CL language, though functional paradigm and pattern matching enabled by default makes its syntax kinda dirty and verbose compared to CL
<phoe>
but then again, it's just Erlang with parens and a few Lispesque functions and macros to make things nicer
frgo_ is now known as frgo
_whitelogger has joined #lisp
iissaacc has quit [Ping timeout: 256 seconds]
sugarwren has joined #lisp
random-nick has quit [Quit: quit]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
X-Scale` has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
pankajgodbole has quit [Ping timeout: 240 seconds]
contrapunctus has joined #lisp
X-Scale has quit [Ping timeout: 264 seconds]
X-Scale` is now known as X-Scale
emys has joined #lisp
saganman has quit [Read error: Connection reset by peer]
random-nick has joined #lisp
sonologico has quit [Remote host closed the connection]
habeangur has joined #lisp
isBEKaml has joined #lisp
mangul has quit [Ping timeout: 256 seconds]
iissaacc has joined #lisp
cosimone has joined #lisp
habeangur is now known as shangul
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
emys has quit [Ping timeout: 246 seconds]
_Posterdati_ has joined #lisp
emys has joined #lisp
Posterdati has quit [Ping timeout: 260 seconds]
emys has quit [Ping timeout: 272 seconds]
emys has joined #lisp
aaaaaa has joined #lisp
shifty has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
<bhartrihari>
What problems would one want to look at while trying to improve the state of smalltalk like image based programming in CL?
dilated_dinosaur has joined #lisp
<no-defun-allowed>
I'd like to "atomically" replace a set of functions and types, so that busy threads don't get confused if they try to use those while I'm reloading them.
contrapunctus has joined #lisp
emys has quit [Ping timeout: 264 seconds]
frost-lab has joined #lisp
gopher---- has joined #lisp
<gopher---->
lisp is awful.
<bhartrihari>
no-defun-allowed: Thanks. That's something to think about.
<gopher---->
wha
<gopher---->
what
<no-defun-allowed>
gopher----: Who asked you?
emys has joined #lisp
<gopher---->
you
<no-defun-allowed>
I don't recall asking you anything before.
<gopher---->
what help do you need for ?
Gerula has quit [Quit: Leaving]
iissaacc has quit [Ping timeout: 240 seconds]
<gopher---->
anyway
<gopher---->
if you dont need help, dont highlight me, ok ?
<no-defun-allowed>
One easy implementation would be to have something like (with-stopped-world (ql:quickload :some-stuff)), but that doesn't help if a thread has entered the code we wish to replace.
<no-defun-allowed>
I wanted to know who asked you about how awful you think Lisp is.
<gopher---->
fuck you
<no-defun-allowed>
That wasn't very nice.
<gopher---->
yes
<gopher---->
fuck you
<no-defun-allowed>
Come on now, who shat in your cereal?
<gopher---->
bitch
gopher---- was banned on #lisp by phoe [*!*gopher@2a03:1b20:3:f011::*]
gopher---- was kicked from #lisp by phoe [gopher----]
iissaacc has joined #lisp
<no-defun-allowed>
Maybe you can get closer with first-class global environments. Compile into a copy of the current environment, work out which functions changed, wait for all the threads to leave those functions, then stop the world and install them in the current environment.
<bhartrihari>
Maybe we could find something to solve that while trying to solve the problem of serializing runtimes with multiple threads?
<no-defun-allowed>
Do you mean like save-lisp-and-die -ing in the presence of multiple threads?
<bhartrihari>
Yes
emys has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
The way restoration works there only really leads to one (fresh) thread coming back after you reload the image, so you could destroy all other threads to get an approximation of the solution.
<no-defun-allowed>
I can't comment on the possibility of persisting threads in an image, but alien data structures and associated state (including POSIX threads for example) and images aren't friends.
<bhartrihari>
Does smalltalk deal with this problem?
<no-defun-allowed>
I can't comment on that either.
<bhartrihari>
I see.
<no-defun-allowed>
I think old Smalltalk virtual machines implemented threads at the image level, i.e. Smalltalk would flip between contexts as a timer interrupts the virtual machine, but that's quite far from modern implementations.
<bhartrihari>
Squeak doesn't support native threads, from a cursory look at their wiki.
Gerula has joined #lisp
<bhartrihari>
Green threads.
<bhartrihari>
They have green threads.
<no-defun-allowed>
Right.
shifty has quit [Ping timeout: 256 seconds]
tamarindo has quit [Quit: Leaving]
tamarindo has joined #lisp
refpga has quit [Read error: Connection reset by peer]
refpga has joined #lisp
cosimone has quit [Quit: cosimone]
tamarindo has quit [Client Quit]
tamarindo has joined #lisp
ramHero has quit [Ping timeout: 272 seconds]
mangul has joined #lisp
emys has joined #lisp
shangul has quit [Ping timeout: 258 seconds]
<beach>
Not surprisingly, I didn't understand the meaning of the question by bhartrihari. bhartrihari: Are you saying that currently, no Common Lisp implementation is fit for image-based development, and that you are looking for ways to improve current implementations to make such development practical?
hiroaki has joined #lisp
<phoe>
one thing that smalltalk images commonly provide is an integrated GUI/IDE/class browser - CL currently does not have such a facility
srhm has joined #lisp
<phoe>
s/facility/widespread facility/
emys has quit [Ping timeout: 246 seconds]
emys has joined #lisp
isBEKaml has quit [Ping timeout: 256 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<bhartrihari>
beach: I'm looking to explore the problems therein, mainly to decide whether I would want to spend time making it more practical. There are certain problems which are documented in manuals for implementations like incompatibilities in images between versions. I was wondering what the concerns of the community are that have kept them from adopting that workflow more widely.
<beach>
Got it. Thanks for elaborating.
<beach>
bhartrihari: Are you aware of my CLOSOS document?
<bhartrihari>
I am. I've read parts of it, and was quite inspired by that.
<beach>
OK. Just checking.
<beach>
But you want something that can run on some "modern" operating systems?
<bhartrihari>
Not necessarily. I'm only the problems for now I guess.
<beach>
Fair enough.
<bhartrihari>
*only looking for
Psycomic has quit [Ping timeout: 272 seconds]
<bhartrihari>
Persistence via source control is one good thing about working with text files. I still need to take a closer look at clobber for that.
<beach>
For a "modern" OS, it is true that saving and restoring an image must work correctly.
EvW has joined #lisp
<beach>
But there are other problems. It is way too easy to break the working image in ways that can't be fixed other than starting a new one.
<beach>
First-class global environments with a pertinent set of pre-configured environments would be a start.
<beach>
Also, phoe is right. There are still a few essential tools missing.
<lukego>
bhartrihari: I'm not sure if Lisps usually have an Object>>become: method hiding somewhere, or Object>>allInstancesDo:, but I often miss those in non-Smalltalk images.
<lukego>
I suppose that I mean Class>>allInstancesDo:
<bhartrihari>
On binary incompatibility, sbcl manual states that nobody has been motivated enough to do a lengthy fix. I wonder if that is speculation alone, or there are any hints as to what the lengthy solutions might look like.
<no-defun-allowed>
(You probably wouldn't write it exactly like that, because we use that function to splat in the slots of an object we received into another instance.)
<beach>
bhartrihari: Doing more with standard classes, standard objects, and generic functions would help that problem. But SBCL and the other existing Common Lisp implementations were written before CLOS became part of the standard, so they add CLOS late. This means a lot of dependency on exact representation of objects.
<bhartrihari>
I don't think I understand that fully. You mean there is no standardized representation (ABI?) to conform to?
emys has quit [Ping timeout: 256 seconds]
<phoe>
not in the CL world
emys has joined #lisp
<phoe>
every implementation has its own way of organizing and managing raw memory
<beach>
Sort of. The internal representation of objects is often visible everywhere in the system, say in the form of tag bits and such. CLOS would help abstract those dependencies away.
<bhartrihari>
I see.
<beach>
But it would be a monumental task to modify an existing implementation in that direction.
<beach>
Probably harder than to start over.
edgar-rft has joined #lisp
<Xach>
tychoish: more fixes needed for cl-grip and sbcl 2.0.9
<bhartrihari>
Writing a standardized spec for that is a task in itself. Unless there's some ABI standard out there that fits the bill well.
<beach>
What kind of things would you expect in such a specification?
<beach>
Exact layout of objects? Calling conventions I suppose.
<bhartrihari>
I think layout is fine. But calling conventions would probably take it too close to the compilation target. I would like to see something that both sbcl and ECL can conform to.
tamarindo has quit [Quit: Leaving]
tamarindo has joined #lisp
<beach>
Oh!
<bhartrihari>
I do need to do more readings in ABI specs before setting expectations on that though.
<beach>
Yes, I see.
<beach>
For object layout, you may want to look in the SICL specification. I am using what I think is the simplest possible layout that will still allow for decent performance.
<bhartrihari>
Thanks. Will do.
refpga has quit [Remote host closed the connection]
supercoven_ has joined #lisp
<phoe>
also you will want to do some sort of memory management in the ABI I guess
<phoe>
I mean, you will want to specify whose GC is supposed to work on a given object
<phoe>
(unless I misunderstand the problem)
supercoven has quit [Ping timeout: 240 seconds]
<sm2n_>
does it really matter, as long as you can convert to and from the format you make to whatever format the implementation in question uses?
Gerula has quit [Read error: Connection reset by peer]
sm2n_ is now known as sm2n
tamarindo has quit [Quit: Leaving]
tamarindo has joined #lisp
tamarindo has quit [Remote host closed the connection]
tamarindo has joined #lisp
dmiles has quit [Ping timeout: 265 seconds]
<phoe>
then we already have this
<phoe>
it's called CFFI
kaftejiman has joined #lisp
EvW has quit [Ping timeout: 244 seconds]
<bhartrihari>
Though for now, I wasn't thinking of the possibility of two implementations running a piece of code simultaneously (that's the only case that comes to mind where we have competing GCs). Only at how that standardization can help with image based programming.
<bhartrihari>
I mean, two implementations calling into the same binary.
<bhartrihari>
I guess what it comes down to is perhaps to have a standard way to represent the "world", which multiple implementations can use.
<beach>
bhartrihari: But then the question is, what makes the difference between different implementations? Currently object layout (closely related to memory management) is an important part of that.
srhm has quit [Read error: Connection reset by peer]
<bhartrihari>
I would need to think more about that.
Achylles has joined #lisp
<beach>
Sure. Take your time. :)
enrio has joined #lisp
enrio has quit [Remote host closed the connection]
frost-lab has quit [Quit: Connection closed]
<aaaaaa>
Hi all. Have anybody used Lisp for static webpage generation? I would be interested in how it was done
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
* adlai
has yet to patiently read the entire document, although it should be much more interesting than https://www.cliki.net/LLGPL and its ilk
skapata has joined #lisp
<beach>
If you feel more comfortable asking questions about it, that's fine too.
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
Alloc has quit [Ping timeout: 240 seconds]
Alloc has joined #lisp
Lord_Nightmare has quit [Ping timeout: 260 seconds]
* adlai
is currently targeting a childishly simple goal: reducing the number of forks hosted under github.com/adlai that exist for the sole purpose of an open pull request
<adlai>
perhaps a "premature optimization", for "quarter-life crisis" values of maturity?
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
Alloc has quit [Ping timeout: 260 seconds]
Alloc has joined #lisp
<adlai>
the practical relevance is that I am wondering whether to adopt the websocket client library, due to the uncertain status of its dependency, 8arrow's library event-emitter
emys has quit [Ping timeout: 264 seconds]
emys has joined #lisp
<adlai>
this is skew-parallel, and not quite orthogonal, to the licensing uncertainty hovering over scalpl.
* adlai
can't even recall whether the author's IRC nick is 8arrow or nitro_idiot ; either way, does not seem to be here right now :(
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<adlai>
I realize my current goal is arguably a waste of time; however, since my primary purpose is turning a throwaway prototype into a tool both useful and worthy of publication, and this tool is explicitly for use by for-profit enterprises, it does seem counterproductive to rely on free services.
jonatack has joined #lisp
<edgar-rft>
Let's start a service that's only goal is to make others pay money and serve nobody
<rumbler31_>
it appears that if the argument is a constant, then a lambda is returned that tests a random object var against the specified type, otherwise
<rumbler31_>
the lambda calls typep on a random object name and a random type name, right?
uniminin has quit [Client Quit]
uniminin has joined #lisp
uniminin has quit [Max SendQ exceeded]
uniminin has joined #lisp
<rumbler31_>
the code looks deceptively simple and short but i'm having trouble figuring out what it does, and what machinery behind define-compiler-macro makes it necessary
uniminin has quit [Remote host closed the connection]
emys has quit [Ping timeout: 256 seconds]
<adlai>
rumbler31_: it's worth noting that code using define-compiler-macro should always have identical correct behavior when the forms defining the compiler macro are deleted
<adlai>
no guarantees about consistent failures, nor efficiency; although, compilers are allowed to ignore define-compiler-macro
* adlai
begins to experience anger after too much time reading common lisp in github's website, and finds himself nostalgic for paste.lisp.org
<rumbler31_>
I miss paste too....
<rumbler31_>
running the code in the repl was illuminating. I see that we are returning forms, not the lambdas themselves
<adlai>
correct, the function in question builds a lambda form, that can be compiled into a function
<adlai>
you may want to avoid thinking of the given arguments as "random", and instead just call them the given object name, and given type name.
emys has joined #lisp
<adlai>
rumbler31_: the author[s] have published their own chat website, in another repository under that same account, in case you want to contact them directly; although please remember to update, in here, if you learn something surprising in answer to your questions there
oxum has quit [Remote host closed the connection]
<rumbler31_>
the authors of paste?
<rumbler31_>
oh you mean of the code i'm reading
<rumbler31_>
coffee hasn't kicked in yet
<rumbler31_>
I'm trying to play in the repl to understand the output of the function a little better
oxum has joined #lisp
<adlai>
the function in question probably returns a lambda form, instead of a literal function, to avoid preventing serialization of compiled code.
<rumbler31_>
preventing serialization?
<adlai>
yes; if you modify the code you are running so that it returns #'(lambda ...) instead of '(lambda ...), it will return a literal function object
<adlai>
that will work when you test it interactively, although it will almost certainly fail in certain compilation scenarios.
Gerula has joined #lisp
* adlai
forgets the precise syntax for doing this bad idea with quasiquote, although it is probably `#'(lambda ... ,etc)
oxum has quit [Ping timeout: 265 seconds]
<adlai>
eh, "quasiquote" is a library. I should've just written "backquote".
oxum has joined #lisp
Psycomic has joined #lisp
mangul has joined #lisp
<rumbler31_>
hmm
emys has quit [Ping timeout: 265 seconds]
habeangur has quit [Ping timeout: 256 seconds]
<adlai>
I hope you aren't also trying to unread projects that are removed from quicklisp... that is the garbage collector's job, not yours.
<rumbler31_>
:-)
emys has joined #lisp
<rumbler31_>
I need more practice reading code I didn't write
galex-713 has quit [Ping timeout: 272 seconds]
<adlai>
ok, read all of scalpl. it is terrible code, hitting almost all the nasty twisted corners of the standard, and it works.
* adlai
is available for questions
<adlai>
"all of XYZ" = dependencies, too :)
<adlai>
if there is a specific part of the standard that you wish to see in use, please designate it.
Achylles has quit [Quit: Leaving]
Lord_Nightmare has joined #lisp
<adlai>
if you prefer reading better code, you can always just read your compiler.
emys has quit [Ping timeout: 246 seconds]
Alfr_ has quit [Quit: Leaving]
emys has joined #lisp
nitrowheels has quit [Quit: Leaving]
nitrowheels has joined #lisp
emys has quit [Ping timeout: 265 seconds]
mangul is now known as shangul
nitrowheels has quit [Quit: Leaving]
scymtym has joined #lisp
toorevitimirp has quit [Quit: Konversation terminated!]
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
jesse1010 has joined #lisp
Xach has quit [Remote host closed the connection]
Inoperable has quit [Remote host closed the connection]
ak-coram has quit [Remote host closed the connection]
cosimone has joined #lisp
terpri_ has joined #lisp
terpri has quit [Ping timeout: 260 seconds]
drl has quit [Quit: Ex-Chat]
EvW has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
karlosz has quit [Quit: karlosz]
heisig has quit [Quit: Leaving]
pankajsg has quit [Ping timeout: 258 seconds]
EvW has joined #lisp
daphnis has joined #lisp
<daphnis>
what's the cl equivalent of echo foo >bar, where bar is a named pipe? (with-open-file (s "bar" :direction :output :if-exists :supersede) (format s "foo")) doesn't seem to work.