<Nilby>
it works, but seems like it can cause trouble and subverts many assumptions about keywords
<White_Flame>
I don't think anything is specified about it
<White_Flame>
in terms of special case
<White_Flame>
but yeah, what Nilby said
<euouae>
alright, thank you
<euouae>
11.11.2.3 mentions "Any individual symbol can be added to a package by use of import."
<Nilby>
like (eq :foo :bar) => T , would really break your assumptions reading code
<euouae>
right
Inline_ has joined #commonlisp
Oladon has quit [Quit: Leaving.]
Inline__ has quit [Ping timeout: 252 seconds]
EsoAlgo8 has joined #commonlisp
EsoAlgo has quit [Read error: Connection reset by peer]
EsoAlgo8 is now known as EsoAlgo
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 252 seconds]
anticomputer_ has joined #commonlisp
anticomputer has quit [Ping timeout: 255 seconds]
cyberbanjo has quit [Remote host closed the connection]
<euouae>
Is this macro correctly written? <https://plaster.tymoon.eu/view/3512> I just wrote it for fun, but I'm not sure if it's right. Aside from the _ symbol leaking
cyberbanjo has joined #commonlisp
<nij->
seems correct to me.
<nij->
(let ((x 4) (y 3) (z 2) (w 1)) (funcall (partial-application f x y _ z _ w _ _) 1 2 3 4)) ;; => 20
<euouae>
nice
<beach>
Since the IF special form returns a value, you can write COLLECT (IF (EQ X '_) (POP VARIABLES) X)
<nij->
euouae I also find macroexpansion handy.
<nij->
It expands to: #'(lambda (#:g397 #:g398 #:g399 #:g400) (f x y #:g397 z #:g398 w #:g399 #:g400))
<beach>
euouae: Oh, and you should skip the #' in front of (LAMBDA ...)
<euouae>
Why do you say so? I read some info on a google CL style page that it's a stylistic thing for a project
<beach>
I am saying it because there is pretty much a consensus now that it should be dropped.
<beach>
The macro LAMBDA exists so that you can drop the #'.
<euouae>
sounds right
Inline_ has joined #commonlisp
nij- has quit [Ping timeout: 260 seconds]
Lord_of_Life has quit [Ping timeout: 252 seconds]
Lord_of_Life has joined #commonlisp
Inline__ has quit [Ping timeout: 260 seconds]
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 260 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 252 seconds]
aartaka has joined #commonlisp
aartaka has quit [Ping timeout: 260 seconds]
Inline__ has joined #commonlisp
aartaka has joined #commonlisp
Inline_ has quit [Ping timeout: 260 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 260 seconds]
Inline__ has joined #commonlisp
euouae- has joined #commonlisp
Inline_ has quit [Ping timeout: 246 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 246 seconds]
aartaka has quit [Ping timeout: 252 seconds]
Inline__ has joined #commonlisp
aartaka has joined #commonlisp
Inline_ has quit [Ping timeout: 248 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 260 seconds]
Inline__ has joined #commonlisp
<euouae>
on 11.1.2.3.2 it is said "it is generally not wise for a program to use a keyword[1] as a property indicator, since if there were ever another program that did the same thing, each would clobber the other's data."
<euouae>
What is meant by that? Isn't a plist such as (:foo 1 :bar 2) pretty common?
Inline_ has quit [Ping timeout: 260 seconds]
euouae- has left #commonlisp [#commonlisp]
<beach>
I think they are referring to the property lists of symbols.
<euouae>
Hmm, I see
<euouae>
okay, thank you
igemnace has joined #commonlisp
Inline_ has joined #commonlisp
<beach>
But even those property lists do not represent a problem, provided the package system is used correctly.
<beach>
I am accumulating evidence that the package system was underused when the standard was written.
Inline__ has quit [Ping timeout: 260 seconds]
<beach>
The use of class names to prefix accessors is one practice that suggests this idea.
<euouae>
I see
Inline_ has quit [Ping timeout: 260 seconds]
<beach>
The paragraph in 11.1.2.3.2 seems to suggest that two different programs would use the property list of a symbol that is shared between those programs, and that's definitely not recommended.
<euouae>
programs in what sense?
<euouae>
running concurrently under the lisp image?
<beach>
Two different applications or libraries.
<beach>
Yes.
<White_Flame>
and interactive programs might not be "running" full time, as the user calls functions from multiple things to execute behavior
<White_Flame>
but their state would still trample if they shared symbol-plist storage etc
<White_Flame>
lisp has a history as an OS or operating environment where the user did many things within the single running image
<euouae>
Right, I've at least heard about that, symbolics
<White_Flame>
even before then
<beach>
It's the superior way of doing it. Unfortunately, current systems, and even previous ones like Genera, do not take into account the security problems that now exist.
<euouae>
security wise there's been quite an evolution certainly
<euouae>
are there any cool applications of types of CL? or can the subject be mostly ignored?
<beach>
Er, what?
<beach>
Types are omnipresent in Common Lisp.
<beach>
Security has sort of evolved. But the solution most operating systems use is that of processes, which is like killing a fly with a sledgehammer.
<phoe>
the condition system is a good example
<phoe>
the class system is something good too, since classes kinda grew from types
rgherdt has joined #commonlisp
<phoe>
the whole concept of array specialization is also fun to notice
<beach>
Same for streams.
<euouae>
suppose I have a made a type (square-matrix type size)
<euouae>
How can it be used? (it's a 2D array of square size)
<beach>
That's kind of asking the question the wrong way. It is better to state what problem you are trying to solve, and then perhaps see how defining a type might provide a solution.
<euouae>
how can I give an object this type?
aartaka has quit [Ping timeout: 248 seconds]
aartaka has joined #commonlisp
<beach>
Objects are not "given" types in Common Lisp. An object "is" of one or more types.
<euouae>
I see. So in a function, I could look up its type and match it to square-matrix with subtypep
<White_Flame>
each object is an instance of a class. a type is a descriptor/predicate/range/etc which can overlap and a single type may match disparate classes
<White_Flame>
the simplest type of type is just a class, though
<White_Flame>
*class name
<euouae>
to make use of a type, you'd use typep and subtypep right?
<White_Flame>
yep
<aeth>
and typecase and check-type
<euouae>
ah I see
<aeth>
I think that the closest thing to "giving" a type in the CL world would be COERCE, which converts from one type to another. But it won't work on many things. Mostly numbers and sequences.
<aeth>
But everything already has a type (actually, at least one) to begin with
<White_Flame>
everything already matches an infinite number of types ;)
<euouae>
I've heard before that the CL type system isn't as powerful as ML etc. I'm trying to imagine why. I think part of it is because there's no function types apart from a single function type?
<White_Flame>
since (or fixnum null) matches every fixnum, and keep adding as many irrelevant OR clauses ad infinitum
<euouae>
beach, I think you mean that CL can. But can CL express positive only integers?
<beach>
Of course.
<phoe>
euouae: (integer 1)
<euouae>
What about the type of primes? :P
<phoe>
(satisfies primep)
<White_Flame>
there's always SATISFIES types
<beach>
phoe: You beat me to it.
<phoe>
the fastest typewriter in the west
<phoe>
(that's a nice accidental pun, I enjoy it)
<beach>
Heh!
<aeth>
any integer except 0 is (or (integer * -1) (integer 1 *)) or alternatively (not (integer 0 0))
<aeth>
SATISFIES types aren't really something the compiler can take advantage of afaik
<White_Flame>
(and integer (not (integer 0 0)))
<aeth>
oh, sorry
<beach>
(and integer (not (eql 0)))
<aeth>
so it's (or (integer * -1) (integer 1 *)) OR (not (integer 0 0)) OR (and integer (not (eql 0)))
<aeth>
as well as some other ways, but again, prefer not to use satisfies types, e.g. (and integer (not (satisfies zerop)))
<aeth>
ugh I did it again, I copied mine, not White_Flame's
<aeth>
it's (and integer (not ...)) if you're building it from NOTs
tibfulv has quit [Remote host closed the connection]
<beach>
euouae: Common Lisp has the most powerful type system of all the ones I have learned about. It is not decidable, of course, which is what the static-typing crowd wants. But Common Lisp is a dynamically typed language, so decidability is not a requirement.
<euouae>
beach, for example in Rust the type system is very nicely utilized in terms of parallelism to avoid MOVEing stuff when you shouldn't. I can't remember the specifics but I can look it up if you want
tibfulv has joined #commonlisp
<euouae>
Does CL have something similar?
<aeth>
sounds like something you'd do with a macro in CL instead of with types
<beach>
I seem to recall that Rust is a statically typed language, so the detection of problems is done at compile time. In general, in Common Lisp, such situations would be detected at run-time.
<phoe>
euouae: Rust avoids being GCed whereas CL is garbage collected, so that's two completely different strategies of memory management
<beach>
euouae: If you try to do in Common Lisp what you would typically do in a statically typed programming language, in terms of compile-time checks, you are out of luck.
<phoe>
(though some strategies for having that sort of facilities exist, so you're not *completely* out of luck)
<aeth>
CL is technically gradually typed in that it's a dynamically typed language that supports some static typing, but in general, implementations cannot portably assume that most things *can't* be recompiled outside of the current file (or other compilation-unit) being compiled. So any kind of errors caught with declared types or inferred types will be restricted to being in the same file file and mostly
<aeth>
to the internals of one function.
<aeth>
It can be done, though.
<phoe>
(e.g. SBCL can detect some type mismatches at compilation time if you declare types evewyehere, and there are DSLs like Coalton that take this idea even further)
<aeth>
If you want things to be detected at compile time outside of this, you'd want some kind of macro with metadata
<beach>
euouae: There is this unspoken but "obvious truth" (to the static-typing crowd) that more compile-time checks is better. But those represent a development cost that that crowd keeps quiet about. They choice of a language should be dictated by a careful compromise between run-time "safety" and cost. I might not use SBCL to fly an airplane, but there is no need to use a statically typed programming language in a spreadsheet or a wor
<beach>
processor.
<White_Flame>
I can't stand the traditional edit/compile/run cycle
<beach>
Yes, that's a large part of the cost.
<White_Flame>
and the inability of REPL-less languages to simply test calling functions
<beach>
Plus, most of the time, your program is incomplete, so it can't be statically typed.
<White_Flame>
instead of having to compile in static code to do that for you on the next run :-P
<euouae>
I see
shka has joined #commonlisp
<aeth>
I think you can mostly do it (or almost totally do it if you go the elaborate DSL or macro route), but nobody does because it's not the CL culture.
<aeth>
CL could probably give you much deeper integration to the base language than something like TypeScript on top of JavaScript. But TypeScript is not JavaScript. And the cultures are different. So you'd probably wind up with a new language anyway.
<euouae>
yeah I'm not trying to go against the grain but I wanted to understand how types can be leveraged for good things
<euouae>
It seems that they're useful for the exception system of CL
<White_Flame>
type declarations are used for correctness (the compiler statically and/or dynamically verifying that things match the expected types), and for optimization
<White_Flame>
and of course testing & branching on types
<aeth>
oh, it's called a condition system not an exception system because they're continuable, most trivially (defun foo (x) (check-type x integer) (* x 2)) (foo "hi") ; you can provide a valid value since "hi" isn't an integer and then continue on
<phoe>
an exception system is most often "unwind the stack first, think second"
<phoe>
the CL condition system reverses these two and also makes unwinding optional
amb007 has joined #commonlisp
gjvc has joined #commonlisp
<phoe>
FYI there's a whole book on the condition system that explains the design rationale and its implementation and how it differs from the "traditional" exception handling popularized by c++ and java and python and what not
aeth has joined #commonlisp
<phoe>
(and I know the author, he's kinda fun)
<euouae>
ah nice
aeth_ has quit [Client Quit]
<jackdaniel>
I see that there are more humble and nice people on this # besides me
<jackdaniel>
that's nice
<phoe>
yes, obviously
amb007 has quit [Ping timeout: 255 seconds]
<beach>
I believe I have met the author a few times, too.
<euouae>
I think I should probably learn how to use the debugger
<euouae>
That is implementation-specific, right?
<phoe>
if you use something like slime then not really
<euouae>
Ah got it. Yeah I use slime
<phoe>
the slime debugger interface is very much the same for all implementations, even if the internals are different
<jackdaniel>
slime is not an acceptable debugger in 3 2 1 ;)
<phoe>
while we're at it, cl is not an acceptable lisp
<beach>
euouae: Unfortunately, FLOSS Common Lisp implementations have sub-optimal debugging support at this time. So depending on how much you have used debuggers in the past, you may or may not be disappointed.
MajorBiscuit has joined #commonlisp
<euouae>
Ah, I suppose that is one of the features of a proprietary implementation
<beach>
It looks like it is the same functionality as most other "debuggers", i.e., it's mainly a backtrace inspector.
<beach>
The "debugger" is invoked when an unhandled error is signaled, and you are given the possibility to inspect the current active stack frames, and you can invoke a restart.
amb007 has joined #commonlisp
frgo has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
<AadVersteden[m]>
I don't think debugging tools are that bad in Common Lisp to be honest. There is a wide set of tools that in total help you to debug code and there are a few vastly superior systems in Common Lisp. I greatly miss a stepper but that might just be a broken Sly configuration.
<beach>
If you are happy with what there is, then that's fine.
<AadVersteden[m]>
SBCL's type system catches about the same amount of silly errors as TypeScript does, but with much less typing, tracing functions helps a lot for functions that are called a lot, and SLY's stickers can be rather informative of some cases. That's functionality I don't seem to find in other languages.
<beach>
I would like to be able to set a breakpoint in some code, without recompiling, perhaps code that is going to be executed after a restart has been invoked. And then I would like to be able to step after that breakpoint is hit.
<AadVersteden[m]>
beach: Yes, I want that too. That's what I miss here. But I miss the other features in other languages so at least it's a mixed bag.
<AadVersteden[m]>
I wouldn't mind recompiling the code if it can happen in the background.
<beach>
But if the code is already on the stack, then recompiling it will not do the trick. It would then be a different function from the one on the stack.
<AadVersteden[m]>
beach: if compiled with with the right debug settings, can't SLY/SLIME do the stepping?
<beach>
The stepper exists, but it has to be done from the REPL. I want to be able to step from a breakpoint of my choice.
<beach>
But since we can't set breakpoints without recompiling, then that's not possible.
<AadVersteden[m]>
beach: I doubt you can have the optimization cake and eat the debugging cherry too. It would at least be complex.
<beach>
GDB does it easily.
<AadVersteden[m]>
Yeah, but "a sufficienly smart compiler can handle it" is not something that GDB had to take into account.
<AadVersteden[m]>
But I guess you don't intend to have this for `(optimize (debug 0))` ?
<beach>
I think what I have to say is already in that paper, including what Allegro does, for instance.
<beach>
I don't quite understand the reference to the sufficiently smart compiler either. Oh, well.
<AadVersteden[m]>
beach: That's an argument that was used during the Common Lisp standardization I thought?
* AadVersteden[m]
missed the link to the paper, hope to read at some point :-)
<beach>
An argument in favor of what?
<AadVersteden[m]>
I suppose that was used when adding features to the language. If that statement was effectively used, then I would assume the compiler to be more complex. Inspecting the resulting code and mapping it back to the sources may be harder then. But either case, I should read the paper first, this will be a repetition of what you already wrote down otherwise.
<euouae>
the paper says the issue boils down to breakpoints affecting the entire lisp image
<beach>
AadVersteden[m]: I don't think it is that hard to create a debugger for Common Lisp. What I think is that the typical users of a Common Lisp system don't seem to be used to using advanced debugging tools, so they firmly believe we have the best development environment that exists, all languages considered. Unfortunately, they are wrong.
<AadVersteden[m]>
beach: Then my statement holds again. We have great tools that are totally different than what other systems offer, but we also lack the systems I've grown used to out of the lisp ecosystem. It's not all bad.
<beach>
OK.
euouae has quit []
<AadVersteden[m]>
beach: To make a case though: it's been vastly simpler for me to optimize some lisp code with respect to parsing than what I could do in Elixir. Part of that is going to be due to me lacking knowledge, but part of it is compiler hints. Not exactly debugging but somewhere close. I would love a "normal" debugger to be added to the mix akin to what you find in your browser when executing readable javascript code.
aartaka has quit [Ping timeout: 260 seconds]
<beach>
I too prefer Common Lisp to other languages for a variety of reasons. But I am a researcher, and I am not about to be content with the current situation when I think I know how to improve it.
aartaka has joined #commonlisp
szkl has joined #commonlisp
glaucon has quit [Quit: WeeChat 3.5]
amb007 has joined #commonlisp
nij- has joined #commonlisp
Bung has joined #commonlisp
Inline has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
Inline_ has joined #commonlisp
Madsy has quit [Ping timeout: 260 seconds]
Inline has quit [Ping timeout: 255 seconds]
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 260 seconds]
Inline_ has joined #commonlisp
aartaka has quit [Ping timeout: 252 seconds]
aartaka has joined #commonlisp
Inline__ has quit [Ping timeout: 260 seconds]
Inline__ has joined #commonlisp
amb007 has joined #commonlisp
Madsy has joined #commonlisp
Madsy has quit [Client Quit]
Inline_ has quit [Ping timeout: 260 seconds]
<ecraven>
does anyone know here know how swank/sly use threads internally? is there one thread for communication with slime, and the "repl" that is used to evaluate things is in *another* thread (so that if this blocks, emacs can still communicate with swank)?
amb007 has quit [Ping timeout: 246 seconds]
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 252 seconds]
epony has joined #commonlisp
<nij->
(sb-thread:list-all-threads) from a sly mrepl shows that there is at least
<nij->
and
<nij->
#<SB-THREAD:THREAD "Slynk Sentinel" waiting on:
<jcowan>
beach: fwiw, the Self papers talk about how debugging is done in Self on the same stack: there is a full decompiler that allows deoptimizing code so that it can be debugged as if in an interpreter
<Bike>
huh, didn't know javascript also got its JIT stuff from self
nij- has quit [Ping timeout: 255 seconds]
aartaka has quit [Ping timeout: 252 seconds]
aartaka has joined #commonlisp
azimut_ has quit [Remote host closed the connection]
pve has joined #commonlisp
Dynom_ has joined #commonlisp
azimut has joined #commonlisp
Dynom_ is now known as Guest7474
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 255 seconds]
aartaka has quit [Ping timeout: 268 seconds]
aartaka has joined #commonlisp
<jcowan>
also, errors in spreadsheet programs can be quite as lethal as errors in avionics software, if less obviously so
<jcowan>
(though the typical error is in the spreadsheet itself, considered as a functional program, as opposed to the spreadsheet software)
<jcowan>
Ray Panko at UHawaii has been studying spreadsheet errors (of the second type) for a long time, and estimates that almost 90% of spreadsheets have one or more undetected errors
<jcowan>
(where "error" means that 1% or more of cells defined by formulas have incorrect formulas)
<Bike>
::notify euouae no, clasp does not have breakpoints. i don't see where in the manual it says otherwise.
<Colleen>
Bike: Got it. I'll let euouae know as soon as possible.
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
seok has quit [Read error: Connection reset by peer]
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 260 seconds]
frgo has quit [Remote host closed the connection]
amb007 has joined #commonlisp
<beach>
jcowan: Thanks.
amb007 has quit [Ping timeout: 255 seconds]
jeosol has joined #commonlisp
cosimone has quit [Read error: Connection reset by peer]
pranavats has left #commonlisp [Error from remote client]
zacque has quit [Quit: Goodbye :D]
nij- has joined #commonlisp
nij_ has joined #commonlisp
nij- has quit [Killed (NickServ (GHOST command used by nij_))]
nij_ is now known as nij-
nij- has quit [Remote host closed the connection]
nij- has joined #commonlisp
<nij->
How to import (only) the symbol 'with from the package :rutils into :cl-user?
<beach>
Why would you import a keyword? They are always accessible.
<beach>
And the name of the package is probably "CL-USER" and not ":cl-user"
<nij->
Oh, the package is called "rutils", I want to import the symbol rutils:with.
<pjb>
(in-package :cl-user) (import 'rutils:with)
<White_Flame>
(import 'rutils:with)
<nij->
As easy as it sounds. Nice :D
<pjb>
also: (import 'rutils:with :cl-user)
amb007 has joined #commonlisp
copec_ has joined #commonlisp
copec has quit [Quit: checkity check out.]
copec_ is now known as copec
jeosol has quit [Quit: Client closed]
amb007 has quit [Ping timeout: 260 seconds]
pranavats has joined #commonlisp
tyson2 has joined #commonlisp
ec_ has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 260 seconds]
ec_ has joined #commonlisp
frgo has joined #commonlisp
aartaka has joined #commonlisp
nij- has quit [Ping timeout: 252 seconds]
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 252 seconds]
nij- has joined #commonlisp
seletz_ has joined #commonlisp
azimut_ has joined #commonlisp
azimut has quit [Ping timeout: 255 seconds]
seletz has quit [Ping timeout: 260 seconds]
Inline__ has joined #commonlisp
amb007 has joined #commonlisp
Inline_ has quit [Ping timeout: 268 seconds]
cosimone has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
Cymew has quit [Ping timeout: 260 seconds]
morganw has joined #commonlisp
<nij->
I wrote a function to wait for a FIFO to be opened. It will then read the content in the FIFO. However, sometimes right after the FIFO is opened, it seems to start reading too quickly. In that case, it seems that it actually block the FIFO writer to write.. A kludge I did is to add a (sleep 0.1) after noticing the FIFO is opened (https://bpa.st/VYPQ). I wonder what's a better way to solve this.
Inline_ has joined #commonlisp
vn36 has joined #commonlisp
Inline__ has quit [Ping timeout: 268 seconds]
prokhor_ has joined #commonlisp
Bung has quit [Quit: Leaving]
<beach>
I have no solution for you, but I am wondering about the purpose of the PROGN.
jmdaemon has joined #commonlisp
<jackdaniel>
if you are into busy loops already, just do (loop until (listen fifo))
causal has quit [Quit: WeeChat 3.7.1]
Inline__ has joined #commonlisp
amb007 has joined #commonlisp
thuna` has joined #commonlisp
azimut_ has quit [Ping timeout: 255 seconds]
Inline_ has quit [Ping timeout: 260 seconds]
amb007 has quit [Ping timeout: 252 seconds]
<nij->
jackdaniel hmmm this is what I try.. however, after your loop form, lisp still hangs there https://bpa.st/IF4A
Inline_ has joined #commonlisp
Inline__ has quit [Ping timeout: 260 seconds]
joast has joined #commonlisp
Inline__ has joined #commonlisp
seletz_ has quit [Ping timeout: 260 seconds]
aartaka has quit [Ping timeout: 255 seconds]
Inline_ has quit [Ping timeout: 260 seconds]
lisper29 has joined #commonlisp
aartaka has joined #commonlisp
amb007 has joined #commonlisp
<beach>
Oh well.
aartaka has quit [Ping timeout: 268 seconds]
amb007 has quit [Ping timeout: 252 seconds]
CptKirk has joined #commonlisp
aartaka has joined #commonlisp
<nij->
beach I see what you mean. I don't need a progn there. Thanks :)
<beach>
Sure.
pranavats has left #commonlisp [Disconnected: Hibernating too long]
pranavats has joined #commonlisp
aartaka has quit [Ping timeout: 260 seconds]
aartaka has joined #commonlisp
Inline_ has joined #commonlisp
ec_ has quit [Remote host closed the connection]
vn36 has quit [Ping timeout: 260 seconds]
Inline__ has quit [Ping timeout: 260 seconds]
ec_ has joined #commonlisp
szkl has quit [Quit: Connection closed for inactivity]
Oladon has joined #commonlisp
seletz has joined #commonlisp
aartaka has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
aartaka has joined #commonlisp
nij- has quit [Ping timeout: 260 seconds]
amb007 has quit [Ping timeout: 255 seconds]
seletz has quit [Ping timeout: 260 seconds]
aartaka has quit [Ping timeout: 268 seconds]
Inline__ has joined #commonlisp
Inline_ has quit [Ping timeout: 268 seconds]
pjb has quit [Read error: Connection reset by peer]
seletz has joined #commonlisp
cosimone has quit [Ping timeout: 268 seconds]
MajorBiscuit has quit [Ping timeout: 252 seconds]
seletz has quit [Ping timeout: 252 seconds]
morganw has quit [Remote host closed the connection]
mathrick has quit [Ping timeout: 252 seconds]
lisper29 has quit [Quit: Leaving]
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
mathrick has joined #commonlisp
ttree has joined #commonlisp
seletz has joined #commonlisp
pdietz has joined #commonlisp
Volt_ has quit [Quit: ]
jeosol has joined #commonlisp
pranavats has left #commonlisp [Disconnected: Hibernating too long]
morganw has joined #commonlisp
amb007 has joined #commonlisp
pranavats has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
Inline_ has joined #commonlisp
cage has joined #commonlisp
boigahs has joined #commonlisp
Inline__ has quit [Ping timeout: 260 seconds]
Oladon has quit [Quit: Leaving.]
waleee has joined #commonlisp
mathrick has quit [Ping timeout: 268 seconds]
cosimone has joined #commonlisp
mathrick has joined #commonlisp
nij- has joined #commonlisp
amb007 has joined #commonlisp
cosimone has quit [Remote host closed the connection]
jeosol has quit [Quit: Client closed]
amb007 has quit [Ping timeout: 252 seconds]
Inline__ has joined #commonlisp
jackdaniel has quit [Changing host]
jackdaniel has joined #commonlisp
haoms has joined #commonlisp
Inline_ has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
karlosz has joined #commonlisp
mathrick has quit [Read error: Connection reset by peer]
mathrick has joined #commonlisp
Oladon has joined #commonlisp
pdietz has quit [Quit: Client closed]
mathrick has quit [Ping timeout: 260 seconds]
haoms has left #commonlisp [#commonlisp]
mathrick has joined #commonlisp
Bung has joined #commonlisp
vn36 has joined #commonlisp
Guest268987 has joined #commonlisp
Bung has quit [Remote host closed the connection]
Bung has joined #commonlisp
son0p has joined #commonlisp
tyson2 has quit [Remote host closed the connection]
igemnace has quit [Remote host closed the connection]
amb007 has joined #commonlisp
Bung has quit [Quit: Leaving]
amb007 has quit [Ping timeout: 252 seconds]
ec_ has quit [Ping timeout: 255 seconds]
ec_ has joined #commonlisp
pjb has joined #commonlisp
<nij->
Can I have a lisp send a very large matrix to another lisp (different process) using shared memory?