nickenchuggets has quit [Read error: Connection reset by peer]
dddddd has joined #lisp
nickenchuggets has joined #lisp
shrdlu68 has joined #lisp
nickenchuggets has quit [Read error: Connection reset by peer]
red-dot has joined #lisp
mlf|2 has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
Mutex7 has quit [Quit: Leaving]
milanj has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
robotoad has quit [Quit: robotoad]
<xificurC>
makomo: I just read what you wrote me, thanks. I enjoyed reading let over lambda despite the code-walking issues and elitism. The sorting network chapter was pretty cool. It's also interesting to see how closures can be the building block of OO and how one can create ad-hoc protocols from it
fraya has joined #lisp
<makomo>
morning
<makomo>
xificurC: yeah :-)
<xificurC>
someone else (I never remember who) mentioned he doesn't like that (rephrasing) the values in closures cannot be changed, which is very non-lispy
<schweers>
xificurC: they can be changed
<xificurC>
but the pandoric macros did allow that, so again I'm not sure what did he mean
<xificurC>
maybe it was White_Flame
smokeink has quit [Remote host closed the connection]
<xificurC>
"Several remarks that might seem offensive are actually just phrasing mistakes on my part"
<xificurC>
the terminology throughout the book really sounded that way to me. All the right vs wrong, lisp vs. blubs etc
<schweers>
people often complain that lispers are elists and look down on other languages. But really, this is to be expected, given the current state of our field :/
<schweers>
I’ve become very grumpy about other languages myself
Lord_Nightmare2 has joined #lisp
Lord_Nightmare has quit [Ping timeout: 256 seconds]
<beach>
I still don't see how that is "elitist" though. But never mind. I am in a rotten mood, so I should probably be quiet.
<xificurC>
schweers: I agree and I sound like that to some of my colleagues too. Still it's something to look out for. Noone likes to hear their choices are "wrong" or downright "stupid" and I don't feel competent to judge anyone
Lord_Nightmare2 is now known as Lord_Nightmare
<schweers>
I’m sorry to hear that beach :(
<beach>
Not a big deal. I'll get over it.
<xificurC>
beach: sorry if the term offended you in any way. It was a subjective feeling not to be confused with what the author actually meant.
smurfrobot has joined #lisp
<schweers>
I also wonder ... is being elitist wrong generally? I feed that it can be justified
<xificurC>
I would say - knowing you are better at something is ok. Being a jerk about is is not.
<shrdlu68>
Well, elitism is usually associated with prejudice and snobbery.
<beach>
xificurC: I have often been accused of being elitist, which is probably why I reacted that way. But the people who accuse me of that say that because I happen to think it is a good idea for programmers to actually have some training. Just like I would like for surgeons, lawyers, accountants, etc., to actually have some training.
<beach>
xificurC: Many people seem to think that anyone who has written a 10-line program should be allowed to practice programming professionally.
<shrdlu68>
That in itself is indicative of deeper failures in the industry.
<schweers>
shrdlu68, xificurC: it may be associated with negative behavior, but I don’t think it need be that way. Anyway, being a jerk about it and having prejudices(?) is not good. Not my point though.
<beach>
shrdlu68: I totally agree.
<aeth>
If I was programming the way I was trained, then I would only use C++ or Java.
<schweers>
I wonder where this notion comes from. In no other field is this practiced.
<schweers>
aeth: ditto
<schweers>
but training amounts to more than just having learned a language
<xificurC>
beach: sounds like kids calling you a swot to be honest. I try not to take those people's aggressive behavior to heart
<jdz>
schweers: ever heard of homeopathy?
smurfrobot has quit [Ping timeout: 264 seconds]
<beach>
xificurC: Sure. Like water off a duck's back.
<schweers>
jdz: these people are called out for being quacks for a reason
<jdz>
Do the people who do the "out calling" sound elitist?
<aeth>
schweers: Yes, but even beyond language choice, I'm not sure that software engineering has a solid foundation. Or, at least, if it has one, it doesn't seem to be the majority position.
<aeth>
If software engineering were to be treated like engineering (and maybe it should be), then it should be engineering first.
<schweers>
aeth: no, I guess the field is too young for that kind of maturity. Also, software is very different from regular engineering
<schweers>
jdz: not to me, no
<jach[m]>
jdz: even homeopaths are trained to properly dillute the thing.. but also, you can write a 10 line program that does something useful, vs homeopaths that aren't actually useful
<xificurC>
I think too much work has come too quickly and now everyone is trying to do whatever they can to code. It's not exactly anyone's fault, the field is just young
<jdz>
Maybe the analogy is not very good, then. I rest my point.
<beach>
schweers: I agree that software is very different from the artifacts that engineering is concerned with.
<schweers>
xificurC: I agree. No one entity is at fault, but the result is still very bad and needs fixing. And I don’t see much fixing going on.
<shrdlu68>
Does every other company need a web developer? This is a bizarre field, and Im struck by how ephemeral our work is.
<jach[m]>
A better analogy might be writing fiction. "Real authors" and readers of them tend to be pretty snobby against things like fanfiction, and even teenage authors producing highly derivative original-enough books.
<schweers>
xificurC: some, yes. I found a job where I can write software in CL, so that’s a start. I must say that I’m the only one here, and my collegue insists on using scheme :/
<aeth>
schweers: which Scheme?
<schweers>
gauche
<schweers>
aeth:^
<xificurC>
if the fight is about which lisp to use you're off to a good start!
<schweers>
I know, but using CL really has made me see how it is a better language (and has better implementations) than others, even scheme.
<schweers>
anyway, enough flaming ;p
<akkad>
there are better schemes than Gauche :P
<p_l>
akkad: yes, but they are all separate schemes
<schweers>
that may be the case, but his code is not portable to those other implementations
<ecraven>
akkad: why?
<ecraven>
I mean, what don't you like about gauche?
<aeth>
That's the problem with Scheme. You're (usually) not a Scheme programmer, you're a programmer of some Scheme dialect.
* p_l
struggled for years with Lisp because of pushing scheme as the better option
shrdlu68 has quit [Ping timeout: 264 seconds]
<aeth>
And if you like an obscure one (like Gauche) you don't get access to much of an ecosystem.
<ecraven>
aeth: r7rs-large will hopefully change that
<schweers>
several things, but its slow and doesn’t have a debugger, so there are two things to start
<aeth>
ecraven: If r7rs-large came out 3-4 years ago I probably would have finished cl-scheme
<xificurC>
I saw someone mention femtolisp in reddit comments on r/lisp, has anyone had any experience with it? It's an undocumented lisp with 700 stars, how can that even happen?
shrdlu68 has joined #lisp
<aeth>
xificurC: Front page of HN?
<xificurC>
aeth: that sounds reasonable
<aeth>
Probably 700 "I'll look at it later"s
<aeth>
From HN. That would be my guess
<xificurC>
yeah but there's not much to look at besides the code
<shka>
hmm
<shka>
why people use scheme for large projects anyway?
<schweers>
shka: I don’t get why people use it at all, other than trying it out for educational purposes and the like
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<shka>
well, it is simple and elegant language
<shka>
I see why people like it
varjag has joined #lisp
<schweers>
but if you can have the power of Common Lisp instead I don’t see the advantage.
shrdlu68 has quit [Ping timeout: 264 seconds]
shrdlu68 has joined #lisp
<akkad>
ecraven: it's fine, has a good stdlib, but runtime it tends to use a lot more ram for the stuff I've done. Just saying there are better schemes to compare directly with cl
<aeth>
Common Lisp seems like the superior language for writing everything in one language.
<makomo>
xificurC: pandoric macros were awesome :D
<aeth>
Scheme could be better than SBCL or CCL in a bilingual environment.
<ecraven>
akkad: ah, sorry, I missed the "comparing to CL" part
<makomo>
xificurC: i really wonder if some time into the future people will get used to those various macrology tricks that usually seem convoluted or fragile/error-prone
<akkad>
e.g. those with compilers
<ecraven>
aeth: I'd prefer Scheme from a theoretical standpoint (I like the language "design" better, I like Lisp-1), but library-wise, there's no question that CL is far ahead
<makomo>
xificurC: doug says that some of the stuff he talks about "hasn't been fully explored and/or understood yet", and that that is the reason for it not being used
<jach[m]>
Does Racket still count as Scheme anymore? I guess maybe it's sort of like Scheme++ with all its extensions.
<akkad>
ecraven: you have any benchmarks that are apples to apples for say sbcl vs chez?
<ecraven>
and regarding debugging, I've never seen any other lisp that even deserves to be called debugging, compared to SLIME
<akkad>
^^
<schweers>
any scheme which has a defmacro or syntax-rules is a deviation from the standard (as far as I know)
<ecraven>
akkad: no, but my suspicion is that chez would at least be in the same ballpark as sbcl, if not faster
<ecraven>
but I've never done any benchmarking on sbcl
<akkad>
visual inspector in slime... <3
<xificurC>
I never understood the claim that lisp-1 is bad for writing macros. When not capturing vars but using gensyms how does a lisp-1 pose any problems?
<ecraven>
also, chez has close to no libraries
<schweers>
ecraven: exactly! and even sbcl with slime sometimes does weird stuff
<ecraven>
akkad: I've got a working inspector for chez, the problem is actual debugging
<akkad>
ahh
<aeth>
ecraven: the difference with a fast Scheme and a fast CL is (almost) everyone here could switch to a faster-than-SBCL CL tomorrow
<akkad>
gerbil has some libs
<ecraven>
actually, I've got a working r7rs inspector, it just needs some native support
<ecraven>
my r7rs-swank for gerbil should actually have a working slime inspector
<akkad>
aeth: oh, clasp with the -OMG flag for llvm?
<aeth>
ecraven: Libraries don't matter as much if you're using Scheme as a scripting language
<edgar-rft>
jach[m], AFAIK the main point of Scheme since ever was that only a minimal core language is defined by rNrs and everything else is a big mess :-)
<aeth>
akkad: Probably not.
<makomo>
xificurC: hm i didn't connect that he disliked lisp-1s because they "made macro writing hard". i thought it was just a stylistic issue really, and a huge annoyance also, having to name your variables like "lst" and similar
<schweers>
xificurC: I didn’t get it for the longest time either, but there are in practice fewer problems in a lisp-2. But I won’t pretend that I can explain it very well.
<ecraven>
aeth: indeed, that's the main thing I hope r7rs-large will remedy, add portability
shrdlu68 has quit [Ping timeout: 264 seconds]
<ecraven>
makomo: it's not about macros, I just prefer lisp-1s (just personal preference)
<ecraven>
I don't like funcall
shrdlu68 has joined #lisp
<ecraven>
if I won the lottery, I'd fund a Scheme that has CL's introspection and debuggability
<makomo>
i'm in the lisp-2 camp :-). i can't stand having to rename variables to something silly just to avoid name clashes
<makomo>
it's so irritating
<ecraven>
but then, that might be actual CL, so might not be useful ;)
<makomo>
and it's always clear from the context which one is being used
<ecraven>
makomo: I understand that ;) I just don't feel that way
<shka>
ecraven: Scheme guys have Racket so don't complain ;-)
<ecraven>
shka: racket is lightyears behind CL in those aspects
<mrm>
As someone who primarily uses scheme/racket, I'm pretty envious of CL's assembly stuff and annotations.
<shka>
they are making good progress
<schweers>
racket disqualified itself to me by not having CLOS
<ecraven>
shka: for example, I don't think you can "enter" a module in racket and redefine things. and I don't think that will ever work
<shka>
as for CL, perhaps only smalltalk is better
<makomo>
schweers: it has an implementation of it :D
<schweers>
makomo: have you ever used it?
<White_Flame>
xificurC: yeah, it was me. One of my major complaints is that you can't change the behavior of LoL-style objects via recompiling the source code
<makomo>
as an external thing of course
<makomo>
schweers: nope :-)
<makomo>
i've never really used scheme. tried it a couple of times but i like CL better i think
hhdave has joined #lisp
<schweers>
makomo: try it and you may understand why I don’t like it ;)
<xificurC>
White_Flame: hi. My mind can't imagine such use cases yet
<ecraven>
I've even pondered creating a small wrapper around CL to make scheme code run, but I cannot figure out how to make CL into a lisp-1
<mrm>
I was pretty taken in with Racket's promise of an extensible api to the compiler, but I feel like CL delivers on that front so much more.
<akkad>
or continuations :P
<White_Flame>
xificurC: it's simple runtime editing. Change CL source code, and next time you call a defun, the new behavior is there. Change LoL-based source code, and next time you call an object's method, the behavior is still the old behavior
<xificurC>
White_Flame: you mean having a running instance and reloading a source code file.
<mrm>
ecraven: Maybe a macro that defines '(define x y)' as something that binds both slots to the same thing?
<ecraven>
mrm: I don't think that's enough. same for LET, LET* etc.
<ecraven>
but that's how much I'd love to get a fully-working SLIME in Scheme :P
buoyantair_ has joined #lisp
<shka>
I don't think anyone with sane mind would attempt to use LOL style objects over CLOS objects
<xificurC>
White_Flame: and CLOS achieves that through what, more indirection?
<White_Flame>
yes
EvW1 has joined #lisp
<White_Flame>
CLOS doesn't put functions inside objects
<shka>
but as a concept, they are quite useful
<mrm>
Oh, fair. Maybe something that inserts an #%app wrapper around every function call?
<White_Flame>
functions are toplevel
Kundry_Wag has joined #lisp
<ecraven>
mrm: yea, something like that would probably be needed :-/
<White_Flame>
xificurC: and even in the (defun do-something-to-object (obj var) ...) case without CLOS, that's still runtime modifiable for all objects without additional indirection, simply because it's not hidden inside object instance closures
buoyantair has quit [Ping timeout: 276 seconds]
damke has joined #lisp
<xificurC>
White_Flame: thanks for the clarification
<White_Flame>
now, of course, objects that are configurable in their behavior might want to contain function objects themselves, but when you have a 'class' of object, being unable to edit that general class's behavior during runtime editing is a limitation
shrdlu68 has quit [Ping timeout: 240 seconds]
<White_Flame>
and also, introspection of those objects then requires creating facilities to access the closure fields. Without LoL, you can easily see & introspect the object state
<White_Flame>
because it's just a plain data object with no hiding
shrdlu68 has joined #lisp
damke_ has quit [Ping timeout: 244 seconds]
<xificurC>
case uses eql? Can I case over characters?
<White_Flame>
eql works for comparing characters
<shka>
xificurC: sure
Kundry_Wag has quit [Ping timeout: 264 seconds]
EvW1 has quit [Ping timeout: 264 seconds]
<akkad>
b#e
<shka>
White_Flame: i think that most of things in LOL are demonstration of what CAN be done, not what should be done ;-)
<White_Flame>
I agree
<White_Flame>
it's a good exercise to learn from
<shka>
I actually have good use for pandoric macros
<shka>
i made generators
<shka>
well, sort of
hhdave has quit [Ping timeout: 264 seconds]
<shka>
but nontheless, technics desribed in LOL can be sometimes put to good use
shrdlu68 has quit [Ping timeout: 264 seconds]
shrdlu68 has joined #lisp
<White_Flame>
it would be nice if there was some standard, programmatic way to access closed-over variables from function objects
pjb`` has joined #lisp
<White_Flame>
but I'm sure there are weird nesting cases that would make access ambiguous or unwieldy
shangul has joined #lisp
<shka>
White_Flame: oh god, how horrible code would become if people would work like this
<phoe>
^
pjb` has quit [Ping timeout: 260 seconds]
<White_Flame>
oh, totally. But it would be useful for logging & debugging
<White_Flame>
but, isn't that LoL-style anyway? ;)
<White_Flame>
like, literally what pandoric macros are for?
<phoe>
there are other standard CL facilities that support logging and debugging, CLOS being the first thing that comes to mind
<White_Flame>
(then again, I guess it's named "pandoric" for a reason ;) )
<shka>
hehe
<White_Flame>
phoe: I simply mean that logging & debugging might want lower level access to data than normal code
<shka>
White_Flame: panodric macro can be usefull here in there, but when they spread in code it quickly becomes turbocancer
shrdlu68 has quit [Ping timeout: 245 seconds]
<phoe>
White_Flame: one of Lisp strengths is that almost everything is normal code
<shka>
as for debugging, slime inspector can show you values that are closed over the function
shrdlu68 has joined #lisp
<White_Flame>
shka: right, because it uses implementation specifics
<phoe>
the moment you split the code into lower code and upper code, then you lose when you want to debug this lower code
<phoe>
because you likely need lower lower code
<phoe>
and then you recurse
<shka>
White_Flame: well, isn't that sufficient for debugging?
<White_Flame>
I mean if you're going to write your own debugging tools
<White_Flame>
to be able to be portable across implementations would be nice
<xificurC>
how much different is using CLOS compared to clojure's way of using (hash-)maps for objects
sjl has joined #lisp
<beach>
xificurC: I don't know what Clojure does, but from your description, it sounds like it would be very slow.
<shka>
xificurC: veeeeeery different
EvW has joined #lisp
<shka>
and main reason why i still program in CL rather then in clojure
<beach>
xificurC: Are you saying that they do a hash-table lookup for ever slot access?
<makomo>
shka: "oh god, how horrible code would become if people would work like this" -- reminds me of stuff that non-lispers say about lisp's macros :-), but i do agree that it would probably be a mess
shrdlu68 has quit [Ping timeout: 256 seconds]
<xificurC>
beach: data structures are immutable, it's not a hash table lookup but I think maps are trees with 32 nodes at each level so lookup is like O(log32 n)
shrdlu68 has joined #lisp
<beach>
makomo: One hopes that those non-lispers also don't write abstractions in the form of functions.
<makomo>
hahaha :-)
EvW has quit [Client Quit]
<beach>
xificurC: I see. Still much slower than a typical CLOS access.
<makomo>
beach: hmm, how does CLOS do it? or rather, what's the usual technique of speeding it up?
<shka>
xificurC: honestly, i find clojure lack of true object orientation to be it's biggest flaw
<beach>
makomo: The slot accessor goes directly to the instance, with a fixed offset.
m00natic has joined #lisp
<shka>
it is wonderful language, but i can't accept this
<p_l>
shka: doesn't it have proper object orientation which tends to be ignored in favour of passing maps around?
<xificurC>
shka: it's much less ceremony though :)
<p_l>
there's not much ceremony in CLOS
<xificurC>
p_l: mainly yes
<p_l>
there's much more in actually using objects in Clojure, at least last time I tried
<shka>
p_l: no inheritence for instance
<p_l>
ehh, inheritance I don't care that much, composition otoh
<makomo>
beach: is this something that the compiler has to take care of, or can it be done within lisp?
sjl has quit [Ping timeout: 264 seconds]
<makomo>
in the sense of "does it require any low-level knowledge, etc."
<p_l>
makomo: can be implemented in Lisp, but some optimizations might involve low-level compiler access
<xificurC>
inheritance with maps? Isn't that just merge?
<beach>
makomo: It can be done as portable code, but that code invokes the compiler. Not a problem though, because the compiler is part of the standard.
<makomo>
mhm i see, beautiful. :-)
<p_l>
WITH-SLOTS can just "preinit" symbols with references direct to slots in portable code for example
<xificurC>
when objects don't carry their methods with them inheritance and composition seem to be more similar
<p_l>
method calls can implement local caches using some CL structures
<p_l>
(which I don't recall right now... LOAD-TIME-VALUE?)
<makomo>
p_l: what would "preinit" be?
<p_l>
makomo: running a possibly complex lookup from instance reference to physical slot contents
<makomo>
oh, as an optimization, instead of the usual symbol-macrolet business?
<p_l>
yeah
<makomo>
that's pretty cool
<beach>
p_l: It is a bit tricky though, since classes can be redefined at run time.
<makomo>
i was just about to ask what about that
<makomo>
so i guess it's not the most commonly used optimization?
<p_l>
beach: yes, but if the class redefinition happens *outside* of with-slots block, my idea doesn't even notice any problem
<beach>
p_l: Oh, so you do the computation when that block is entered?
<beach>
That would be too slow in general.
<p_l>
beach: essentially, when entering a with-slots form, it does the equivalent of (let ((slot-name (compute-effective-slot instance slot-name)) ...)
<beach>
Oh, that's too slow.
<beach>
There are better ways.
<p_l>
beach: I was thinking that this could be "phase 1" of such optimization
<p_l>
also what I can figure in 5 minutes I could implement in portable CL :)
<beach>
makomo: Those optimizations are part of PCL as I recall.
<makomo>
never heard of an implementation named PCL so i suppose you're referring to the book?
<beach>
I know how to do it with accessors, but I don't remember the details of how to make slot-value with a constant slot name fast. It is similar though.
<makomo>
oh, Portable Common Loops?
<p_l>
makomo: no, "Portable Common Loops", which is where most implementations got their CLOS code from
<p_l>
yep
<beach>
makomo: Portable Common Loops. A portable implementation of CLOS.
shrdlu68 has quit [Ping timeout: 260 seconds]
svillemot has joined #lisp
<makomo>
are Common Loops and Portable Common Loops two different things?
shrdlu68 has joined #lisp
<p_l>
makomo: Common Loops are, iirc, earlier version of the code that wasn't portable
<p_l>
PCL was cleaned up and portable (and integratable) code
shangul has quit [Ping timeout: 265 seconds]
<makomo>
ah i see. i've heard about a few ancestors of CLOS (CL, Flavors, etc.) but never PCL
<makomo>
does anyone know how the "visitor pattern" would scale when you want to do n-dispatch, where n >= 3?
damke has quit [Ping timeout: 244 seconds]
<beach>
p_l: My guess would be that they turn (slot-value x 'bla) into a slot reader like (slot-value-bla x), and then it can be treated as a slot reader which I know how to optimize.
<makomo>
how would the generalization even look? how many classes would you have to use?
<makomo>
i wonder if there's a recurrence relation or something for it
<p_l>
makomo: I'm missing something :|
<beach>
makomo: You don't need the visitor pattern in Common Lisp.
<makomo>
of course, i'm aware :-)
<makomo>
i want to analyze how bad it would be in languages that don't have multimethods
<shka>
you don't need majority of patterns in CL
<makomo>
yup
* p_l
still doesn't understand
<shka>
norvig has article about that
<makomo>
p_l: i've only ever seen visitors used for 2-dispatch
<makomo>
never anything beyond that
<p_l>
isn't visitor pattern just MAP over a collection of OBJECTS calling a LAMBDA that calls something in OBJECT ?
<p_l>
makomo: 2-dispatch? where
<makomo>
p_l: the canonical example of "drawing shapes on a display"
damke has joined #lisp
<makomo>
you want to dispatch both on the type of the shape and the type of the display
<makomo>
hence, double dispatch
<makomo>
now let's say you have additional parameters whose types you want to switch on (i.e. n >= 3). i'm interested in how it would be done
<makomo>
oh, when i said "how many classes would you have to use", i meant "abstract classes" or "interfaces"
<p_l>
makomo: I'd compose this shit out of lambdas, tbqh
<makomo>
hahaha
<makomo>
let's say you're stuck within java :-)
<makomo>
this is for scientific purposes only of course :D
<makomo>
i'm not interested in doing it within CL, since CL has multimethods so we don't need the pattern anyway
<p_l>
makomo: I mean, I see the problem described, and I see myself do it by implementing "standard protocols" and passing possibly anonymous class instances that compose the specific environment I want
shrdlu68 has quit [Ping timeout: 256 seconds]
<p_l>
the CAD drawing example, I'd have standard drawing protocol, and "drivers" implementing different ways of drawing
shrdlu68 has joined #lisp
<p_l>
then I could pass an object representing the object to draw an instance of already set-up driver (2nd dispatch as I understand you), which could be an anonymous class that delegates everything to a preconfigured specifically instance of another driver (for example it needs an instance of the drawing medium, like a file or GPU handle), which would be 3rd instance
<makomo>
p_l: hm, would that be almost like CPS? dispatch one, next class, dispatch two, next class, etc.?
<p_l>
no, not really
<p_l>
this is more like abstraction using lambdas
<p_l>
from reading example code on Wikipedia, I see I turned it inside out
<makomo>
i was only referring to this characteristic of "continuing", rather than the core of what CPS is supposed to be, but i guess it's not a good analogy anyway
milanj has quit [Quit: This computer has gone to sleep]
<makomo>
right, so you would have these nested instances right?
<p_l>
well, composed instances
<p_l>
you care only about the interface
<makomo>
right
<p_l>
kinda currying multiple dispatch into single dispatch
<makomo>
yup, exactly that
_cosmonaut_ has joined #lisp
red-dot has joined #lisp
<p_l>
I kinda see what they do in the example code but I don't exactly see *why*
shrdlu68 has quit [Ping timeout: 264 seconds]
shrdlu68 has joined #lisp
<makomo>
i always have to "relearn" how exactly the visitor pattern does what it does, because it's a bit convoluted
<p_l>
the CL example for visitor pattern quickly becomes simple structure traversal xD
<makomo>
:-)
<makomo>
right, the first dispatch is on accept(), and then the second one is on visit()
<akkad>
something not right (map nil #'(lambda (x) (bt:make-thread #'(lambda (x) (format t "~a" x)))) '(1 2 3 4))
<makomo>
however, visit() has multiple overloads, one for every concrete class of the hierarchy that is being traversed
<makomo>
those are all separate functions of course
<varjag>
interesting.. i have two hosts set up to the same timezone, yet sbcl decode-universal-time gives different results
<varjag>
on the same timestamp
<varjag>
what am i missing
shrdlu68 has quit [Ping timeout: 276 seconds]
<p_l>
varjag: check env vars
<varjag>
hmm
shrdlu68 has joined #lisp
_cosmonaut_ has quit [Quit: Leaving.]
_cosmonaut_ has joined #lisp
<schweers>
akkad: MAKE-THREAD wants a thunk, not a function of one argument.
_cosmonaut_ has quit [Client Quit]
_cosmonaut_ has joined #lisp
<schweers>
akkad: also you might want to either emit an extra newline, or call FINISH-OUTPUT from the threads.
<varjag>
nope, no apparent difference in vars
<akkad>
right
<akkad>
half asleep
smurfrobot has joined #lisp
<akkad>
thought thunk was just a scheme term
<schweers>
I first encountered it while reading about what the haskell compiler does (in broad terms)
<aeth>
(The initial bindings part is one of several ways to use SLIME's stdout instead of the default, which isn't SLIME's, assuming you're in SLIME or something similar)
<aeth>
oh, (finish-output), too, but SLIME handles it (your inferior lisp might not, which is why it looks like it vanished instead of going there when you didn't bind the stdout)
<aeth>
Of course, to get the phantom numbers to show up there, just do this: (bt:make-thread #'(lambda () (finish-output)))
<aeth>
I personally I have "12341234" in *inferior-lisp* after doing that.
<mfiano>
aeth: You shouldn't ever prefix (lambda ...) with #'
<aeth>
mfiano: I was just working with akkad's initial code. My normal style doesn't use #'(lambda
deng_cn has quit [Quit: deng_cn]
<mfiano>
The lambda macro expands to (function (lambda ...)) which is the same as #'lambda, just less code. More importantly though, if you're in code position the macro will do the correct thing, or you're in data position and using #'lambda will expand to (function (lambda ...)) which is not evaluated. lambda may not even be cl:lambda so the expansion of (cl:function (pkg:lambda ...)) won't even be valid. So best
<mfiano>
case, it does nothing. Worst case it breaks stuff.
karswell_ has joined #lisp
<schweers>
also, it looks weird ;)
karswell_ has quit [Remote host closed the connection]
Bronsa has joined #lisp
<akkad>
#'lambda screws with my paren matching
karswell_ has joined #lisp
shrdlu68 has quit [Ping timeout: 265 seconds]
shrdlu68 has joined #lisp
<varjag>
p_l: ok, the versions of sbcl are different.. should look into that
<aeth>
Oh, and if you want 1324 to show up more frequently, perhaps try inserting a sleep. e.g. (map nil (lambda (x) (bt:make-thread #'(lambda () (sleep 1) (format t "~a" x) (finish-output)) :initial-bindings `((*standard-output* . ,*standard-output*)))) '(1 2 3 4))
<mfiano>
and now you're just not being consistent :)
<aeth>
Well, I'm working with the initial code snippit in one line, it's becoming difficult to notice style
<akkad>
so (lambda can be used the same as #'lambda?
<aeth>
In most but not all Common Lisps.
hjek has joined #lisp
<aeth>
Old style guides will say to put the #' there in #'(lambda so it will work on all of them.
<akkad>
thanks for the info
<mfiano>
In all Common Lisps
<mfiano>
The standard requires it, albeit was a late addition to the standard
<aeth>
If it was added after CLtL and before ANSI Common Lisp, then there are "Common Lisps" from 1984-1994 without it, as well as potentially unconforming CLs. I suppose that's increasingly irrelevant, though.
hjek has left #lisp [#lisp]
shrdlu68 has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
<mfiano>
Very much so. The standard clearly states, that they should be equivalent
<mfiano>
By using the reader macro to refer to the second namespace, you are A) preventing shadowed lambda symbols from working, and B) sort of makes no sense because lambdas are anonymous, so no need for the second namespace
mrblack_ has quit [Remote host closed the connection]
mrblack_ has joined #lisp
shrdlu68 has quit [Ping timeout: 264 seconds]
shrdlu68 has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Remote host closed the connection]
shrdlu68 has joined #lisp
jmercouris has joined #lisp
mrblack_ has quit [Remote host closed the connection]
nowhereman_ has joined #lisp
mrblack_ has joined #lisp
smurfrobot has joined #lisp
mrblack_ has quit [Remote host closed the connection]
mrblack_ has joined #lisp
hhdave has joined #lisp
milanj has joined #lisp
smurfrobot has quit [Remote host closed the connection]
shrdlu68 has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
shrdlu68 has quit [Ping timeout: 264 seconds]
shrdlu68 has joined #lisp
vlatkoB_ has joined #lisp
karswell_ has quit [Read error: No route to host]
karswell_ has joined #lisp
vlatkoB has quit [Ping timeout: 260 seconds]
securelord has joined #lisp
securelord has quit [Ping timeout: 248 seconds]
TCZ has joined #lisp
lumm has joined #lisp
zaquest has quit [Ping timeout: 264 seconds]
mrblack___ has joined #lisp
mrblack_ has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
``Erik_ has joined #lisp
``Erik has quit [Ping timeout: 256 seconds]
karswell_ has quit [Read error: No route to host]
karswell_ has joined #lisp
heisig has joined #lisp
smurfrobot has joined #lisp
shrdlu68 has quit [Remote host closed the connection]
shrdlu68 has joined #lisp
<jmercouris>
how could one transform a single dimensional array of 9 elements into a two dimensional array of 3x3?
<jmercouris>
I can think of ways to do it, but is there a built in?
<jmercouris>
or some clever way that doesn't involve traversing each element and populating the second array?
mrblack___ has quit [Remote host closed the connection]
mrblack___ has joined #lisp
EvW has joined #lisp
<jmercouris>
heisig: yes, indeed, thank you
<schweers>
jmercouris: note that array displacement can come with a severe performance cost
<jmercouris>
schweers: I'll keep that in mind, thanks
<schweers>
I tried array displacement in a project where performance is really important and it was really horrible. Obviously, YMMV.
redeemed has joined #lisp
<jmercouris>
Yeah, I don't need to invoke it a lot, this is a prototype project as well
<jmercouris>
it's the QR Video concept I was talking about earlier
karswell_ is now known as karswell
SenasOzys has joined #lisp
SenasOzys has quit [Remote host closed the connection]
MasouDa has joined #lisp
<ym>
Do somebody has "error in process filter: Wrong number of arguments: (0 . 1), 2" messages in emacs 26.1 + slime?
<loke>
Yay! I probably used CADADR for the first time for real today :-)
<loke>
In the repl, but still
<_death>
ym: yes, someone mentioned it lately.. the solution was to use slime bleeding edge (clone the repo)
<loke>
This has been known for well over a year if you've been on git versions of Emacs ;-)
<_death>
true.. but if you're using bleeding edge emacs, then it's likely that you're doing the same for slime and friends ;)
<loke>
_death: For the longest time I didn't. I just manually poatched Slime :-)
<_death>
well, I have patches for slime that fix such issues, and wonder how come no one else had them so they didn't get fixed
scymtym has joined #lisp
Kevslinger has joined #lisp
EvW has quit [Ping timeout: 245 seconds]
Guest40730 is now known as thekolb
Cymew has joined #lisp
Cymew has quit [Ping timeout: 255 seconds]
<ym>
_death, thanks.
lumm has quit [Read error: Connection reset by peer]
<jmercouris>
I prefer my editor not to crash randomly, I upgraded to 26, but I then upgraded again to 25 :D
mrblack___ has quit [Remote host closed the connection]
Bronsa has quit [Remote host closed the connection]
mrblack___ has joined #lisp
markoong has joined #lisp
karswell has quit [Read error: Connection reset by peer]
karswell has joined #lisp
<schweers>
jmercouris: why? did emacs 26.1 crash? I find it to be a tad slow, but seems stable so far.
<jmercouris>
schweers: I can't recall, some incompatibility with some packages on my system
<jmercouris>
to be fair, it wasn't a literal crash, but grinding to halt in which C-g repeatedly pressed until I could do something again
<schweers>
I had a few problems with elfeed, probably due to added records in emacs 26.1, but I could just remove the database. Not perfect, but was good enough for me.
<jmercouris>
I use elfeed as well, that was just one of a few packages
buoyantair_ has quit [Ping timeout: 256 seconds]
MasouDa has quit [Ping timeout: 256 seconds]
TCZ has quit [Quit: Leaving]
<jmercouris>
I have an array like this 1,2,3, how might I make an array padded to 6 elements like this, 1,2,3,0,0,0
<jmercouris>
I tried make-array with initial-element and initial-contents, but you can't use both
<jmercouris>
which makes sense I guess
buoyantair_ has joined #lisp
<shrdlu68>
jmercouris: Make a second array from the first?
<jmercouris>
Yes, this is possible
<jmercouris>
I'm still thinking about it though, maybe there is some better way
<shrdlu68>
jmercouris: I'm not sure, but what about #'adjust-array?
<jmercouris>
it's a non adjustable array
<jmercouris>
simple-vector
EvW1 has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<jmercouris>
shka: Lol, man, nice
<jmercouris>
It does work, I'll tell you that
<shka>
sure it does
<shka>
unless you want fill pointer
<jmercouris>
Blows my mind, what made you think of this idea?
<makomo>
know your maps :-D
<shka>
jmercouris: well, working with sequences
<makomo>
schweers: why would displacement cause such a large performance hit?
<shka>
map in lisp is probabbly one of fundamental tool to work with generic sequences
<shka>
so i just ended up using it a lot for code that is supposed to work with both list and arrays
<schweers>
what I forgot to mention was that I was using simple arrays of a specific type, so a displaced array causes an indirection and possibly bounds-check (I’m speculating her). I expected a mild performance hit, but was quite surprised at how significant it was. I have no idea why it was that much, and sadly don’t have the numbers anymore.
karswell has quit [Remote host closed the connection]
<shka>
displaced-arrays in sbcl are quite sluggish
TCZ has joined #lisp
rafasc has joined #lisp
karswell has joined #lisp
rafasc has left #lisp ["WeeChat 2.1"]
<jmercouris>
shka: I know the function, but I would have not thought of using it this way
<makomo>
hm weird. i would expect arrays to just have a dope/stride vector and a pointer to storage (and possibly a reference to the array that owns the underlying storage)
<makomo>
i don't see why they would be so much less efficient
<makomo>
the bounds check should also happen when accessing a normal array too no?
CrazyEddy has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 245 seconds]
karswell has quit [Read error: Connection reset by peer]
Bike has joined #lisp
<xificurC>
is using #1= reader macro considered bad taste? This seems to replicate anaphoric macro features in a funny way. (if #1=(+ 2 3) #1# 0)
<beach>
xificurC: The expression will very likely still be evaluated twice.
<beach>
But, no, it is not considered bad taste.
<xificurC>
beach: oh, I thought it's going to be evaluated only once
<xificurC>
let's try
<beach>
xificurC: Not very likely. The compiler typically does not take that sharing into account.
<xificurC>
twice
<xificurC>
so it's like copying the s-exp
<beach>
Plus, the compiler would have to prove that there are no side effects.
<beach>
No, it is not copying it.
<xificurC>
not storing the result in some special #1#
<xificurC>
I'll look up the docs, don't bother
<beach>
But it is traversing it twice, and compiling similar but duplicate code for it each time.
<xificurC>
surely you have better things to do
<beach>
xificurC: #1# is a reader feature.
<beach>
By the time the compiler sees it, the #1# is gone.
smurfrobot has joined #lisp
<beach>
All the compiler could possibly see is sharing.
smokeink has joined #lisp
<beach>
But it very likely doesn't bother.
<xificurC>
so it's the same list in memory (eq)
<beach>
If you are lucky, it could use common sub-expression elimination, but it would do that even if you duplicate the expression.
<beach>
However, on today's architectures, it is not clear that common sub-expression elimination is worth the effort.
<beach>
It is often cheaper to recompute the expression than to store the result.
<beach>
And, not many programmers will repeat big and costly common sub-expressions anyway.
<beach>
The ones that will be repeated are small, like (1+ x) (+ x y), (car x), etc.
smurfrobot has quit [Ping timeout: 260 seconds]
Patzy has quit [Quit: WeeChat 2.1]
Patzy has joined #lisp
warweasle has joined #lisp
EvW1 has quit [Ping timeout: 265 seconds]
SenasOzys has joined #lisp
Kundry_Wag has joined #lisp
Pixel_Outlaw has joined #lisp
Pixel_Outlaw has quit [Client Quit]
mindCrime has joined #lisp
getha has quit [Ping timeout: 268 seconds]
Kundry_Wag has quit [Remote host closed the connection]
jmercouris has quit [Remote host closed the connection]
damke_ has joined #lisp
damke has quit [Ping timeout: 244 seconds]
igemnace has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 244 seconds]
<makomo>
beach: "If you are lucky, it could use common sub-expression elimination, but it would do that even if you duplicate the expression." -- meaning that this elimination usually happens on some lower form, like IR?
<Xof>
I have a feeling that code with shared structure invokes undefined behaviour in CL.
<makomo>
why?
<Xof>
I don't know
<Xof>
I just spent 5 minutes trying to find a reference and failed, so my feeling might be wrong
<makomo>
i doubt that #= and ## would exist if that was the case
lumm has joined #lisp
<Xof>
well they would still be useful for data structures with shared structure
<Xof>
and for printing code with gensyms in it
<Xof>
I mean specifically list structure, but, again, I'm failing to find a reference so I might well be wrong
<Xof>
(and I use (do ((x #1=(complicated thing) #1#)) ...) all the time, so I'm a hypocrite as well)
Kundry_W_ has joined #lisp
random9899 has joined #lisp
Kundry_W_ has quit [Remote host closed the connection]
<_death>
that's an old idiom, so I doubt they'd rule it out
Kundry_Wag has joined #lisp
<schweers>
I can’t help but think that its more readable to use a local binding (i.e. with a name) instead, at least in most cases
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
<Bike>
infinitely deep or long code is banned somewhere, i think, but i doubt structure sharing is banned in general
shrdlu68 has joined #lisp
<Bike>
macroexpansion can get you that pretty easily, and e.g. the clhs page on load-time-value talks about the possibliity
<Bike>
sorta
kerrhau has quit [Ping timeout: 260 seconds]
mindCrime has quit [Ping timeout: 264 seconds]
Kundry_Wag has quit [Remote host closed the connection]
pjb`` has quit [Remote host closed the connection]
pjb`` has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
milanj has quit [Quit: This computer has gone to sleep]
TCZ has joined #lisp
<ym>
govna
<ym>
What about Open Genera. Is there free fork?
<shka>
no
<ym>
Strange.
smurfrobot has joined #lisp
<shka>
ym: it is closed to the bone
smokeink has quit [Remote host closed the connection]
<drunk_foxx[m]>
Genera's source code was leaked in 2015, if I am not mistaken
<shka>
does not make it open source
smurfrobot has quit [Remote host closed the connection]
scymtym__ has joined #lisp
<ym>
It makes it easy to convert to open source version.
<ym>
If you know what I mean.
<ym>
There is even manual how to run it on linux.
<beach>
makomo: Yes, common sub-expression elimination is usually done on the level of a flow graph.
scymtym_ has quit [Ping timeout: 245 seconds]
<beach>
ym: You can't legally transform proprietary code. It is called "derivative work" and it is subject to the restrictions of copyright law.
damke_ has joined #lisp
damke has quit [Ping timeout: 244 seconds]
<ym>
What do you mean telling "transform"? I can use the proprietary code as a textbook and write my own free implementation of principals I learned.
<flip214>
you still have to re-type _everything_, no copy/paste
<Bike>
don't be stupid
<beach>
flip214: That's not enough.
<Bike>
it's not a matter of typing
<flip214>
well, of course it has to be _different_ enough too
<Bike>
it's "intellectual" property because it's tied to actual ideas, not some kind of physical labor
<flip214>
Bike: there are no software patents in europe.
<flip214>
so ideas alone shouldn't be protected.
<shka>
flip214: does not matter
<shka>
ym: sadly, no open source genera
<beach>
ym: That's debatable. And that is also the reason why people who write free software avoid looking at proprietary code as much as possible.
<Bike>
can you copyright it?
<shka>
which kinda sucks
<shka>
want lisp os, do it yourself
<flip214>
Bike: AFAIK only one specific expression of an idea.
<shka>
like in the case of mezzano
smokeink has joined #lisp
<shka>
mezzano is amazing considering timescale
<flip214>
clean-room implementations typically go the route of a description that's surely "different enough"
<Bike>
i don't think using the leaked code as a textbook would really be clean room reimplementation
<beach>
I agree with Bike.
<beach>
It would be very risky.
<shka>
anyway, i understand that genera is cool
<shka>
but it is pretty much obsolete at the same time
<beach>
I think we can do better than Genera anyway.
<shka>
beach: exactly
<flip214>
Bike: no, surely not. you'd need a transcription step inbetween, eg. via an english text.
fraya has quit [Remote host closed the connection]
<shka>
given time and effort, we can build even better things that will last longer
_cosmonaut_ has quit [Ping timeout: 265 seconds]
<Bike>
right
SenasOzys has quit [Remote host closed the connection]
<skidd0>
i'm really new to lisp, so i'm not sure what i'm looking at here
<skidd0>
some lisp macros
<skidd0>
some js macros
dcluna has joined #lisp
<skidd0>
oh the js ones are all wrapped up in one definition statement
<skidd0>
so those are a bunch of macros
<skidd0>
i see
<akkad>
skidd0: #clnoobs is a also a great resource.
<skidd0>
thanks
<on_ion>
skidd0: i forget, that was a few years ago =) it felt like i had puppet strings on top of javascript though, which is my main aim with LISP, do more effect with less cause
<on_ion>
like setting up a bunch of gears to move the world but only having to turn a little wheel =P
<skidd0>
i see
<skidd0>
yes that's what's pulling me into lisp atm.
<skidd0>
i am attracted to the bottom up, top down programming that Paul Graham's talked about in some of his essays
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
<skidd0>
and designing DSLs for tasks
<on_ion>
human time and effort is precious , may as well get the machine working as we designed them (, prolog too)
<skidd0>
right
<on_ion>
yes me too, and the idea of starting out prototype dynamically, then working toward (molding/guiding) a static implementation of whatever we are doing
<skidd0>
YES
<skidd0>
and i'm falling in love with the iterative design with a REPL
<skidd0>
I use vim w/ vlime rather than the usual emacs+slime
<on_ion>
same, i was almost dependant on edit/compile/run/debug cycle of aforetimes
<skidd0>
after trying spacemacs for a heavy week
<on_ion>
thats ok =)
<skidd0>
it's really nice to just "have an idea" > "make a basic prototype of idea" > "refine that" > "have another idea"
<skidd0>
it's straight up FUN to program again
Bronsa has quit [Ping timeout: 260 seconds]
<on_ion>
yes =) when i pick up a guitar or piano, i just play, realtime improv, no premeditated design tech spec to implement, just let creation happen joyfully
<skidd0>
that's the nature of creation to me, play
<on_ion>
yeah =) if its not fun, chances are we are destroying =P
Kundry_Wag has joined #lisp
<skidd0>
i dunno, that can be fun, too
habamax has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
shka_ has joined #lisp
light2yellow has quit [Quit: light2yellow]
Kundry_Wag has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Cymew has joined #lisp
nika has quit [Quit: Leaving...]
rixard has joined #lisp
ckonstanski has joined #lisp
papachan has quit [Ping timeout: 256 seconds]
rixard has quit [Client Quit]
Cymew has quit [Ping timeout: 240 seconds]
red-dot has joined #lisp
<on_ion>
skidd0: certainly two sides of the same coin, as creation destroys and destruction creates, but in fun or not may decide which side we are looking at=)
FreeBirdLjj has joined #lisp
sz0 has joined #lisp
fikka has joined #lisp
wigust has joined #lisp
dilated_dinosaur has quit [Remote host closed the connection]
papachan has joined #lisp
jack_rabbit has quit [Ping timeout: 240 seconds]
dilated_dinosaur has joined #lisp
lumm has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 248 seconds]
quazimodo has quit [Ping timeout: 245 seconds]
buoyantair has quit [Quit: Leaving]
terpri has joined #lisp
fikka has joined #lisp
johs has quit []
fikka has quit [Ping timeout: 264 seconds]
johs has joined #lisp
eli_oat has quit [Quit: Leaving.]
r5n has joined #lisp
Guest29019 has quit [Remote host closed the connection]
<ZigPaw>
as I long time ViM user I found doom-emacs config for emacs and sly for common lisp interaction quite sleek and functional (and I can use org-mode as an added bonus).
r5n has quit [Client Quit]
Sonny_ has joined #lisp
Sonny_ has quit [Client Quit]
snits has quit [Quit: leaving]
snits has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
red-dot has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
EvW has joined #lisp
makomo has joined #lisp
sauvin has quit [Remote host closed the connection]
<sukaeto>
skidd0: +1 for caveman2. If you're used to Flask, you'll feel (relatively) at home
<skidd0>
the thing is, i'm not sure staying on safe shores it the best approach
<sukaeto>
(I say "relatively" because Python and Common Lisp are quite different)
<skidd0>
i want something lispy
<skidd0>
that makes me think lispy
<sukaeto>
well, it *is* Lispy
snits has quit [Quit: leaving]
snits has joined #lisp
<sukaeto>
but it's got syntax for Sinatra style routes and whatnot
<skidd0>
yeah i saw that
<skidd0>
it did seem familiar
<sukaeto>
also Djula, which if you're familiar with Jinja, it's essentially that for Lisp
<skidd0>
i saw that in lucerne!
<skidd0>
i am used to that sort of template flow
<skidd0>
and extending a template in blocks
hjek has quit [Ping timeout: 264 seconds]
<sukaeto>
(granted, there's no requirement to use Djula with caveman2, but it comes along for the ride when you ql:quickload caveman2)
Kundry_Wag has quit [Remote host closed the connection]
<sukaeto>
also also: if you really want to get experience with Lisp. Eitaro Fukamachi's (the guy who wrote caveman) documentation tends to be pretty Spartan - usually a simple crash course on possible uses of the library. For the rest of it, you've got to look at his code.
<sukaeto>
which, I've found his code to be pretty easy to read/navigate.
<skidd0>
i've come to realize that's kinda the lisp way
<sukaeto>
(full disclaimer: I've also been using Lisp for some time)
<skidd0>
you're expected to check the source, tests, and exported package stuff
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Ping timeout: 245 seconds]
klm2is_ has quit [Quit: Leaving]
yoel has joined #lisp
yoel is now known as Guest85020
hjek has joined #lisp
smurfrobot has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
herr_jth has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<on_ion>
^_^
ryanwatkins has joined #lisp
Kundry_Wag has joined #lisp
karswell has quit [Ping timeout: 256 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
karlosz has quit [Ping timeout: 264 seconds]
surya has quit [Ping timeout: 245 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
nimiux has quit [Ping timeout: 240 seconds]
charh has quit [Quit: ZzZ]
skidd0 has quit [Quit: WeeChat 2.1]
Bronsa has joined #lisp
lumm has quit [Read error: Connection reset by peer]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
Kundry_Wag has quit [Remote host closed the connection]
Intensity has quit [Ping timeout: 260 seconds]
ym has quit [Remote host closed the connection]
Intensity has joined #lisp
red-dot has joined #lisp
Kundry_Wag has joined #lisp
rumbler31 has quit [Remote host closed the connection]
karlosz has joined #lisp
puchacz has quit [Quit: Konversation terminated!]
charh has joined #lisp
lumm has joined #lisp
lumm has quit [Read error: Connection reset by peer]
jasom has joined #lisp
charh has quit [Client Quit]
vlatkoB_ has quit [Remote host closed the connection]
lumm has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Intensity has quit [Ping timeout: 260 seconds]
charh has joined #lisp
Intensity has joined #lisp
comborico1611 has joined #lisp
sjl_ has joined #lisp
ZombieChicken has joined #lisp
fraya has quit [Remote host closed the connection]
sjl_ has quit [Client Quit]
sjl_ has joined #lisp
lumm has quit [Ping timeout: 240 seconds]
sauvin has joined #lisp
Intensity has quit [Ping timeout: 260 seconds]
Intensity has joined #lisp
zaquest_ has joined #lisp
skeuomorf has joined #lisp
ym has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Seafood has joined #lisp
Kundry_Wag has joined #lisp
Seafood is now known as Seafood_
eli_oat has joined #lisp
ealfonso has joined #lisp
Smokitch has joined #lisp
<ealfonso>
I know it might be silly to ask this here. I want to write a simple web application. I have used clojure (ring, etc) and hunchentoot in CL. why should I prefer one over the other?
<ealfonso>
Intensity has quit [Ping timeout: 260 seconds]
shka_ has quit [Ping timeout: 260 seconds]
kerrhau has joined #lisp
kerrhau has joined #lisp
kerrhau has quit [Changing host]
Intensity has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
eli_oat has quit [Quit: Leaving.]
scymtym has joined #lisp
<_death>
you used both and ask us why you should prefer one to the other?
Smokitch has left #lisp [#lisp]
<ealfonso>
It seems that clojure is more 'sophisticated' for web app development, but I liked working with hunchentoot and I haven't used clojure in a while... I guess I'm looking for the lack of a strong reason to use clojure
herr_jth has quit [Remote host closed the connection]
Intensity has quit [Ping timeout: 260 seconds]
<_death>
flip a coin :)
smurfrobot has joined #lisp
manicennui has joined #lisp
<_death>
if it results in a bad choice, bend it a little
stacksmith has quit [Quit: stacksmith]
smurfrobot has quit [Ping timeout: 245 seconds]
tylerdmace has joined #lisp
tylerdmace has quit [Client Quit]
Intensity has joined #lisp
sjl_ has quit [Ping timeout: 248 seconds]
hjek has quit [Quit: Leaving.]
Cymew has joined #lisp
sjl_ has joined #lisp
vhost- has quit [Ping timeout: 276 seconds]
<aeth>
Does anyone use unit testing with CI, especially Gitlab CI? Is testing beyond unit testing ever done in CL?
Cymew has quit [Ping timeout: 265 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
nickenchuggets has joined #lisp
mindCrime has quit [Ping timeout: 264 seconds]
Guest85020 has quit [Remote host closed the connection]
Intensity has quit [Ping timeout: 260 seconds]
yoel has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
yoel is now known as Guest67495
Kundry_Wag has joined #lisp
hjek has joined #lisp
Intensity has joined #lisp
Guest67495 has quit [Ping timeout: 248 seconds]
Kundry_Wag has quit [Remote host closed the connection]
vhost- has joined #lisp
Intensity has quit [Ping timeout: 260 seconds]
sjl_ has quit [Quit: WeeChat 2.2-dev]
sjl_ has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
sjl has quit [Quit: WeeChat 2.0.1]
``Erik_ has quit [Ping timeout: 276 seconds]
Intensity has joined #lisp
rumbler31 has joined #lisp
sjl_ has quit [Client Quit]
``Erik has joined #lisp
sjl has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
lumm has joined #lisp
Intensity has quit [Ping timeout: 260 seconds]
<ZigPaw>
aeth yes, look at tests in ceramic for example: https://github.com/ceramic/ceramic/tree/master/t there are integration tests there as well (not much sophisticated but they are there). And you can see travis.yml file how they are executed by CI (and it is quite similar I think to yaml file from gitlab).
<pillton>
I wonder if it maintains an instance's state in a JSON data structure as well?
warweasle has joined #lisp
<jasom>
pillton: what do you mean?
<jasom>
pillton: encoding to json from a class should be mechanical for all specifiers except :any
smurfrobot has quit [Ping timeout: 240 seconds]
<pillton>
In data flow programming you often have computations where the output is the input with a few entries added. It is possible to create an instance of the class representing the input and the class representing the output from the same data structure.
robotoad has joined #lisp
<jasom>
pillton: this looks like it's specifically for round-tripping objects in JSON, so there doesn't appear to be a way to add or remove slots when encoding
<jasom>
it does allow for default values when decoding though
<pillton>
I am not sure if it is a good idea to do what I said earlier, but the pattern occurred often enough that I wondered if was worth thinking about the relationship between type and the representation of state.
<jasom>
this assumes that the representation of the state is a function of the type
<pillton>
"This" as in what I am saying or json-mop?
<jasom>
pillton: json-mop
<jasom>
I have an ad-hoc unspecified implementation of half of json-mop's functionality in one of my webapps...
smurfrobot has joined #lisp
<pillton>
It is probably worth banding together and giving it some more thought. This functionality with support in parenscript would be cool.
smurfrobot has quit [Ping timeout: 248 seconds]
<_death>
the approach seems similar to Go's
TCZ has quit [Quit: Leaving]
sz0 has quit [Quit: Connection closed for inactivity]
<jasom>
oh right, my implementation did have support on the parenscript side, which this doesn't appear to provide...
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
mikecheck has joined #lisp
vhost- has quit [Read error: Connection reset by peer]
TCZ has joined #lisp
smurfrobot has joined #lisp
azimut has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Ping timeout: 264 seconds]
talonfire441 has quit [Quit: talonfire441]
k-hos has quit [Read error: Connection reset by peer]