<pjb>
kenster: basically, you need to know two things: the size of each field, the position of each field.
<pjb>
kenster: tools like swig are not able to correctly extract those informations from C headers.
<pjb>
kenster: for example, they don't process #pragma pack.
<pjb>
kenster: structures can have strange alignment rules and as you can see, it can also depend from notations that are not in the C source (#pragma are outside of C, they're non-C code information given to the compiler.).
Kundry_Wag has joined #lisp
<pjb>
kenster: conclusion: you need to collect this information yourself (eg. use printf on (char*)s->field - (char*)s to get the offset, sizeof to get the size for each field).
<pjb>
then use that to access the fields yourself using memref, not using defcstruct.
<pjb>
kenster: did I tell you already NOT to use FFI? Just reimplemnt the fucking thing in lisp!
happy-dude has quit [Quit: Connection closed for inactivity]
nowhereman_ has quit [Ping timeout: 256 seconds]
nowhereman_ has joined #lisp
<kenster>
pjb:
<kenster>
sorry for not seeing your msgs
<kenster>
It was actually because of the c values being garbage collected by cffi
<kenster>
because I used foreign-values and was storing the ptrs of those on the c struct
<kenster>
so I made the constructor copy the values
<pjb>
There's no GC in C. Unless you link with Boehm GC?
<kenster>
no
<kenster>
what I mean is, the values went out of scope
<kenster>
cffi discards the values
<kenster>
when you allocate foreign values, it deletes them for you
<kenster>
so the char* pointers I had were wrong
<pjb>
There are CFFI macros that allocate C variables on the stack, yes.
<pjb>
But you don't have to use those macros. you can allocate on the heap.
<kenster>
the file upload procedure works now though
<kenster>
so it's all good
<pjb>
ok
<kenster>
I realized I should have been using cffi-grovel
<kenster>
too late now I suppose
<kenster>
my macros work
<kenster>
though actually the grovel file would be messy because it would generate wrappers for the cc_ functions too, though I suppose I could try to "blacklist" those
<kenster>
the cc_ functions are what the C functions call
_whitelogger has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
<LdBeth>
Good morning
hvxgr_ has quit [Ping timeout: 265 seconds]
hvxgr_ has joined #lisp
makomo has quit [Ping timeout: 276 seconds]
ebrasca has joined #lisp
<no-defun-allowed>
Morning LdBeth
EvW has quit [Ping timeout: 265 seconds]
pioneer42 has joined #lisp
karswell_ has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
acolarh has joined #lisp
Cymew has joined #lisp
wheelsucker has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
karlosz has joined #lisp
gehlw has quit [Quit: Leaving]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
lemo_ has joined #lisp
flazh has quit [Ping timeout: 244 seconds]
lemo has quit [Ping timeout: 244 seconds]
lemo_ is now known as lemo
nowhereman_ has quit [Remote host closed the connection]
jasmith has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
lemo has quit [Changing host]
lemo has joined #lisp
nowhereman_ has joined #lisp
Fare has joined #lisp
karlosz has quit [Quit: karlosz]
Kundry_Wag has joined #lisp
Trystam has joined #lisp
Tristam has quit [Ping timeout: 240 seconds]
Trystam is now known as Tristam
skidd0 has joined #lisp
daniel-s has joined #lisp
<skidd0>
has anyone here used snooze? How do you define a route on root?
xrash has quit [Ping timeout: 265 seconds]
robotoad has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
Fare has quit [Ping timeout: 256 seconds]
bleak has joined #lisp
<bleak>
What would be a real life metaphor for CLOS-style late binding?
<bleak>
I mean in the same sense that communication between cells is a metaphor for message passing in Smalltalk.
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
Cthulhux has quit [Ping timeout: 240 seconds]
krwq has joined #lisp
<Bike>
like, living cells? that's kind of a loose metaphor
<krwq>
how would you go about writing a macro which would add a prefix to every defun name? (also working recursively)
<Bike>
every defun name in what?
<krwq>
i.e. (with-prefix "FOO" (defun bar () (format t "(i am foobar)"))) and also (with-prefix "FOO" (with-prefix "BAR" (defun lol () (format t "(i am foobarlol)"))))
<Bike>
i wouldn't do that
<krwq>
why not?
<krwq>
I.d like to create some kind of namespaces
<Bike>
i would just write (defun foobar ...)
<Bike>
you have packages for that
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<krwq>
i'd like to do it myself in order to translate one language into lisp
<Bike>
if you really must, i'd use something other than defun
<Bike>
defun-with-prefix or something shorter, whatever
<krwq>
specifcally you get input as csharp code, then you translate that to lispish version of that and then translate it to lisp code which you could execute
<Bike>
biochemicals aren't usually sent to just one signal, is all
<Bike>
anyway i don't know any metaphor for multiple dispatch
<LdBeth>
doesn't C# have namespace?
<krwq>
so i already got lispification partially working - i used roslyn to generate lisp-like code
<krwq>
yes it does
<krwq>
that's why i need prefixes
<krwq>
in my lisp code i simply run csharp app which print out on the screen lisp code, then i translate and (rather try to for now) execute it
<krwq>
so i.e. i got csharp app with hello world
<krwq>
this is how my current test case look like (this is working): (defparameter *csharp-hello-world-lispified*
<krwq>
i'm thinking how to make it so that it generates something like (defun c#-HelloWorld-Program-Main (args) (format t "Hello, World!"))
Cthulhux has joined #lisp
<Bike>
assuming the contents of the variable are going to be executed in some lisp like way, i'd just have c#-namespace and c#-class bind a *current-namespace* variable or suchlike
<Bike>
then have c#-defun prepend it to its namespace
dddddd has quit [Read error: Connection reset by peer]
pierpa has quit [Quit: Page closed]
terpri has quit [Ping timeout: 256 seconds]
<krwq>
ok, i'll read about it over the weekend and finish once I understand how this works. If my project starts working for at least simple cases I'll likely put it somewhere public
Kundry_Wag has joined #lisp
dented42 has joined #lisp
smurfrobot has joined #lisp
dented42 has quit [Client Quit]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
smurfrobot has quit [Remote host closed the connection]
Orion3k has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
skidd0 has quit [Quit: WeeChat 2.1]
orivej has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
pjb has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
Bike has quit [Quit: Lost terminal]
Kundry_Wag has quit [Ping timeout: 268 seconds]
bleak has quit [Quit: Page closed]
Orion3k has joined #lisp
smurfrobot has quit [Remote host closed the connection]
dented42 has joined #lisp
rippa has joined #lisp
smurfrobot has joined #lisp
lemo has quit [Read error: Connection reset by peer]
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
adulteratedjedi has quit [Read error: Connection reset by peer]
adulteratedjedi has joined #lisp
<beach>
Good morning everyone!
daniel-s has quit [Remote host closed the connection]
panji has joined #lisp
smurfrobot has quit [Remote host closed the connection]
Fare has joined #lisp
vlatkoB has joined #lisp
eminhi has joined #lisp
panji has quit [Ping timeout: 240 seconds]
newbie has quit [Read error: Connection reset by peer]
Guest94317 has quit [Quit: leaving]
anon has joined #lisp
anon has quit [Changing host]
anon has joined #lisp
anon is now known as Guest29
nickenchuggets has quit [Read error: Connection reset by peer]
flazh has joined #lisp
terpri has joined #lisp
<phoe>
dlowe: actually I don't want to enter the debugger all the time - I want to signal a condition. Then the user may do whatever he pleases.
<phoe>
Signaling a condition /= entering the debugger, either.
panji has joined #lisp
sauvin has joined #lisp
smurfrobot has joined #lisp
fikka has joined #lisp
<beach>
Indeed.
Fare has quit [Ping timeout: 264 seconds]
saki has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Fare has joined #lisp
Kundry_Wag has joined #lisp
kajo has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<aeth>
phoe: You still might want to do it the return value way if it's faster if it needs to be fast.
<aeth>
e.g. if there's a reasonable expectation that it won't be successful many times in a hot loop
<aeth>
Multiple return values is also sort of the approach gethash does
<aeth>
(It also has an optional default value, so it kind of lets you handle it two ways.)
<aeth>
Imo, there isn't really a Lisp way. The Lisp way is to allow every style in one language.
<aeth>
s/style/paradigm/
<aeth>
(There is only one style for things like parens and spaces!)
eminhi has quit [Quit: leaving]
buoyantair has joined #lisp
buoyantair has quit [Quit: buoyantair]
Kundry_Wag has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
Fare has quit [Ping timeout: 244 seconds]
fikka has quit [Ping timeout: 260 seconds]
Fare has joined #lisp
fikka has joined #lisp
Fare has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
<phoe>
aeth: it doesn't need to be fast.
smurfrobot has quit [Remote host closed the connection]
shka1 has joined #lisp
<phoe>
A signaled condition does not have any kind of dynamic extent, right? I can store a reference to it somewhere and process in a completely different place of the program.
<beach>
Absolutely.
<phoe>
Thanks. For a moment, I wasn't sure of that.
FreeBirdLjj has joined #lisp
shka1 has quit [Ping timeout: 265 seconds]
smurfrobot has joined #lisp
Kundry_Wag has joined #lisp
<phoe>
Is there some sort of Lisp mechanism that will allow me to do run-time dispatch on conditions and handlers? HANDLER-BIND is a macro and therefore expands at macroexpansion time.
<phoe>
The simplest thing that I can think of is making a HANDLER-BIND on CONDITION and providing it with a function of my choosing. I just wonder if there's a better way.
<phoe>
Either that, or I need to take a step back and rethink what I actually want to achieve.
shka1 has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<phoe>
No, I really want a run-time way of dispatching. I don't really want to do it with macros since they don't tie well into the CLOS-heavy style I'm working with here.
<trittweiler>
phoe, yeah, you could handler-bind a generic function, for example.
<phoe>
trittweiler: I was thinking of that, actually
<phoe>
That would mean that the user could define methods on that function.
<phoe>
Hmmm. That's right! Multiple dispatch comes to the rescue here; I don't have to dispatch on a single argument.
<phoe>
trittweiler: thanks.
shka1 has quit [Ping timeout: 256 seconds]
pagnol has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
varjag has joined #lisp
smurfrobot has joined #lisp
shka1 has joined #lisp
svillemot has left #lisp [#lisp]
smurfrobot has quit [Remote host closed the connection]
nanoz has joined #lisp
inode has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
shka1 has quit [Ping timeout: 265 seconds]
inode has left #lisp [#lisp]
smurfrobot has joined #lisp
fikka has joined #lisp
kenster has quit [Ping timeout: 256 seconds]
zfree has joined #lisp
krwq has quit [Remote host closed the connection]
shka1 has joined #lisp
pagnol has quit [Ping timeout: 260 seconds]
alienated has joined #lisp
<alienated>
Hey, I thought you guys might be interested in this blog by freenode staff member Bryan 'kloeri' Ostergaard https://bryanostergaard.com/
<alienated>
or maybe this blog by freenode staff member Matthew 'mst' Trout https://MattSTrout.com/
<beach>
shka1: I should hope so. I worked hard on improving it. :)
drot has joined #lisp
<phoe>
beach: it already looks pretty much like what you presented at ELS
<beach>
phoe: Thanks.
cage_ has quit [Quit: Leaving]
cage_ has joined #lisp
ccl-logbot has quit [Quit: Client terminated by server]
ccl-logbot has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
<p_l>
beach: funny thing - some people have patched MACLISP on PDP-10 to be Y2k-safe and decided to check what Multics version did... Multics appeared to be Y2k-safe due to a coding mistake :D
<beach>
Heh! I had no idea.
<p_l>
ITS did (year mod 100), Multics version did (year - 1900)
<p_l>
the Maclisp "spec" in this area was to return 2-digit year
<beach>
I see. And no overflow on Multics?
EvW has quit [Remote host closed the connection]
EvW has joined #lisp
<phoe>
Overflow? Even if it hosted it in a (signed-byte 8), it'd overflow only after 127
<p_l>
beach: I think in both cases the datatype was big enough, and the 2-digit was used for different reasons
<phoe>
So we still have nine years left
<beach>
p_l: I see.
<p_l>
phoe: except possibly in BCD mode on some machines
<p_l>
actually, I think the CMOS clock in IBM PC used 2 BCD digits for year
<p_l>
the COBOL systems that had so much problem were storing 2 digits in *text*
EvW has quit [Ping timeout: 256 seconds]
<p_l>
apparently causes fun errors though
<p_l>
like Emacs reporting date as year 118 or so?
light2yellow has joined #lisp
<Bike>
the oldest known painting of a wheelbarrow was done in 118
<phoe>
see, and they already had emacs back then!
<pjb>
p_l: the nice thing with cobol, is that you can easily deal with the US budget, even in 1950.
<pjb>
p_l: C programmers would have more difficulties there…
<p_l>
yeah
<pjb>
and even naive lisp programmers.
<p_l>
pjb: on at least some platforms COBOL was popular, C was impossible due to non-reentrant functions in standard library
<pjb>
Yeah, reentrant functions was such a big problem once :-)
<p_l>
pjb: on CICS, all functions have to be reentrant because your code can be interrupted all the time
<p_l>
and you have shared environment with other "transactions" (CICS programs)
dddddd has quit [Remote host closed the connection]
<krwq>
ok :) I analyzed and understood your example from yesterday (https://pastebin.com/3D8uuF7Z) - got another question - is there some way to add also imperative adding of prefixes which would cooperate with the scoped ones? (usecase is (c#-using "foo"))
<Bike>
not really
<Bike>
it's all macro time
<krwq>
any easy way to hack around that? (i.e. change all usings so that they wrap everything until end of scope i.e.)
<krwq>
so that more or less (c# (c#-using ...) (c#-using ...) ...) => (c# (c#-using ... (c#-using ... ...)))
<phoe>
that's what came to my mind after krwq example
<krwq>
hmmm i'd still need some kind of state anyway
<krwq>
i thinkl
<Bike>
you'll have to do some processing to find the using nodes at compile time
<krwq>
but i'm thinking of different case - the order of definition of classes doesn't matter in c# but I'll need all the info about them when someone calls c# func)
<krwq>
unless the calling subroutine would generate itself the first time it is used
<krwq>
unless I just go with eval - it seems to simplify things in this case
<Bike>
i really, really don't think you want to use eval
<Bike>
you should process your program at compile time
<Bike>
it's not like a Using declaration is a runtime thing anyway
pagnol has joined #lisp
<krwq>
this is harder than i thought :P
Kundry_Wag has joined #lisp
newbie has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
eminhi has joined #lisp
<pjb>
krwq: this is software. It's still softer than the softer hardware!
Kundry_Wag has joined #lisp
varjag has quit [Ping timeout: 240 seconds]
<shka1>
*softest
trocado has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
EvW1 has quit [Ping timeout: 245 seconds]
sjl_ has joined #lisp
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
robotoad has joined #lisp
kajo has quit [Ping timeout: 260 seconds]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
kenster has joined #lisp
Autolycus has joined #lisp
Kundry_Wag has joined #lisp
fikka has joined #lisp
cage_ has quit [Quit: Leaving]
trocado has quit [Ping timeout: 256 seconds]
lemoinem is now known as Guest30799
Guest30799 has quit [Killed (weber.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
robotoad has quit [Quit: robotoad]
jfrancis has quit [Read error: Connection reset by peer]
vlatkoB has quit [Remote host closed the connection]
trocado has joined #lisp
Khisanth has quit [Ping timeout: 256 seconds]
vlatkoB has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
asarch has joined #lisp
trocado has quit [Ping timeout: 244 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
Khisanth has joined #lisp
robotoad has joined #lisp
trocado has joined #lisp
FreeBirdLjj has joined #lisp
littlelisper has joined #lisp
bitch has quit [Ping timeout: 260 seconds]
trocado has quit [Ping timeout: 268 seconds]
lnostdal has joined #lisp
<shka1>
beach: i have a question regarding x86 instruction set and compilers
<shka1>
namely
Kundry_Wag has joined #lisp
<shka1>
why compilers produce so many nops in assembly?!
bitch has joined #lisp
kuwze has joined #lisp
<Bike>
there are lots of reasons to generate nops. is there some particular example confusing you?
<shka1>
Bike: sadly i don't have anything concrete to show
<p_l>
shka1: many reasons why you might need nops. Some weird alignment issues, leaving space for runtime hot patching, ensuring certain ordering of operations
<shka1>
but i see this all the time in gcc and clang output
<shka1>
sbcl to lesser degree
<Bike>
i mostly remember programming for some machine with branch delays
<Bike>
annoying
<p_l>
shka1: on Alpha, huge NOP sleds were afaik the only way to get exact results in program counter in case of a trap
<p_l>
MIPS and SPARC had branch delay slots, yes
<shka1>
nopnopnopnopnopnop
<shka1>
should be a macro :P
<shka1>
anyway, this is one of the things that bothered me
<shka1>
other is strictly releated to clang vs gcc so it does not belong here
<shka1>
but i was seriously wtfacking at it :P
<shka1>
anyway, is it the same on other architectures?
<shka1>
powerpc for instance?
<shka1>
isn't that design flaw of architecture?
<p_l>
what, branch delay slot?
<p_l>
it was an artifact of simplifying hw design in case of MIPS and SPARC
<shka1>
lack of thereof
ebrasca has quit [Remote host closed the connection]
<p_l>
you don't want branch delay slots
<Bike>
lack of branch delay slots is an architecture flaw? that's a new one
Jesin has joined #lisp
<p_l>
their existence happens because of non-interlocked pipelines where another instruction in the pipe will still be executed when a branch was reached
<shka1>
Bike: i am not into the hardware
<shka1>
like at all
<shka1>
i lietrally studied medicine before programming :P
<shka1>
p_l: so it is easier for compiler to nopnop?
<shka1>
even at the cost of innability to write assembly by hand
<p_l>
shka1: no, the hardware itself *requires* a nop
<p_l>
with a branch delay slot involved, you need to either manually add a NOP, or add an operation that you *want* to happen
<shka1>
right
<shka1>
it if confusing though
smurfrobot has joined #lisp
<p_l>
for example, in SPARC: jmpl %L1; ld [%L1 - 8], %L2;
<p_l>
the instruction *after* jmpl will still be executed, despite the fact that jmpl is unconditional jump
<p_l>
IIRC
eminhi has quit [Remote host closed the connection]
gypsydave5 has quit [Remote host closed the connection]
<shka1>
that's interesting
<p_l>
there can be also "load delay slot", where an instruction immediately after a load instruction won't see the results of the load
<p_l>
MIPS I has that
<p_l>
later MIPS don't
<p_l>
so, if you don't have anything to work with, you'd put a nop
papachan has joined #lisp
<p_l>
example from Wikipedia: lw v0,4(v1) /* Load word from address v1+4 into v0 */; nop /*wasted load delay slot */; jr v0 /* jump to address in v0 */; nop /*wasted branch delay slot */
smurfrobot has quit [Ping timeout: 260 seconds]
<p_l>
(that's MIPS I, used among other things in original Play Station)
<shka1>
ok
<shka1>
is it the same in x86?
<p_l>
nop
<p_l>
;)
fikka has quit [Ping timeout: 265 seconds]
<p_l>
but there might other microptimizations involved
<shka1>
so x86 has those pesky slots that Bike seems to desipise?
<p_l>
no, but it might have other reasons to optimize like that
<Bike>
that's why i said "some machine"
<Bike>
mips, on further reflection
<p_l>
shka1: on x86 there's often NOP used to maintain code alignment (for jumps etc.)
<shka1>
and that's to keep cache happy?
<p_l>
cache, memory unit, etc. etc.
<v0|d>
\x90\x90\x90
<shka1>
hm, ok
<Fade>
there seems to be a misconfiguration on sbcl.org where the webserver will not resolve www.sbcl.org but sbcl.org works fine.
<p_l>
shka1: try compiling to assembly then compare that with assembly listing
<shka1>
p_l: sbcl will do?
<Fade>
actually, that just brings up the top page. all subpages are throwing a 503 error.
<p_l>
shka1: IIRC SBCL will also generate NOPs for alignment, as it doesn't strive for maximum density
<v0|d>
so what does FOP stands for in SBCL? i guess VOP is virtual op?
<shka1>
p_l: it will, but to somewhat lesser extent then gcc or clang
littlelisper has quit [Quit: leaving]
<shka1>
even if it does inline everything
<shka1>
i don't know if it is because of inferior code generation of sbcl, or just different set of priorities
<Bike>
nops are deliberately generated, it's not like a bad code generator is just going to have more somehow
<p_l>
clang/gcc might have more optimizations for specific cpus
<shka1>
Bike: this much is obivous :-)
<shka1>
anyway, thanks Bike and p_l for explanation
Josh_2 has joined #lisp
lavaflow has joined #lisp
smasta has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
dddddd has joined #lisp
fikka has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
ozzloy has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
karswell_ has joined #lisp
sjl_ has quit [Ping timeout: 248 seconds]
caltelt has quit [Ping timeout: 276 seconds]
shka1 has quit [Ping timeout: 276 seconds]
vultyre has joined #lisp
sjl has quit [Ping timeout: 256 seconds]
smasta has quit [Ping timeout: 248 seconds]
vultyre has quit [Client Quit]
iskander has quit [Ping timeout: 260 seconds]
jfrancis has joined #lisp
Autolycus has quit []
iskander has joined #lisp
sjl_ has joined #lisp
fikka has joined #lisp
caltelt has joined #lisp
varjag has joined #lisp
Fare has joined #lisp
xrash has quit [Ping timeout: 264 seconds]
jinkies has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
xrash has joined #lisp
EvW has joined #lisp
puchacz has joined #lisp
caltelt has quit [Ping timeout: 256 seconds]
Kundry_Wag has quit [Remote host closed the connection]
<phoe>
Tasks B and C can't start until A is finished. Task D can't start until B and C are finished. Once task D is finished, it returns a list of values - for each such value, an individual task E is started.
sjl has joined #lisp
angavrilov has quit [Remote host closed the connection]
iskander has joined #lisp
Fare has quit [Ping timeout: 244 seconds]
ebrasca has joined #lisp
Kundry_Wag has joined #lisp
test1600 has joined #lisp
test1600 has quit [Client Quit]
test1600 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 265 seconds]
pierpa has joined #lisp
papachan has quit [Quit: Leaving]
<pjb>
phoe: asdf
<pjb>
phoe: since you can define your own type of files
<pjb>
and operations with asdf, I'd say it's general-purpose enough.
skidd0 has joined #lisp
Fare has joined #lisp
<skidd0>
Has anyone here used snooze and made a route on the root path? e.g. localhost/ vs localhost/some-route
puchacz has quit [Quit: Konversation terminated!]
Fare has quit [Ping timeout: 264 seconds]
ebrasca has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
ebrasca has joined #lisp
fikka has joined #lisp
loli has quit [Quit: WeeChat 2.2]
makomo has quit [Quit: WeeChat 2.0.1]
loli has joined #lisp
potatonomicon has joined #lisp
dtornabene has joined #lisp
test1600 has quit [Ping timeout: 264 seconds]
k-hos has quit [Ping timeout: 256 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
caltelt has quit [Ping timeout: 240 seconds]
vlatkoB has quit [Remote host closed the connection]
ensyde has joined #lisp
ensyde has quit [Killed (Sigyn (Spam is off topic on freenode.))]
BitPuffin has quit [Remote host closed the connection]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
argoneus has quit [Quit: No Ping reply in 180 seconds.]
reu has quit [Ping timeout: 240 seconds]
lumm has quit [Quit: lumm]
lumm has joined #lisp
caltelt has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
argoneus has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
nickenchuggets has joined #lisp
aeth has quit [Read error: Connection reset by peer]
aeth has joined #lisp
lumm has quit [Ping timeout: 256 seconds]
kirkwood has joined #lisp
vaporatorius__ has quit [Ping timeout: 240 seconds]
DataLinkDroid has quit [Ping timeout: 240 seconds]
kajo has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
trocado has joined #lisp
pagnol has quit [Ping timeout: 256 seconds]
krwq has quit [Remote host closed the connection]
isawan has joined #lisp
isawan has quit [Client Quit]
dale_ has joined #lisp
pagnol has joined #lisp
reu has joined #lisp
trocado has quit [Ping timeout: 248 seconds]
trocado has joined #lisp
mejja has joined #lisp
mejja has quit [Client Quit]
dale_ has quit [Remote host closed the connection]
random-nick has quit [Read error: Connection reset by peer]