JohnMS_WORK has quit [Read error: Connection reset by peer]
schweers has quit [Remote host closed the connection]
schweers has joined #lisp
ravenousmoose has joined #lisp
JohnMS_WORK has joined #lisp
rople has joined #lisp
ravenousmoose has quit [Ping timeout: 246 seconds]
rople has quit [Client Quit]
rople has joined #lisp
chens has joined #lisp
scymtym has joined #lisp
<fiddlerwoaroof>
no-defun-allowed: ABCL ships JFLI in a contrib, which makes dealing with Java a lot nicer
<fiddlerwoaroof>
But, alot probably depends on what you're trying to accomplish
majeure has quit [Quit: Lost terminal]
<no-defun-allowed>
Most of the complexity is coming from the stupid obsfucation Minecraft has, so I had to write some methods which look up a table to translate the human friendly names (like posX) to crap (like field_12345)
raghavgururajan has quit [Read error: Connection reset by peer]
nwoob has joined #lisp
nanoz has quit [Ping timeout: 268 seconds]
manualcrank has quit [Quit: WeeChat 1.9.1]
ralt has joined #lisp
schjetne has joined #lisp
_whitelogger has joined #lisp
ggole has joined #lisp
libertyprime has quit [Quit: leaving]
libertyprime has joined #lisp
shka__ has joined #lisp
nowhere_man has joined #lisp
akoana has joined #lisp
nowhere_man has quit [Ping timeout: 276 seconds]
nowhere_man has joined #lisp
hhdave has joined #lisp
nanoz has joined #lisp
jgerman has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<no-defun-allowed>
drmeister: I made a terrible, terrible aimbot to test out the deswizzler (and I only had to provide one obsfucated name, thanks to god damn method overloading.)
<no-defun-allowed>
I guess I have to key my method table using all the Java classes...somehow.
jlarocco has quit [Ping timeout: 245 seconds]
m00natic has joined #lisp
nanoz has quit [Ping timeout: 246 seconds]
seok has joined #lisp
<seok>
which database does everyone use for their projects?
<jdz>
seok: I can't answer for anybody else, but I prefere PostgreSQL.
<shka__>
postgres is fine
<jackdaniel>
sqlite is great if you need a local database
<jackdaniel>
without much hassle to set it up
<seok>
Yeah, just wondering what everyone uses
<seok>
I'm using mongo for mine
<jackdaniel>
depends on requirements I suppose
<jackdaniel>
I'm certain you could find people who use the lisp image as their database
<jackdaniel>
and call save-lisp-and-die
grumble has quit [Ping timeout: 622 seconds]
<seok>
I'm stressing out whether I should swap to SQL as the lack of community of common-lisp - mongodb users make it difficult to ask for help in odd cases
flip214 has quit [Ping timeout: 245 seconds]
<shka__>
well, many people use postgres because of how fun postmodern is
<jackdaniel>
I'd switch unless you have a real need for something what is not SQL
<shka__>
to clarify ;-)
<seok>
I would love to use lisp image as a db, but I have doubts whether it would keep up with the performance standard of SQL or NoSQL DBs
<seok>
or at least the code I implement
<jackdaniel>
what can be faster then memory directly available for the process?
<jdz>
I've seen articles about how Postegres is a better Mongo.
<jackdaniel>
when you use external database you need to: a) speak some protocol (transmission), b) serialize/deserialize data (computing)
<jdz>
PostgreSQL can store and query JSON.
flip214 has joined #lisp
<jackdaniel>
however I could imagine a database in beach-envisioned system where your process simply gains access to the database memory
<seok>
What about data integrity? How can I be sure that data won't be lost in case of unexpected shutdowns
<jdz>
You can't.
<jdz>
Integrity does not safeguard from data loos, it just guarantees integrity of written data.
<jackdaniel>
I like this answer ↑ (and it is true)
<jonatack>
seok: did a one year project for the paris airports where we were required to use mongo... never again
<seok>
Would in-lisp database be just as secure as a full DB?
<jackdaniel>
seok: but yes, using "real" database will give you some guarantees which are not available in stock lisp image :)
<seok>
jonatack: yeah it's horrible eh?
<jonatack>
as the project evolved it became relation-centric rather than document-centric
<jonatack>
but no managerial will to allow us to change to SQL (we wanted to use postgres)
<seok>
If I could be convinced that a lisp database can be just as scalable and data-secure as full DB's, I would go for that right away
flip214 has quit [Ping timeout: 240 seconds]
Necktwi has joined #lisp
even4void has joined #lisp
<jonatack>
mongo was fun at first but if any risk of evolving toward needing a RDBMS instead... heh
nanoz has joined #lisp
flip214 has joined #lisp
<seok>
On what occasions did mongo underperform?
<jackdaniel>
seok: that was primarily meant as a joke, lisp image is not a way to go for managing data in any non-personal project. if it is a small project with single client use sqlite, otherwise use postgresql
techquila has joined #lisp
<seok>
I was hearing that aggregation is not so bad compared to joining in SQL
<jonatack>
mongo is the wrong choice for relational mapping without going down rabbit holes to accomodate/cascading updates and let's not get started about maintaining db integrity in that case
<jonatack>
anyway, ymmv :) but as for me, never again
cartwright has quit [Remote host closed the connection]
Lord_of_Life has quit [Ping timeout: 245 seconds]
<seok>
Ugh, I guess it might be good idea to do away with mongo then
<jonatack>
basically an SQL backend with maybe a mongo one for the document part would have been fine, but some manager sold the project as cheaper by speccing only having to deploy and admin mongo for everything
cartwright has joined #lisp
Lord_of_Life has joined #lisp
<jonatack>
the takeaway: if the value of the data is in the relationships between the data, then go for an RDBMS.
user___ has joined #lisp
<seok>
Well it's quite interesting you are writing apps in CL for commercial projects
<jonatack>
it was unfortunately not CL but a ruby/rails/react app but the database aspect should apply broadly
<jonatack>
had no say in the stack, was called in to save the damn thing
<jonatack>
wish I'd refused :p
<seok>
Was it a web app?
<jonatack>
part of it was a web app, the rest an internal management/AI tool to dump data from employees' heads as they were nearing retirement, centralise the data, and apply learning to it
<jonatack>
to automate tasks and probably hire fewer people, hopefully doing more interesting work without the dumb automated parts
<jonatack>
typical globo-corp software
libertyprime has quit [Ping timeout: 245 seconds]
nostoi has quit [Quit: Verlassend]
Necktwi has quit [Ping timeout: 245 seconds]
nowhere_man has quit [Ping timeout: 246 seconds]
stepnem_ is now known as stepnem
Necktwi has joined #lisp
libertyprime has joined #lisp
chens has quit [Read error: Connection reset by peer]
chens has joined #lisp
Necktwi has quit [Ping timeout: 246 seconds]
chens has quit [Remote host closed the connection]
Necktwi has joined #lisp
nwoob has quit [Ping timeout: 268 seconds]
vyorkin has joined #lisp
knicklux has quit [Remote host closed the connection]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
grumble has joined #lisp
dddddd has joined #lisp
vyorkin has quit [Remote host closed the connection]
ramus has quit [Ping timeout: 246 seconds]
ljavorsk_ has joined #lisp
ljavorsk has quit [Ping timeout: 276 seconds]
sellout- has quit [Ping timeout: 246 seconds]
sellout- has joined #lisp
nwoob has joined #lisp
rople has quit [Quit: rople]
rople has joined #lisp
EvW1 has joined #lisp
ramus has joined #lisp
patrixl has joined #lisp
alexanderbarbosa has quit [Read error: No route to host]
libertyprime has quit [Ping timeout: 276 seconds]
libertyprime has joined #lisp
jgerman has joined #lisp
jgerman has quit [Client Quit]
<ebrasca>
beach: I did some unit testing and I think testing is good.
seok has quit [Remote host closed the connection]
ljavorsk_ has quit [Quit: I'm out, bye]
ljavorsk has joined #lisp
<beach>
Yes, unit testing is good most of the time. Sometimes it is very hard to accomplish, though.
<beach>
And many times it is tedious if the technique used is to enumerate every possible case.
rople has quit [Quit: rople]
rople has joined #lisp
amerlyq has joined #lisp
<ebrasca>
beach: I try to make all cases.
<ebrasca>
beach: With one test I found it don't read last byte/char.
<ebrasca>
beach: Yea , for me it is very slow.
rople has quit [Ping timeout: 246 seconds]
bitmapper has joined #lisp
red-dot has joined #lisp
<thijso>
So naming... If I have a class that gets to an end state (giving an answer to for example 'find-node') using multiple rpc-exchanges, what would be a good name for such a class? rpc-process? rpc-action?
esrse has quit [Ping timeout: 268 seconds]
<thijso>
Hhmmm, maybe I shouldn't be generalizing too much. Something like find-node-<something>.
<beach>
It would be strange to have the name of a class start with a verb.
Cymew has quit [Ping timeout: 246 seconds]
<thijso>
yeah
<beach>
And I don't know what it means for a class to "get to an end state".
Cymew has joined #lisp
Cymew has quit [Client Quit]
Cymew has joined #lisp
<thijso>
Yeah, not the class, an instance of that class. And wording is bad. I mean a method of that class that gives the answer to 'find-node', which is an iterative process using 'rpc-exchange's to get to that answer
Cymew has quit [Client Quit]
Cymew has joined #lisp
<beach>
Classes don't have methods. Generic functions do.
orivej has joined #lisp
<beach>
And what does it mean for a method to give an answer to find-node?
gabiruh has quit [Quit: ZNC - 1.6.0 - http://znc.in]
gabiruh has joined #lisp
<beach>
What is the nature of `find-node'? Is it a function?
<thijso>
Its an rpc, a call to a different node
Bike has joined #lisp
<beach>
So what does it mean for a method to "give an answer to" an rpc?
<beach>
I am sorry for being so dense, but I truly don't understand.
<thijso>
It returns a list of nodes that were found
<beach>
I think I had better let others figure this out. I do not understand your terminology. I feel more stupid than usual. Sorry.
<thijso>
np
grumble is now known as \emph{grumble}
<beach>
Since nobody is answering, let me try again.
<beach>
Why does a particular remote call have a name?
<beach>
Does every call have a different name?
<ck_>
I thought about chiming in, but don't get the problem either
<ck_>
thijso: maybe show an invocation and the result of it, then people can tell you whether your naming is somehow unusual or not
<beach>
I am guessing that it is not a call that is named find-node, but some function that, when called, makes the remote procedure call. Am I understanding this right?
flamebeard has quit []
<beach>
ck_: So either we are both dense, or thijso is not being clear.
<thijso>
I'm probably not being clear. Indeed there are rpc calls being done to a different node (instance of the same code running on a different host/port/whatever). Some of them have a type :find-node and pass on a :node-id they want to find. The other side replies with the closest ones it knows and the requester iterates on those to find the one it wants (or ends up with x closest results, but not the actual one
<thijso>
as it doesn't exist (yet))
<thijso>
I'm thinking of making a class that keeps track of the iterations of the rpc calls it has done, keeping track of the replies (found nodes) it gets and removes the duplicate results from different nodes it has queried. In the end it should end up with the answer (1 node, or the x closest ones to that id)
<thijso>
Not sure if that clears it up or makes it worse...
<shka__>
p2p, right?
akoana has left #lisp ["Leaving"]
<thijso>
Yep, a Kademlia DHT implementation
<beach>
Now it makes more sense. But again, only instances of classes that are also functions do things, like "keep track", "remove", etc. Those would be generic functions specialized to some class.
<shka__>
instances of some class
<beach>
I meant "generic functions with methods specialized to some class".
<beach>
The specializer is usually a class.
<beach>
thijso: So a class could be called rpc-state, or find-node-state or something like that.
<shka__>
or perhaps query?
<shka__>
find-node-query
<thijso>
okay... lemme think about that
<beach>
thijso: And you would have one or more generic functions with methods specialized to that class for keeping track of the answers.
lucasb has joined #lisp
<thijso>
beach: I think we have different understandings of 'keep track'. In my view, the slots in the class are where the keeping track is happening, the method manipulate the data in those slots, but it's 'saved' in there. Or am I seeing this completely wrong?
<beach>
That's correct.
<beach>
A method specialized to the class would remove the duplicates. Not the class.
<thijso>
I'm thinking I like find-node-query. Well, not 'like', but it's the best I've seen
<thijso>
Yeah, agreed, beach
t58 has joined #lisp
<beach>
thijso: I was remarking on your saying that "it [referring to the class] gets and removes the duplicate results from different nodes it has queried"
<beach>
The class does none of these things. Nor an instance of it.
<shka__>
instances in cl are pretty much just data
<shka__>
and classes are just schemes for instances
EvW1 has quit [Ping timeout: 264 seconds]
<thijso>
yeah, I understand. I wasn't being clear. And I probably have too much bagage from other languages in there still.
<shka__>
it can be actually considered to be old school
<beach>
shka_: Except that it gets complicated, because a function is an instance of the class FUNCTION.
<thijso>
Or even, misconceptions brought over from other languages.
<shka__>
beach: i kinda omitted functions on purpose ;-)
Guest89 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
ljavorsk has quit [Ping timeout: 245 seconds]
awolven has quit [Ping timeout: 276 seconds]
orivej has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
X-Scale has joined #lisp
wxie has joined #lisp
EvW has joined #lisp
<ralt>
thijso: composition usually comes in handy there, where the instance would hold an "rpc" object in one of its slots, and the rpc object can manage caching and whatever is needed, and the methods just do e.g. (defmethod find-node ((node node)) (rpc-call (rpc node) :method :find-node :node-id ...))
dyelar has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
nwoob has quit [Ping timeout: 244 seconds]
wxie has quit [Ping timeout: 264 seconds]
smazga has joined #lisp
manualcrank has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
fitzsim has quit [Ping timeout: 268 seconds]
fitzsim has joined #lisp
q9929t has joined #lisp
red-dot has joined #lisp
Lord_of_Life has quit [Ping timeout: 276 seconds]
jprajzne has quit [Quit: Leaving.]
orivej has quit [Ping timeout: 268 seconds]
papachan has joined #lisp
orivej has joined #lisp
nwoob has joined #lisp
EvW has quit [Ping timeout: 276 seconds]
Lord_of_Life has joined #lisp
Oladon_work has joined #lisp
EvW has joined #lisp
schjetne has quit [Ping timeout: 245 seconds]
madand has joined #lisp
edgar-rft has quit [Quit: Leaving]
nwoob has quit [Ping timeout: 245 seconds]
q9929t has quit [Quit: q9929t]
madand has quit [Read error: Connection reset by peer]
vyorkin` has joined #lisp
Oddity has joined #lisp
cosimone has joined #lisp
v88m has quit [Ping timeout: 264 seconds]
seok has joined #lisp
<seok>
anybody use trivial-timeout or other equivalents?
shka_ has quit [Remote host closed the connection]
shka_ has joined #lisp
bitmapper has quit []
raghavgururajan has joined #lisp
schjetne has joined #lisp
nwoob has joined #lisp
warweasle has joined #lisp
m00natic has quit [Remote host closed the connection]
yoeljacobsen has joined #lisp
fragamus has quit [Ping timeout: 245 seconds]
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
mathrick has quit [Ping timeout: 276 seconds]
papachan has quit [Ping timeout: 246 seconds]
raghavgururajan has quit [Remote host closed the connection]
hhdave has quit [Quit: hhdave]
ark has joined #lisp
varjag has joined #lisp
Josh_2 has joined #lisp
seok has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 245 seconds]
<alandipert>
what are good references on compiling lisp? representation, transformation, heuristics, etc. i have PAIP and Lisp in Small Pieces, looking for others
yoeljacobsen has quit [Ping timeout: 240 seconds]
<Xach>
alandipert: those are a very good start!
<Xach>
alandipert: i have also seen recommended "anatomy of lisp"
<alandipert>
i have that one, i'm not sure what to make of it yet
<Xach>
i have nothing further to suggest, sorry
<aap>
hm maybe GLS' paper on his RABBIT compiler?
<aap>
it compiles scheme to a subset of maclisp
<Xach>
ah, that slipped my mind, those are good
aautcsh has joined #lisp
srji has quit [Ping timeout: 246 seconds]
curiouscain has quit [Quit: WeeChat 2.4]
nwoob has quit [Ping timeout: 246 seconds]
shifty has quit [Ping timeout: 268 seconds]
<ggole>
"Essentials of Compilation"
schjetne has quit [Ping timeout: 245 seconds]
gravicappa has quit [Ping timeout: 240 seconds]
davr0s_ has joined #lisp
davr0s has joined #lisp
vyorkin` has quit [Remote host closed the connection]
gabiruh_ has joined #lisp
gravicappa has joined #lisp
gabiruh has quit [Ping timeout: 250 seconds]
orivej has joined #lisp
awolven has joined #lisp
gareppa has joined #lisp
Xach has quit [Ping timeout: 268 seconds]
Xach has joined #lisp
lavaflow has quit [Ping timeout: 246 seconds]
mathrick has joined #lisp
Necktwi has quit [Remote host closed the connection]
ravenousmoose has joined #lisp
ggole has quit [Quit: Leaving]
nanozz has joined #lisp
gareppa has quit [Quit: Leaving]
nanoz has quit [Ping timeout: 276 seconds]
varjag has quit [Ping timeout: 276 seconds]
jmercouris has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
niceplace has quit [Ping timeout: 240 seconds]
niceplace has joined #lisp
amerlyq has quit [Quit: amerlyq]
sauvin has quit [Read error: Connection reset by peer]
lavaflow has joined #lisp
LiamH has joined #lisp
gravicappa has quit [Ping timeout: 268 seconds]
<remexre>
possibly lightly cursed, but
<remexre>
is there a type specifier for "there is an applicable method"
<remexre>
like, (can-call (x) (foo fixnum x x)) would apply to string iff there were a (defmethod foo ((_ fixnum) (_ string) (_ string))), etc
<Bike>
No. That's not determinable at compile time anyway.
<remexre>
I mean, eql isn't either :P
<Bike>
eql type specifiers are, because the object is right there
<Bike>
satisfies type declarations are generally discarded by the compiler
<remexre>
even on a check-type? or arguments to a defmethod?
<remexre>
to be clear I'm not trying to get better static warnings
<remexre>
I'm doing runtime checks
<Bike>
well, those aren't the compiler. i'm just saying compiler declarations are a major use of types and what you're describing would be totally useless there.
<Bike>
even at runtime it would be kind of tricky to determine what you're talking about
<Bike>
also, methods are specialized on classes, not types
<remexre>
ugh, right, that still trips me up
<remexre>
hm, would satifies + find-method be too footgunny?
<Bike>
also, there being applicable methods doesn't mean a call would be valid. for example you could have a gf with one primary method on fixnum, and one around method on T; then there would always be applicable methods, but it would be an error on anything but a fixnum
<Bike>
what are you trying to do overall?
<remexre>
I've got a function that takes either one of a couple of symbols, or a couple different classes, with the commonality being a single generic function they all have methods defined on
orivej has joined #lisp
<remexre>
and the method may not be called for a hot minute after the function is, so I'd rather fail fast than crash 20 minutes later
keep_learning has quit [Remote host closed the connection]
<Bike>
But you're anticipating changing the generic function enough that you can't just maintain a fixed list of what to allow?
<remexre>
this is a library; the "couple different classes" are end-user-extensible
<Bike>
right.
superkumasan has quit [Ping timeout: 276 seconds]
rippa has joined #lisp
<remexre>
as in like the user should be able to define more
<remexre>
the generic function is the extension point, not the couple of builtin classes that have methods for it
<pjb>
in CLOS.
cartwright has quit [Remote host closed the connection]
<Bike>
there's no guaranteed way to tell that a generic function has an effective method for a given list of classes. first off if there are any eql specializers it's hopeless, and secondly you can't determine that the applicable methods actually add up to an effective method with the given method combination.
edgar-rft has joined #lisp
<remexre>
pjb: yeah
cartwright has joined #lisp
<remexre>
hm, if I ban qualifiers, and the symbols are non-extensible (and I just allow them explicitly), that seems more tractable?
<Bike>
i'm not sure i understand the "symbols" here
<Bike>
and banning qualifiers kind of sucks, but you could do that, i guess
<remexre>
uh like if one passes t, it has its own semantics
<remexre>
idk, it still seems kinda surprising that there's no "could I call foo with these args"...
<Bike>
clos basically lets you execute arbitrary code to define what a call actually does
<Bike>
not being able to answer that question kind of follows along
<remexre>
well, I can execute arbitrary code at runtime :)
srji has joined #lisp
<Bike>
clos also generally assumes that when you're figuring out what a call does, you actually have all of the arguments. not just their classes.
<Bike>
it's very runtime oriented itself
<remexre>
er, I can get "real enough" values for the args
<Bike>
i don't know what that means. if your generic function has the standard method combination and you don't allow qualified methods and you can sort out what to do with eql specializers in some particular way you can probably work out whether a call is valid.
<remexre>
okay, I'm just trying to explore which of those restrictions I could lift
<pjb>
To reject qualified methods, you would define a method combination without qualifier.
<remexre>
though wait, wouldn't (find-method _ nil _ _) not get them in the first place?
yoeljacobsen has joined #lisp
<Bike>
Huh?
<Bike>
Nil is which argument to find-method? the first argument to find-method is the generic function.
<Bike>
wait, well you don't want to use find-method here at all, probably.
<remexre>
them = method-qualifiers
<remexre>
er, nil = method-qualifiers
<Bike>
find-method finds a method with the exact specializers you get it. like, if you provide a class that's a subclass of a class that does have a method specialized on it, that method won't be returned
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Loplin has joined #lisp
<Bike>
this is the function that's actually used during a call, if you pretend caching doesn't exist
sameerynho has joined #lisp
lavaflow has quit [Ping timeout: 245 seconds]
<remexre>
okay, looks like this'll work; thanks!
<Bike>
good luck
k has quit [Ping timeout: 268 seconds]
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 258 seconds]
k has joined #lisp
k is now known as Guest81626
cosimone has joined #lisp
varjag has joined #lisp
scymtym has quit [Ping timeout: 250 seconds]
Ven`` has joined #lisp
Aruseus has joined #lisp
<thijso>
How do I just restart/retry a function if it fails? Can I do (restart-case (somefun) (restart-fun () (somefun)) and then bind handler to invoke that restart on failure? Is there a better way to do this? For context, 'somefun' starts a UDP listener on a port, and regardless of errors, it needs to get back up and listening.
<jmercouris>
thijso: you can put a handler-case in a loop or something
<jmercouris>
I assume the operation is a blocking one in this case, if it is not, my suggestion doesn't work
<thijso>
My idea was to wrap the (wait-for-input ...) call in an unwind-protect, where the socket gets correctly closed in case of failure. Then the function that called udp-start-server in the restart calls that same function again, re-connecting the port. But I'm not sure if this is the correct way to do this.
<Josh_2>
I do that
<Josh_2>
if an error is called it just attempts to restart the function in a networking context
<jmercouris>
thijso: sounds like a perfectly reasonable solution to me
<jmercouris>
maybe a better question would be though, why the failure?
<Josh_2>
Plaster has absolute murdered the indentation, I think it is because I use tabs not spaces ¯\_(ツ)_/¯
Guest81626 has quit [Changing host]
Guest81626 has joined #lisp
Guest81626 has left #lisp [#lisp]
<thijso>
jmercouris: yeah, that's next on my list to figure out, but I'm having trouble debugging as it's threaded code. I'm using the udp port to also send dump commands, so I can see what is going on. Bit of a hack, I know, but it works. As long as I have the UDP port to talk to...
<thijso>
Josh_2: easily fixed in emacs. No worries.
<Josh_2>
thijso: you can print to standard output with a background thread by printing to *standard-out* if that helps with debugging
<Josh_2>
that code is also used on a background thread
<jmercouris>
thijso: I guess my question is, if you are just listening on the UDP port, why does it crash? is it *what* you are doing with the data that you listen to that is causing your program to crash?
<thijso>
The issue I'm having is not printing to stdout while my program is behaving. The issue is that my errors seem to miss a lot of information when they happen. It's a lot less than what I get in slime, for example.
<jmercouris>
thijso: aha! well then, I should inform you about the two types of slime you can have
<jmercouris>
thijso: you can have a ~/.swank.lisp like this (setf swank:*communication-style* :spawn) or like this (setf swank:*communication-style* :fd-handler)
<Josh_2>
What is the difference??
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
<jmercouris>
I'm not sure exactly, I believe FD handler is file descriptor handler rather than a BSD socket
<thijso>
Ah, yes. But I'm running the code without swank or slime, as I need to run x instances (nodes) that talk to each other.
<thijso>
There's probably better ways to set this up, but it kinda works
<jmercouris>
I see
jmercouris has quit [Ping timeout: 246 seconds]
permagreen has joined #lisp
ralt has quit [Quit: Connection closed for inactivity]
fragamus has joined #lisp
<fragamus>
Hey can someone tell me how to build clisp on a Mac from source