<gilberth>
I always had good luck to convince [paid] hosters to put CCL, which I prefer, onto the white list of non-evil processes. But then I always have ssh access. Configure apache to forward the relevant request to you and let the Lisp run until the machine is rebooted.
quazimodo has joined #lisp
quazimodo has quit [Client Quit]
keep_learning has joined #lisp
quazimodo has joined #lisp
dddddd has quit [Remote host closed the connection]
frodef has quit [Ping timeout: 246 seconds]
smasta has quit [Ping timeout: 250 seconds]
rcosta has joined #lisp
smasta has joined #lisp
rcosta has quit [Ping timeout: 240 seconds]
smasta has quit [Ping timeout: 244 seconds]
abhixec has quit [Ping timeout: 245 seconds]
vms14 has quit [Quit: Doing something with my shit life :D]
ckonstanski has quit [Remote host closed the connection]
DGASAU has quit [Read error: Connection reset by peer]
Aruseus has quit [Remote host closed the connection]
robdog has joined #lisp
paul0 has joined #lisp
DGASAU has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
rcosta has joined #lisp
robdog has joined #lisp
rcosta has quit [Ping timeout: 250 seconds]
karlosz has joined #lisp
smasta has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
smasta has quit [Ping timeout: 246 seconds]
jstypo has quit [Ping timeout: 257 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
smasta has joined #lisp
actuallybatman has joined #lisp
dale has quit [Quit: dale]
jstypo has joined #lisp
rcosta has joined #lisp
karlosz has quit [Quit: karlosz]
notzmv has joined #lisp
rcosta has quit [Ping timeout: 246 seconds]
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
akoana has joined #lisp
jstypo has quit [Ping timeout: 250 seconds]
jstypo has joined #lisp
robdog has joined #lisp
karlosz has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
rcosta has joined #lisp
robdog has joined #lisp
rcosta has quit [Ping timeout: 258 seconds]
wanz has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog_ has quit [Ping timeout: 258 seconds]
dale has joined #lisp
Oladon has joined #lisp
robdog has joined #lisp
akoana has left #lisp [#lisp]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog_ has quit [Ping timeout: 264 seconds]
rcosta has joined #lisp
CrazyEddy has joined #lisp
rcosta has quit [Ping timeout: 259 seconds]
actuallybatman has left #lisp ["ERC (IRC client for Emacs 27.0.50)"]
slyrus_ has quit [Ping timeout: 268 seconds]
powerbit has joined #lisp
rcosta has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
rcosta has quit [Ping timeout: 258 seconds]
DGASAU has quit [Read error: Connection reset by peer]
Necktwi has quit [Ping timeout: 245 seconds]
marvin3 has quit [Ping timeout: 240 seconds]
Bike has quit [Quit: Lost terminal]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
DGASAU has joined #lisp
dale has quit [Quit: dale]
libertyprime has quit [Ping timeout: 240 seconds]
arpunk has quit [Ping timeout: 246 seconds]
DGASAU has quit [Read error: Connection reset by peer]
rcosta has joined #lisp
<Ukari>
I find that use a defmethod to wrap a defstuct's slot accessor in order to rename it would be slower than a defstruct's origin slot accessor
<Ukari>
is there any way to rename it without effect on performance
rcosta has quit [Ping timeout: 246 seconds]
DGASAU has joined #lisp
<pillton>
Ukari: You could introduce the new function and declaim it inline.
DGASAU has quit [Read error: Connection reset by peer]
<pillton>
Ukari: In some cases you are actually better off doing (let ((x (new-reader object))) (form-modifying-x x ...) (setf (new-reader object) x )).
<Ukari>
I test that but there has still been a difference in performance. (time 0.010220 to 0.001659 )
<pillton>
Have you tested that is actually being inlined?
<Grue`>
Ukari: not sure if you control the defstruct in question, but there's :conc-name option to make the readers names shorter
<Ukari>
yes
Lycurgus has joined #lisp
smasta has joined #lisp
Ukari has quit [Remote host closed the connection]
Ukari has joined #lisp
smasta has quit [Ping timeout: 250 seconds]
<splittist>
Good morning
<verisimilitude>
Well, I've just had my first UTF-8 decoding error in SBCL when trying to manipulate files, so it failed.
<verisimilitude>
Thanks Ken Thompson.
<verisimilitude>
Good morning, splittist.
Lycurgus has quit [Quit: Exeunt]
<beach>
Hello splittist.
wanz has quit [Quit: wanz]
schweers has joined #lisp
robdog has joined #lisp
wanz has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
nowhere_man has quit [Ping timeout: 258 seconds]
emaczen has quit [Ping timeout: 268 seconds]
milivoj has joined #lisp
robdog has joined #lisp
smasta has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
smasta has quit [Ping timeout: 255 seconds]
Lycurgus has joined #lisp
jstypo has quit [Ping timeout: 245 seconds]
jstypo has joined #lisp
robdog has joined #lisp
aerique has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
hectorhonn has joined #lisp
<hectorhonn>
morning everyone
<shrdlu68>
Good morning.
varjag has joined #lisp
robdog has joined #lisp
patrixl has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
rcosta has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
patrixl has quit [Quit: ERC (IRC client for Emacs 26.1)]
rcosta has quit [Ping timeout: 240 seconds]
robdog has joined #lisp
patrixl has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
bobby has quit [Ping timeout: 268 seconds]
heisig has joined #lisp
bobby has joined #lisp
smasta has joined #lisp
patrixl has quit [Quit: ERC (IRC client for Emacs 26.1)]
patrixl has joined #lisp
smasta has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
bobby has quit [Ping timeout: 258 seconds]
bobby has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
hhdave has joined #lisp
Ukari has quit [Remote host closed the connection]
rozenglass has quit [Ping timeout: 258 seconds]
Necktwi has joined #lisp
vilivulpine has quit [Remote host closed the connection]
patrixl has quit [Ping timeout: 250 seconds]
wanz has quit [Quit: wanz]
robdog has joined #lisp
marvin2 has joined #lisp
jstypo has quit [Ping timeout: 255 seconds]
jstypo has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
Arcaelyx has quit [Ping timeout: 244 seconds]
robdog has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
lavaflow has quit [Ping timeout: 268 seconds]
schweers has quit [Ping timeout: 264 seconds]
robdog has quit [Ping timeout: 268 seconds]
smasta has joined #lisp
igemnace has joined #lisp
Lycurgus has quit [Quit: Exeunt]
scymtym has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
rozenglass has joined #lisp
schweers has joined #lisp
robdog has joined #lisp
jstypo has quit [Ping timeout: 240 seconds]
rcosta has joined #lisp
jstypo has joined #lisp
Arcaelyx has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
jstypo has quit [Ping timeout: 258 seconds]
rcosta has quit [Ping timeout: 246 seconds]
smasta has joined #lisp
smasta has quit [Ping timeout: 268 seconds]
karlosz has quit [Quit: karlosz]
smasta has joined #lisp
jstypo has joined #lisp
smasta has quit [Ping timeout: 250 seconds]
wanz has joined #lisp
jb has quit [Ping timeout: 255 seconds]
rcosta has joined #lisp
rcosta has quit [Ping timeout: 244 seconds]
hectorhonn has quit [Quit: Page closed]
<schweers>
If I want to have a method dispatch on a simple-array which has the element-type '(unsigned-byte 8) ... what class should I use to stay portable? sbcl says this: (class-of (make-array 1 :element-type '(unsigned-byte 8))) ;; => #<BUILT-IN-CLASS SB-KERNEL::SIMPLE-ARRAY-UNSIGNED-BYTE-8>
<schweers>
This is obviously non-portable. Is there a portable way to do this?
<schweers>
I just had the idea of looking at the class precedence list of said class, and it just has vector, simple-array, array and sequence in it (in that order). Why is vector considered to be a subclass of simple-array? Isn’t the point of an array, that it is not growable, while vectors can be?
<hjudt_>
does anyone know if and where i can find hashtable {} reader syntax implementation?
rcosta has joined #lisp
rcosta has quit [Ping timeout: 255 seconds]
<ggole>
schweers: vector is just a one-dimensional array
<schweers>
one dimensional simple-array, as it seems
<schweers>
I guess I have answered my original question myself
<ggole>
Vectors are not necessarily simple-arrays, no
<ggole>
They can be adjustable.
<ggole>
A simple-vector is a one-dimensional simple-array.
<schweers>
hence the superclasses irritate me
<schweers>
Ahh, SB-KERNEL::SIMPLE-ARRAY-UNSIGNED-BYTE-8 multiple inherits from both vector and simple-array. Interesting
<ggole>
I don't think that simple-array is a superclass of vectors in general, but of that particular vector
<schweers>
yeah, this clears up my confusion a bit.
<ggole>
The class precedence list is a linearisations of a DAG, by my understanding
<ggole>
eg, something appearing above something else does not imply a superclass relationship between the two
<schweers>
indeed
<ggole>
I think I have made that particular mistake a few times.
<schweers>
Also, just because one specializes a method on a class which has no user defined base class, does not mean that there are no further methods to call.
<ggole>
As for the original question, I don't think that you can portably specialise on element-types
<ggole>
You might be able to perform your own dispatch using array-element-type?
dddddd has joined #lisp
lumm has joined #lisp
lucasb has joined #lisp
smasta has joined #lisp
makomo has joined #lisp
Ukari has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
smasta has joined #lisp
makomo has quit [Quit: WeeChat 2.2]
smasta has quit [Ping timeout: 250 seconds]
schjetne has joined #lisp
jstypo has quit [Quit: I think, therefore I drink]
shrdlu68 has quit [Ping timeout: 268 seconds]
m00natic has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
smasta has joined #lisp
makomo has joined #lisp
makomo_ has joined #lisp
defaultxr has quit [Ping timeout: 250 seconds]
smasta has quit [Ping timeout: 244 seconds]
<schweers>
ggole: it almost seems so. But if I’m honest to myself, specializing on vector should be enough.
makomo has quit [Ping timeout: 250 seconds]
Lord_of_Life_ has joined #lisp
<ggole>
This is a performance thing, I take it.
Lord_of_Life has quit [Ping timeout: 250 seconds]
Lord_of_Life_ is now known as Lord_of_Life
lavaflow has joined #lisp
<heisig>
By the way, what is this year's value of els:*default-hotel*?
makomo_ is now known as makomo
arpunk has joined #lisp
<makomo>
heisig: i figured it was hotel bristol palace, but i'm not sure
<heisig>
The venue itself seems a bit overpriced. I'd rather walk five minutes to my hotel and spend the saved money on food and wine :)
<pjb>
This is arguable. But if you stay at the HBP, you will have to walk less, therefore you will need less food and wine for you reduced metabolism!
anewuser has joined #lisp
robdog has joined #lisp
smasta has joined #lisp
rcosta has joined #lisp
q3d has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
smasta has quit [Ping timeout: 245 seconds]
rcosta has quit [Ping timeout: 245 seconds]
smasta has joined #lisp
robdog has joined #lisp
lavaflow has quit [Ping timeout: 246 seconds]
smasta has quit [Ping timeout: 268 seconds]
lavaflow has joined #lisp
matijja has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
rcosta has joined #lisp
rcosta has quit [Ping timeout: 245 seconds]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
josemanuel has joined #lisp
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
smasta has joined #lisp
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
rcosta has quit [Remote host closed the connection]
rcosta has joined #lisp
smasta has quit [Ping timeout: 244 seconds]
robdog has joined #lisp
rcosta has quit [Ping timeout: 264 seconds]
robdog has quit [Ping timeout: 250 seconds]
rcosta has joined #lisp
FreeBirdLjj has joined #lisp
wanz has quit [Quit: wanz]
robdog has joined #lisp
Ukari has quit [Ping timeout: 240 seconds]
rcosta has quit [Ping timeout: 264 seconds]
FreeBirdLjj has quit [Ping timeout: 245 seconds]
Ukari has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
aeth has quit [Ping timeout: 245 seconds]
aeth has joined #lisp
CCDelivery has joined #lisp
q9929t has joined #lisp
Bike has joined #lisp
<moldybits>
is it possible to define new types based on an arbitrary predicate? e.g. (define-type sequence-of-two (x) (= 2 (length x))) and then specialize on that type with defmethod?
CCDelivery has quit [Remote host closed the connection]
smasta has quit [Ping timeout: 252 seconds]
smasta has joined #lisp
q9929t has quit [Quit: q9929t]
<moldybits>
hm. is there a reason you can't specialize on types? (or new types)
<pjb>
moldybits: types don't exist. They are not first class objects.
<Bike>
inheritance wouldn't work very well.
<pjb>
moldybits: for a class, there's find-class. For a type, there
<pjb>
's no find-type.
rcosta has joined #lisp
<Bike>
e.g., (integer 0 7) and (integer 3 9) are both types; if you have methods specialized on both, and call it with 5, what happens?
<pjb>
Bike: WRONG
<Bike>
actually, i am right.
<pjb>
Bike: they are type specifiers. Just like FOO or "FOO" are specifiers for a package, but have nothing in common with #<package FOO>.
<pjb>
actually you are dead wrong.
<shka_>
FIGHT!
* schweers
munches popcorn
<Bike>
oh, i see, you're complaining about something different because you're not willing to extend me the human courtesy of understanding that when i say "(integer 0 7) is a type" I mean the type specified by that specifier, which there is no way to refer to.
<pjb>
My argument is that generic function dispatching is based on first class objects.
<Bike>
i didn't say anything about your argument.
<Bike>
but if you're asking, i don't think it's a great one, because there's no reason in principle the language couldn't have had first class types.
<pjb>
Indeed. And there's no fundamental reason why we couldn't dispatch on types either.
<pjb>
classes with multiple inheritance are already a lattice.
<beach>
moldybits: Common Lisp is a language that was created so that it can be implemented as a compiler that generates very fast code, as opposed to "modern", so-called "scripting languages" that were created by people who did not take such considerations into account.
<beach>
moldybits: As it turns out, dispatching on classes and EQL specializers can be made to be very fast, whereas dispatching on types is much more complicated. In the worst case, the dispatch ends up being a sequence of calls to TYPEP.
<pjb>
IIRC, there are some macros giving type dispatch.
<Bike>
yes but there's a defined order. you'd have to impose one for type overlaps. it's complicated.
<beach>
moldybits: When the creators of Common Lisp had a doubt about whether some feature could be implemented efficiently, they preferred to exclude it. Now, you will find libraries that will provide you with this functionality.
<Bike>
given that the type system is naive set theory, it would probably be really hard to impose a total order.
rcosta has quit [Ping timeout: 255 seconds]
<beach>
moldybits: ... since you asked whther there is a reason for this restriction.
LiamH has joined #lisp
<dlowe>
it's true - in CL you are free to implement whatever inefficient thing you want :)
<beach>
Absolutely! :)
orivej has quit [Ping timeout: 250 seconds]
<beach>
moldybits: Of course, then you have the crowd of Common Lisp programmers who, like the creators of these scripting languages, also don't know how to implement things efficiently, but still lament the fact that their favorite feature was left out of the standard, and wish for a revised standard where this particular feature is included.
<beach>
moldybits: I am guessing those are the same people who then turn around and gladly use a language that doesn't even HAVE a standard without complaining.
<moldybits>
i don't know the terminology for this but i wish i could define new static (?) types, where the objects are tagged with their type.
<moldybits>
or that i was just able to tag objects and specialize on those tags. but maybe that's not too hard to implement?
<Bike>
do you mean you want to take an existing kind of objects, like integers, but have them tagged as something else?
<moldybits>
yeah but i can't (+ ((integer 0 7) . 5) 10)
<pjb>
Sure you can!
<moldybits>
by specializing +?
<pjb>
(shadow '+) (defun + (a b) (let ((sum (cl:+ (obj-value a) (obj-value b)))) (make-obj :type (type-of sym) :value sum))
<pjb>
)
FreeBirdLjj has joined #lisp
<moldybits>
right, but then i'd have to reimplement defmethod, for example, to have it check my tags
<moldybits>
right?
<shka_>
yes
<Bike>
which is why defstruct or defclass would be preferable
<Bike>
(you'd still have to shadow + if you want to specialize on it, though)
<Bike>
having a tag for (integer 0 7) is i think not a good design, though
<shka_>
on the other hand just leave mathematical operators alone
<Bike>
if you want to specialize by predication, the analogous thinking would lead to tagging objects with every predicate that's true of them
<Bike>
which would be silly
<shka_>
one particular way to approach issues like this is to use interface passing style
<_death>
also, these symbols are used for more than arithmetic.. for example type specifiers use *, or repl variables
rcosta has joined #lisp
Lycurgus has joined #lisp
rcosta has quit [Ping timeout: 258 seconds]
dale_ has joined #lisp
dale_ is now known as dale
sjl_ has joined #lisp
shka_ has quit [Quit: WeeChat 1.9.1]
smasta has quit [Ping timeout: 255 seconds]
rcosta has joined #lisp
nowhere_man has joined #lisp
rcosta has quit [Ping timeout: 255 seconds]
scymtym has quit [Ping timeout: 268 seconds]
lumm has quit [Quit: lumm]
lumm has joined #lisp
scymtym has joined #lisp
lumm has quit [Client Quit]
lumm has joined #lisp
jprajzne has quit [Quit: Leaving.]
lavaflow has quit [Ping timeout: 255 seconds]
kdas_ has joined #lisp
matijja has quit [Ping timeout: 246 seconds]
lumm has quit [Ping timeout: 264 seconds]
flip214_ is now known as flip214
kushal has quit [Ping timeout: 256 seconds]
smasta has joined #lisp
lumm has joined #lisp
ghard has joined #lisp
orivej has joined #lisp
JohnMS_WORK has quit [Read error: Connection reset by peer]
JohnMS_WORK has joined #lisp
<moldybits>
a SNAKE is a list of SNAKE-PARTs. pro: can use all list functions SNAKE. con: can't specialize.
shka_ has joined #lisp
<moldybits>
but i'm not really using any list functions on it, so i guess a SNAKE should be a SNAKE-PART with a SNAKE-CDR that is a SNAKE or nil.
aerique has quit [Ping timeout: 250 seconds]
<_death>
(defstruct snake parts)
Lycurgus has quit [Quit: Exeunt]
JohnMS_WORK has quit [Client Quit]
<heisig>
moldybits: Yes, it is usually better not to use lists for everything (even in Lisp!). Otherwise, you get hard to debug errors and confusing behavior, e.g. when dealing with lists of snakes.
kdas_ is now known as kushal
<moldybits>
_death: you mean (make-snake (list (make-snake-part) ...))?
<moldybits>
then i could specialize on the head, but not on the body :(
<moldybits>
heisig: i just felt i was reimplementing lists
<moldybits>
but with cons gone i can now tag and i no longer need to car!
<heisig>
moldybits: Ideally, define your own snake class(es) with defclass and a snake protocol for working on them.
<beach>
moldybits: Perhaps if you describe your problem in greater detail, we could give more concrete advice.
<beach>
moldybits: Also, you seem fixated on dispatch. Using generic functions is required only if you need a spread-out implementation of your functionality. Perhaps that is not needed in your case.
<moldybits>
beach: well, it's a snake game. moving the snake is naturally recursive: you move the head which tells its tail to move, which tells its tail to move, etc.
lumm has quit [Quit: lumm]
<beach>
moldybits: So if you need dispatch, you must have many different subtypes so that you need differnt methods?
<moldybits>
but there is one irregularity: the head needs to keep track of where to move next (unless i store it in a global) so it has more slots, and its move method needs to calculate the next position, as opposed to the children who are told in the method call.
lumm has joined #lisp
<moldybits>
wait. that's not the relevant irregularity ...
<beach>
Then why do you need specialization and generic dispatch?
rcosta has joined #lisp
<moldybits>
i'm specializing on SNAKE-TAIL (the list) and SNAKE-TAIL-PART (list elements)
<beach>
So those can be of several different subtypes?
<Bike>
there's more than one kind of snake-tail?
<Bike>
(to rephrase)
<beach>
I am trying to get moldybits to talk about the problem at hand, rather than talking in terms of mechanism.
<moldybits>
if the head is kept separate, then the list is homogenuous.
<beach>
Because it is entirely possible that the mechanism being talked about is not appropriate, or even needed.
schweers has quit [Ping timeout: 250 seconds]
<moldybits>
it is probably not appropriate. basically, the most straightforward approach would be to not use lists at all, but since it's a sequence ... i could just use a list.
<beach>
Again, you are talking mechanism.
<moldybits>
maybe i misunderstand you. i know how to implement the snake both with a list and without. but i don't know how to do it with a list nicely.
<beach>
moldybits: Generic dispatch is needed, when you have different ways of processing certain objects, as defined by their subclasses, and when those different ways must be physically separated, perhaps because one way was created by the library writer and the other by the customer.
<beach>
Or perhaps you mean something else with "specialization".
<moldybits>
i don't understand why you say subclasses where i'd expect classes.
rcosta has quit [Ping timeout: 240 seconds]
<beach>
Classes would be fine too.
<beach>
Usually, there is a protocol class that others are subclasses of.
<beach>
But that is not required.
<beach>
But, we are still talking mechanism here.
<moldybits>
maybe my problem is mechanismical?
notzmv has quit [Ping timeout: 255 seconds]
<moldybits>
i'm not sure what i'm doing wrong wrt problem description :)
<beach>
I don't think I have even seen a problem description other than "snake game".
heisig has quit [Quit: Leaving]
drewlander has joined #lisp
<beach>
As far as I can tell, there is no reason for client code to customize the snake with different classes and methods, so I don't see how you need specialization or generic dispatch.
<beach>
So you have a snake, which seems to be a sequence (not necessarily represented as a Common Lisp sequence) of positions. Is that it?
rpg has joined #lisp
<beach>
Then you need to move the head.
<beach>
From what I have read, you then add a position right behind the head, leave the others intact, and possibly remove the last position in the sequence.
<beach>
Is that it?
<beach>
That's the kind of description I think is needed.
<beach>
I guess you don't even move the head. You just add a new position to the start of the sequence.
<beach>
... and possibly remove the last one.
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
<pjb>
(defstruct snake head tail)
<beach>
Oh, well. I tried.
FreeBirdLjj has quit [Ping timeout: 244 seconds]
<beach>
pjb: I am trying very hard to avoid talking mechanism and to get moldybits to give me a description of the problem at hand.
<beach>
... because either *I* am confused or else moldybits is.
<beach>
Possibly. And that looks exactly like my description (to me at least).
<Bike>
we all know what snake is like, but i don't think it's immediately obvious from that why you'd need separate objects for each segment or why specialization would be involved
<beach>
Exactly.
<pjb>
moldybits: so the way to do it nicely that I propose is to keep two references: one to the head, and one to the last cons cell in the list, ie. the tail. Then you can easily add to the head or the tail, or remove from the tail.
<beach>
If it is low-resolution, you can just do BUTLAST.
<moldybits>
beach: i didn't even think of moving that way. i'm descending down the tail and have each tail-part move to its parents position.
<pjb>
moldybits: but the point of beach, is that it doesn't matter much: more important is to define your own abstraction: snake-eat, snake-advance, snake-turn-left, snake-turn-right, etc.
<beach>
moldybits: I don't think there is any particular reason to keep the identity of each part, as your solution does.
<pjb>
moldybits: the cells don't move, only you get a new head cell, and remove a tail cell. Or if you eat, you just get a new head cell.
<moldybits>
pjb: one "problem" was that i couldn't just say `move-to' instead of `snake-move-to' unless i wanted to specialize on cons.
<moldybits>
what you guys are talking about would seem to simplify things. hm.
<beach>
moldybits: And why is that? Because you have other things that you could move-to?
<pjb>
The links are useful for the turn, but you could even do without, if you memorised the orientation of the cells. Then a bitmap, or a 2D array could do too.
smasta has quit [Ping timeout: 258 seconds]
<moldybits>
beach: yeah, two things at least. the list of parts and the parts themselves, since i actaully updated each part's position.
<beach>
moldybits: No, that's not right.
<beach>
moldybits: define a class snake with a single slot POSITIONS.
<beach>
moldybits: MOVE-TO can be a normal function taking an instance of SNAKE.
<moldybits>
pjb: that's really interseting. though, i have to say, it feels more like something i'd write in C. :)
<shka_>
oh, somebody is doing a snake game? :D
<pjb>
Notably, notice how the apple appear randomly but only on free cells. So having a 2D array to represent the whole game, instead of a specific list of snake cells, may be advantageous.
<beach>
What it does is (setf (positions snake) (cons <new-position> (butlast (positions snake))))
<beach>
moldybits: Done. No generic function, no moving parts, no specialization, no tagged static types.
<moldybits>
pjb: and the reason i avoided having it all on the same was to avoid having to move the parts ...
<shka_>
moldybits: you literally just need to take tail and place it where new head position would be
<shka_>
that's all
<moldybits>
yeah, i realize that now
<shka_>
andy why apply?
<shka_>
nah, this is an overkill
<shka_>
moldybits: i think that it would be better for you to write your snake game just like you would write in language you know, and next ask for potential improvements
<shka_>
you know, baby steps
<shka_>
or you can pick land of lisp
<shka_>
which is a book with some simple lisp games
<shka_>
it is pretty cool
<shka_>
anyway, good luck!
<moldybits>
shka_: is it really that overkill? the apply is to explode the (x y) list for move-to! which takes them as two separate arguments.
<beach>
moldybits: mixing rendering and abstract representation is not a good idea.
milivoj has quit [Ping timeout: 244 seconds]
<shka_>
moldybits: yeah, but you want to make 6-dimensional snake? :D
<shka_>
also, what beach said
<beach>
moldybits: I would define an abstraction SNAKE that is NOT a snake part, and just have it contain a sequence of the parts. Probably just a list.
<shka_>
could be array as well honestly
<beach>
And I would make each part just a CONS of two values. At least until someone tells me something more complicated is needed.
<beach>
The color would be part of the rendering and not of the abstraction.
q9929t has joined #lisp
rcosta has joined #lisp
<shka_>
array would be better because you can do (rotatef (alexandria:first-elt a) (alexandria:last-elt b)) faster ;-)
gareppa has joined #lisp
<beach>
shka_: Or use Flexichain. :)
<moldybits>
beach: you're objecting to the color inside sprite?
<beach>
Definitely.
<shka_>
we are getting into the realms of overkill again :D
<beach>
shka_: But seriously, this is not performance issue.
<shka_>
indeed
<beach>
moldybits: Or rather, I object to sprite inside snake-part.
<beach>
It's just a position.
macdavid313 has joined #lisp
<beach>
Anyway, time to go help my (admittedly small) family fix dinner.
<moldybits>
beach: btw, you said i should write it in a language i know. this is sort of how i'd write it in python, except i'd have each part have a .child attribute.
<beach>
I said no such thing.
<moldybits>
oh, shka_
<moldybits>
sorry
<moldybits>
beach: thank you for your help, though. :)
<beach>
And the fact that you would write it that way in Python doesn't make it right.
<beach>
No problem. Got to go.
<shka_>
moldybits: python idiosyncrasy does not make bad engineering a good one
rcosta has quit [Ping timeout: 240 seconds]
<shka_>
same applies to common lisp
<moldybits>
shka_: yes, let's blame python! :D
<pjb>
moldybits: (defstruct snake-part child) ; what's the problem?
<shka_>
ever since UI was introduced, model is supposed to be separate from the view
<shka_>
and despite beach may disagree, i still think that you should relax and keep it simple
<shka_>
instead of writing the most lisp snake there is
<shka_>
without good understanding of lisp to start with
smasta has joined #lisp
<moldybits>
well, it's an experiment. i don't really need a snake game. :) i did want to see if i could wrap the parts in a list instead of having the links be inside of the parts.
<shka_>
eh, ok
<shka_>
ok i have something to write, see ya later!
<moldybits>
see you, and thanks.
gareppa has quit [Remote host closed the connection]
rcosta has joined #lisp
robdog has joined #lisp
<pjb>
moldybits: think about snake-advance. You need to remove the tail cell; but you also need to redraw the previous tail cell, which becomes the new tail cell. This means that you need to walk the cell sequence from tail to head. And of course, you need to add a new head cell, redraw the old one, draw the new one.
<shka_>
or simply discard everything and draw from scratch
<pjb>
moldybits: so this suggest that, if you use a singly linked list, that the list be from tail to head, and that you keep a reference to both the tail (the beginning of the list) and the head, the last cell of the list.
ggole has quit [Quit: Leaving]
nanoz has joined #lisp
<pjb>
Now, if you look at the video I linked above, you see that when the snake eats, the apple moves from cell to cell down the snake. For this, we need the links to go from the head down to the tail of the snake. So a doubly-linked list would be in order, to implement efficiently this effect.
rcosta has quit [Ping timeout: 250 seconds]
robdog has quit [Ping timeout: 245 seconds]
<pjb>
But I still think that using cells in a 2D array would be a better representation. You'd have slots such as head-direction tail-direction that would let you compute the coordinate of the next or previous cells, and give an indication on how to draw the cell.
q9929t has quit [Quit: q9929t]
<moldybits>
i want to try both versions. btw, what you're describing above is an efficient implemetnation, yes? as opposed to just using (last snake) to get the last part?
<pjb>
Yes.
<pjb>
But then for board sizes in the hundred of even the thousands of cells, even the slowest (last snake) will be quick enough on modern hardware. Even redrawing the whole screen, we can do that hundreds of times a second on modern hardware! This wasn't the case when those small games were invented.
<pjb>
They all can be implemented "very efficiently", because they've been designed so.
rcosta has joined #lisp
FreeBirdLjj has joined #lisp
robdog has joined #lisp
<moldybits>
the apple thing i'd implement as just leaving it be where it is, instead of also forcing it down further.
<moldybits>
i'm not used to thinking of lisp as an efficient language. it doesn't seem as natural as when programming C.
<verisimilitude>
This is a snake game?
<verisimilitude>
Just use at least three bits for every cell, where one bit is set if the snake segment is present and, if so, with the other two indicating the direction of the next segment.
ravndal has quit [Quit: WeeChat 2.3]
amerlyq has joined #lisp
rcosta has quit [Ping timeout: 255 seconds]
robdog has quit [Ping timeout: 264 seconds]
<pjb>
verisimilitude: well, this is lisp, we can use objects, symbols, etc.
<moldybits>
also, i'm not sure what we'll add next, so ...
<pjb>
you can add the width of the segment, the apple digestion.
<verisimilitude>
Yes, but you know how to take that description and make it high-level if desired, pjb.
lavaflow has joined #lisp
ravndal has joined #lisp
<_death>
(ql:quickload "consix") (consix:game) for fighting against lisp snakes
Oladon has joined #lisp
<Xach>
too frightening for me.
<shka_>
ok, let's do this
<shka_>
how do i start the glorious combat?
<_death>
to conquer, you hold space and use the arrows
anewuser has quit [Quit: anewuser]
<shka_>
i love the tail wiggle
nanoz has quit [Ping timeout: 245 seconds]
<pjb>
It doesn't work in slime.
<pjb>
(on ccl on macOS).
<moldybits>
working for me in slime with sbcl on FreeBSD
<shka_>
sbcl on linux, works, obviously
<_death>
pjb: what happens?
<pjb>
Neither on ccl in the terminal: in both cases: 2019-02-27 18:34:03.358 dx86cl64[27261:30721742] GLUT Fatal Error: internal error: NSInternalInconsistencyException, reason: NSWindow drag regions should only be invalidated on the Main Thread!
q3d has quit [Quit: Page closed]
<sjl_>
MacOS is notorious for requiring graphical stuff to happen only from the main thread. trivial-main-thread can help
<_death>
heh
<_death>
alternative, try without slime, I guess.. (I don't use mac)
<sjl_>
though a library with trivial- in the name that has six (transitive) dependecies kind of weirds me out
m00natic has quit [Read error: Connection reset by peer]
hhdave has quit [Ping timeout: 246 seconds]
<_death>
but you mentioned ccl in the terminal.. does ccl not use the main thread for evaluation?
<shka_>
it seems so
aindilis has quit [Remote host closed the connection]
Jesin has quit [Quit: Leaving]
<pjb>
_death: in the terminal yes.
<pjb>
slime works with threads (*inferior-lisp* is the main thread).
<_death>
I guess use (trivial-main-thread:with-body-in-main-thread (:blocking t) (consix:game))
nckx has quit [Quit: Updating my GNU Guix server — https://guix.info]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
nckx has quit [Quit: Updating my GNU Guix server — https://guix.info]
nckx has joined #lisp
macdavid313 has quit [Quit: macdavid313]
FreeBirdLjj has quit [Ping timeout: 244 seconds]
robdog has joined #lisp
jb__ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
rozenglass has quit [Ping timeout: 255 seconds]
karlosz has joined #lisp
ckonstanski has joined #lisp
nckx has quit [Quit: Updating my GNU Guix server — https://guix.info]
Oladon has quit [Read error: Connection reset by peer]
Oladon has joined #lisp
Oladon has quit [Client Quit]
therik has joined #lisp
<therik>
hello, is there any way to do continue; in do loop?
<dlowe>
there is not
<dlowe>
at least, not like you're thinking
<therik>
any other way?
<dlowe>
The simplest is to do all the work in a function, then you can return-from the function at any point.
<flip214>
therik: use the LOOP macro (or switch to ITERATE, which I like better)
<dlowe>
the LOOP macro also does not have a "jump to next" clause
<Xach>
??? what about using tags and go?
<_death>
(block foo ... (return-from foo) ...)
<dlowe>
You can definitely use tags and go
<dlowe>
you know, if you have to
<Xach>
do body is implicit tagbody.
<Xach>
put in a continue tag at the end and go to it!
<Xach>
therik: do you see?
nckx has joined #lisp
trafaret1 has quit [Remote host closed the connection]
<therik>
Xach: I see, thanks
<therik>
one of those will help, i think i need to refactor it first
<therik>
it's 3 nested loops in 4 nested macros, gotta figure out what does what first
<Xach>
heh
<ober>
thank god for smart compilers
rcosta has joined #lisp
lumm has quit [Remote host closed the connection]
rcosta has quit [Ping timeout: 245 seconds]
rpg has quit [Ping timeout: 258 seconds]
moei has joined #lisp
<therik>
i can just put (unless) around the body of the macro to skip that iteration
<therik>
I guess that's simpler than dealing with it now
lumm has joined #lisp
robdog has joined #lisp
ebrasca has quit [Remote host closed the connection]
lumm has quit [Client Quit]
lumm has joined #lisp
robdog has quit [Ping timeout: 252 seconds]
karlosz has quit [Quit: karlosz]
lumm has quit [Remote host closed the connection]
rpg has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
smasta has quit [Ping timeout: 245 seconds]
smasta has joined #lisp
sauvin has quit [Remote host closed the connection]
izh_ has joined #lisp
smasta has quit [Ping timeout: 250 seconds]
Essadon has joined #lisp
smasta has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
robdog has joined #lisp
libertyprime has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
lumm has joined #lisp
nalkri has quit [Ping timeout: 244 seconds]
lumm has quit [Ping timeout: 245 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
im0nde has joined #lisp
nckx has quit [Quit: Updating my GNU Guix server — https://guix.info]
<im0nde>
Hey, I wanted to ask the lisp experts: I like to learn new things, especially programming-related and always wondered why everybody keeps saying lisp is such a "beautiful" or "special" language and is worth learning on it's own. What is the deal with lisp really? why lisp?
nckx has joined #lisp
therik has quit [Ping timeout: 250 seconds]
<dlowe>
it's "special" because it's on a branch of computing where an expression was the unit of computation instead of procedures. The branch split off long ago in the past, and there are structures and ideas that the main branch (which went with procedures) are mostly unaware of
libertyprime has quit [Ping timeout: 245 seconds]
<dlowe>
there's been more crossover in recent years, so it's not quite as special as it once was, but it still comes together as a very solid, practical language with a strong theoretical basis.
<buffergn0me>
im0nde: Lisp is better thought out (more consistent, general, and therefore powerful) than most other languages. More things are first-class. Abelson and Sussman's Structure and Interpretation of Computer Programs has some good illustrations of that, but it touches a tiny subset of what Common Lisp offers. There is just a lot of well-thought out building blocks for making programs in Common Lisp.
libertyprime has joined #lisp
eschulte has quit [Quit: leaving]
smasta has quit [Ping timeout: 268 seconds]
smasta has joined #lisp
emaczen has joined #lisp
sjl has joined #lisp
robdog has joined #lisp
smasta has quit [Ping timeout: 240 seconds]
<ober>
"better thought out" implies no thinking has occurred since the CLHS
robdog has quit [Ping timeout: 264 seconds]
smasta has joined #lisp
smasta has quit [Ping timeout: 244 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
rcosta has joined #lisp
vms14 has joined #lisp
<vms14>
guys
<vms14>
heliohost listened and added common lisp with sbcl as a cgi
<vms14>
I guess it's the first host in the world to offer lisp as cgi
<vms14>
SBCL 1.4.0-1.el7 has been installed on Johnny. To get started with lisp as a cgi create a file named lisp.cgi in public_html/cgi-bin/ with permissions 755 and the contents:
<vms14>
#!/usr/bin/sbcl --script
<vms14>
(format t "Content-type: text/html~%~%")
<vms14>
(format t "Lisp as CGI is working.")
<vms14>
awesome
<vms14>
It was yesterday when I requested they add lisp as cgi
<vms14>
and they did it even knowing I'm a free user
<aeth>
That would also make CCL off limits because Fedora doesn't have CCL yet. It has SBCL and ECL and CLISP. (It does a better job covering major Schemes, where it seems to only be missing MIT/GNU Scheme as far as the very notable Schemes go.)
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
<vms14>
also do you think is a good choice sbcl over clisp as cgi?
<vms14>
because I've incited them to choose sbcl over clisp
<vms14>
so they did
<buffergn0me>
ober: I would love to see more languages that have been created since CL was standardized, but so far most of them have not been
<buffergn0me>
TBH most of the good new PL ideas since then have been in Dyalog APL, mostly borrowing stuff from J
<aeth>
vms14: It depends on what you're looking for. SBCL is in general the faster Lisp, but it might be slower than CLISP for something like that hello world CGI. RAM usage will also be much higher. But in terms of the actual development environment there really isn't competition there (unless you need readline built in) and SBCL has a much better overall experience imo. Better library support, too, since not everything that looks like it works r
<aeth>
not everything that looks like it works runs on CLISP or ABCL.
<buffergn0me>
Yeah, SBCL is going to work with more libraries
shka_ has quit [Ping timeout: 244 seconds]
<aeth>
And in particular, CLISP and ABCL (probably a few more with ABCL, although I'm not sure) are going to break the most libraries.
<vms14>
aeth, so I did well?
<buffergn0me>
Also, I think SDF has been offering CLISP CGI hosting for a while. Anyway, Lisp CGI hosting has definitely been sold in the past
<vms14>
well if you want lisp cgi in a free hosting, just remember that heliohost added it
<vms14>
also you could donate to have better service
rpg has joined #lisp
ebrasca has joined #lisp
scymtym has quit [Ping timeout: 268 seconds]
polezaivsani has joined #lisp
<mason>
This isn't subtle, as marketing goes.
troydm has joined #lisp
robdog has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
<Duns_Scrotus>
just bc people use a 70s programming language doesn't mean they want 90s hosting technology
robdog has joined #lisp
robdog_ has joined #lisp
robdog has quit [Ping timeout: 264 seconds]
robdog_ has quit [Ping timeout: 264 seconds]
Oladon has joined #lisp
matijja has quit [Ping timeout: 250 seconds]
robdog has joined #lisp
thinkpad has quit [Quit: lawl]
verisimilitude has quit [Remote host closed the connection]
robdog has quit [Ping timeout: 252 seconds]
robdog has joined #lisp
emaczen has quit [Ping timeout: 250 seconds]
paul0 has quit [Ping timeout: 250 seconds]
izh_ has left #lisp [#lisp]
robdog has quit [Ping timeout: 252 seconds]
jb__ has quit [Ping timeout: 246 seconds]
jb__ has joined #lisp
rcosta has quit [Remote host closed the connection]
<vms14>
Duns_Scrotus, I don't get it
<vms14>
modern languages aim to be modern because they have "innovative" features
<vms14>
features which were copied from lisp
<vms14>
and I hope use sbcl as cgi won't be a real problem, but one advantadge instead
<vms14>
I still wanting to know if it's better sbcl or clisp as cgi.
<vms14>
Well, if I did well recommending them to use sbcl instead of clisp
<pjb>
vms14: what's better is fastcgi, what's best is to use a web application framework such as hunchentoot.
<pjb>
otherwise, sbcl is ok for servers.
josemanuel has quit [Quit: leaving]
Lycurgus has quit [Ping timeout: 268 seconds]
lumm has joined #lisp
lumm has quit [Remote host closed the connection]
lumm has joined #lisp
<gendl>
sbcl with zaserve is another option.
robdog has joined #lisp
rozenglass has joined #lisp
<Xach>
Not for doing cgi.
bgardner has quit [Remote host closed the connection]
robdog_ has joined #lisp
robdog has quit [Ping timeout: 250 seconds]
lumm has quit [Ping timeout: 258 seconds]
<gendl>
Ok that's true, I was following up to pjb who was saying what's best is to use a Lisp web application framework (or application server -- "framework" is a somewhat higher level concept).
<Xach>
Ah
<gendl>
the idea being that using an embedded server would be more seamless than calling cgi "scripts" for every request.
bgardner has joined #lisp
lumm has joined #lisp
troydm1 has joined #lisp
robdog_ has quit [Ping timeout: 264 seconds]
ebrasca has quit [Remote host closed the connection]
troydm has quit [Ping timeout: 244 seconds]
lumm has quit [Client Quit]
lumm has joined #lisp
ebrasca has joined #lisp
orivej has quit [Ping timeout: 244 seconds]
<vms14>
yeah, cgi is not the best way
robdog has joined #lisp
q3d has joined #lisp
<vms14>
I've just wanted to know if clisp was a better option than sbcl
<vms14>
so then I would be wrong while recommending them to install sbcl
<vms14>
but anyway they installed sbcl so there is no change now
DGASAU has quit [Read error: Connection reset by peer]
robdog has quit [Ping timeout: 264 seconds]
gareppa has joined #lisp
DGASAU has joined #lisp
<pjb>
vms14: well, for a pure cgi, the advantage of clisp is that it boots faster. But since maintainance of clisp is lagging, you may have problems running it on modern systems.
quazimodo has quit [Ping timeout: 255 seconds]
<pjb>
vms14: and finally, it's easy enough to generate executable images, so the script aspect can be forgotten.
slac-in-the-box has joined #lisp
Bike has quit [Quit: beerb]
gareppa has quit [Remote host closed the connection]
<vms14>
hope that first time was not because sbcl was starting, because it lasted so long
rcosta has joined #lisp
paul0 has joined #lisp
<paul0>
hello
<vms14>
hi
<paul0>
something is wrong in my sbcl/quicklisp system, I can't load ironclad
<paul0>
"invalid number of arguments: 5"
robdog_ has joined #lisp
<paul0>
(I don't understand sbcl/slime error logging)
robdog has quit [Ping timeout: 250 seconds]
rcosta has quit [Ping timeout: 255 seconds]
DGASAU has quit [Read error: Connection reset by peer]
robdog_ has quit [Ping timeout: 264 seconds]
<slac-in-the-box>
Didn't know we had a cryptotraghy library--but I just tried M-x slime, followed by (ql:quickload "ironclad") and there it is...
<paul0>
slac-in-the-box, no error?
<slac-in-the-box>
none: first it fetched nibbles... then ironclad
<paul0>
I found some discussions in the internet, and using the latest version of sbcl should fix it. But this problem is still happening
<slac-in-the-box>
paul0, I am using sbcl 1.3.8
schjetne has quit [Ping timeout: 250 seconds]
<paul0>
hum, just downloaded the 1.5.0 binary from sbcl.org, it seems to be working now
<paul0>
yeah, fixed
<gilberth>
vms14: That is awfully slow! So is Lisp unsuitable for web development now? Compare to http://bauhh.dyndns.org:8000/clim-spec/index.html , which runs in my basement behind a DSL line. And _every_ page is generated on the fly.
robdog has joined #lisp
<vms14>
gilberth, I'm trying that cgi example with dillo and does not seem too slow
<gilberth>
vms14: Needing 1.4 seconds to deliver the page is slow to me.
<vms14>
how can I benchmark that with unix tools?
<vms14>
just using time?
<gilberth>
Yes, time wget or time curl, what ever you like better.
scymtym has joined #lisp
<nirved>
gilberth: slower due to http vs https
<vms14>
wget is slower than lynx
<gilberth>
In waiting? You must be kidding.
ober has left #lisp ["ERC (IRC client for Emacs 26.1)"]
ltriant has joined #lisp
<vms14>
oh lol
robdog has quit [Ping timeout: 264 seconds]
<vms14>
the same time
<vms14>
time lynx --dump
<vms14>
0.69 real 0.00 user 0.01 sys
<vms14>
time wget lynx.invisible-island.net
<vms14>
0.69 real 0.05 user 0.10 sys
<vms14>
well maybe is slow, I need to try it without ssl
<vms14>
but I'm very happy to have that option
<gilberth>
*sigh*
<vms14>
with clisp should be faster
<no-defun-allowed>
lmao clisp
<gilberth>
*sigh* again.
<no-defun-allowed>
s🅱cl
<vms14>
idk if I did wrong recommending them using sbcl over clisp for cgi
<vms14>
but I have lisp <3
<vms14>
and I only needed to ask for it
<vms14>
xD
robdog has joined #lisp
<gilberth>
Listen, it is good you asked them. But using plain old CGI from last century is not the "correct" way to do web development with Lisp.
<vms14>
yeah, the correct way should be pay
<vms14>
or have my own pc as a server
<gilberth>
That's not the point.
<gilberth>
Or issue, even.
<vms14>
but that project is for learning web development and also learn to work with other devs
<vms14>
So I guess it's useful in that case
<no-defun-allowed>
run hunchentoot
<gilberth>
no-defun-allowed: Exactly.
<no-defun-allowed>
you're in for a lot more lag if you need SQL connections, any persistent storage, etc with CGI
<vms14>
I could start practicing with lisp and have something working without need to host it by myself or pay a vps
<vms14>
no-defun-allowed, what about woo?
<gilberth>
Or CL-HTTP for that matter :-) I am olde, as Xach said.
<vms14>
the author claims is the fastest in the world xD
<no-defun-allowed>
woo is flaming garbage and will kill your Lisp process if you breathe on it funny
<vms14>
meh
<no-defun-allowed>
it's about as stable as a C server
<no-defun-allowed>
so basically, hunchentoot or radiance over hunchentoot
<vms14>
I'll learn about hunchentoot then, but not now
<vms14>
thanks for the hint, I'll remember it
<vms14>
the only thing I made atm is to just use drakma in a noob way
<vms14>
I did noob stuff like taking the json with yason and with cl-json
LiamH has quit [Quit: Leaving.]
<no-defun-allowed>
jsown interns less in the KEYWORD package
<vms14>
I prefer cl-json because it gives the list with keys
<vms14>
yason gives strings, but I guess I just can put an option for having keys
<no-defun-allowed>
aight
mange has joined #lisp
amerlyq has quit [Quit: amerlyq]
zigpaw has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
Kaisyu7 has quit [Quit: ERC (IRC client for Emacs 26.1)]
rcosta has joined #lisp
sjl_ has quit [Ping timeout: 244 seconds]
Kaisyu7 has joined #lisp
rcosta has quit [Ping timeout: 240 seconds]
harber has joined #lisp
smasta has joined #lisp
<harber>
quick question. seeing things like dexador in the .asd seeing something like (:feature (:not :dexador-no-ssl) "cl+ssl"), how do i enable that dexador-no-ssl flag before import so it doesn't import cl+ssl?
<pjb>
(pushnew :dexador-no-ssl *features*)
<scymtym>
(pushnew :dexador-no-ssl *features*) before loading the system (not before import which is package-level after the system has already been loaded)
robdog has joined #lisp
smasta has quit [Ping timeout: 250 seconds]
<harber>
heeey, that works just dandy, thanks =)
<slac-in-the-box>
I run hunchentoot behind a proxy, on sbcl, and one sbcl thingy that I never worked out was how to get sbcl to work on an ASLR enabled linux kernel...