<stacksmith>
Personally, I prefer skiplists. It only takes a couple of years to debug a skiplist implementation.
seok has quit [Ping timeout: 260 seconds]
Oladon has joined #lisp
t58 has quit [Quit: Night]
torbo has joined #lisp
dialectic has quit [Remote host closed the connection]
dialectic has joined #lisp
hh47 has joined #lisp
<loke>
stacksmith: The freetype engine is more than just subpixel AA. It also uses Harfbuzz for layout, meaning that complex scripts are rendered correctly (such as Hindi or Arabic)
<loke>
stacksmith: Another benefit is that it uses fontconfig, which means that your system font configuration is honoured.
<stacksmith>
loke: thank you
leo_song has quit [Ping timeout: 257 seconds]
leo_song has joined #lisp
ItsMarlin has joined #lisp
anewuser has joined #lisp
Necktwi has joined #lisp
smeggie has joined #lisp
smeggie has quit [Remote host closed the connection]
femi has quit [Ping timeout: 245 seconds]
femi has joined #lisp
Finnfinn has quit [Quit: The humanity!]
vibs29 has quit [Ping timeout: 246 seconds]
Colleen has quit [Remote host closed the connection]
smeggie has joined #lisp
Colleen has joined #lisp
smeggie has quit [Remote host closed the connection]
nanoz has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
Finnfinn has joined #lisp
karayan has joined #lisp
trui has joined #lisp
hh47 has quit [Ping timeout: 264 seconds]
trui has left #lisp ["ERC (IRC client for Emacs 26.2)"]
Lord_of_Life_ has joined #lisp
hh47 has joined #lisp
Lord_of_Life has quit [Ping timeout: 258 seconds]
Lord_of_Life_ is now known as Lord_of_Life
ym555 has quit [Ping timeout: 248 seconds]
dialectic has quit [Ping timeout: 248 seconds]
ym555 has joined #lisp
hh47 has quit [Quit: hh47]
ltriant has quit [Ping timeout: 272 seconds]
karayan has quit [Ping timeout: 252 seconds]
karayan has joined #lisp
Necktwi has quit [Ping timeout: 258 seconds]
karayan has quit [Remote host closed the connection]
karayan has joined #lisp
GoldRin has quit [Ping timeout: 245 seconds]
<LdBeth>
> Are accessors not exported automatically when imported with :use?
<LdBeth>
I remember a DEF macro used in CL-STORE automatically export things
torbo has quit [Remote host closed the connection]
<stacksmith>
It figures out and rebinds all slots by default. Or you can fine-tune which slots and how to name them. Same syntax for CFFI objects.
ltriant has joined #lisp
manualcrank has quit [Quit: WeeChat 1.9.1]
ggole has joined #lisp
wigust- has joined #lisp
wigust has quit [Ping timeout: 245 seconds]
nanoz has joined #lisp
thesorton has joined #lisp
Necktwi has joined #lisp
CloseToZero has joined #lisp
smazga has joined #lisp
smazga has quit [Client Quit]
<aeth>
LdBeth: I think there can be issues with automatically exporting instead of exporting in defpackage, though
stacksmith has quit [Ping timeout: 245 seconds]
akoana has joined #lisp
akoana has quit [Quit: leaving]
<beach>
Good morning everyone!
dacoda has joined #lisp
<dialectic>
Good morning beach
<dialectic>
beach: You should know, the link to your paper on generic dispatch seems to be broken now.
<beach>
Yes, I am moving things around. Hold on...
<dialectic>
I read the cached google on Google already (I guess monopolies are good for some things...) so no hurry, just thought I'd let you know in case you didn't already.
<beach>
metamodular.com/SICL/generic-dispatch.pdf
<beach>
I have been asked to provide an index for all the SICL-related papers, and as part of that work, I am putting them in a sub-directory.
rumbler3_ has quit [Remote host closed the connection]
techquila has quit [Read error: Connection reset by peer]
mindthelion has quit [Remote host closed the connection]
techquila has joined #lisp
gareppa has joined #lisp
dacoda has quit [Ping timeout: 264 seconds]
pfdietz has quit [Ping timeout: 260 seconds]
gareppa has quit [Client Quit]
stacksmith has joined #lisp
mindthelion has joined #lisp
techquila has quit [Read error: Connection reset by peer]
libertyprime has joined #lisp
dddddd has quit [Remote host closed the connection]
zhlyg has joined #lisp
carmack has quit [Ping timeout: 258 seconds]
manualcrank has joined #lisp
sauvin_ has joined #lisp
rumbler3_ has joined #lisp
vlatkoB has joined #lisp
anewuser has quit [Quit: anewuser]
rumbler3_ has quit [Ping timeout: 244 seconds]
Lycurgus has joined #lisp
mindthelion has quit [Remote host closed the connection]
mindthelion has joined #lisp
<PuercoPop>
beach: is it intended for metamodular.com/SICL/ to return 403 forbidden?
catalinbostan has joined #lisp
Arcaelyx has quit [Ping timeout: 272 seconds]
manualcrank has quit [Quit: WeeChat 1.9.1]
CloseToZero has quit [Ping timeout: 276 seconds]
CloseToZero has joined #lisp
libertyprime has quit [Remote host closed the connection]
<beach>
No, not intended, but I haven't done the necessary to make it work yet.
orivej has joined #lisp
Lycurgus has quit [Quit: Exeunt]
Volt_ has quit [Ping timeout: 248 seconds]
frgo has quit [Read error: Connection reset by peer]
frgo_ has joined #lisp
khisanth_ has quit [Ping timeout: 248 seconds]
jprajzne has joined #lisp
JohnMS_WORK has joined #lisp
libre-man has quit [Ping timeout: 248 seconds]
beach has quit [Ping timeout: 250 seconds]
cosimone has joined #lisp
rumbler3_ has joined #lisp
khisanth_ has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
rumbler3_ has quit [Ping timeout: 244 seconds]
libre-man has joined #lisp
dacoda has joined #lisp
beach has joined #lisp
dialectic has quit [Ping timeout: 245 seconds]
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
<flip214>
Is there some HTTP/3 client library for CL available? Or a server (plugin for hunchentoot)?
<loke>
flip214: I don't think so. Would be nice to have,.
<loke>
In the meantime, use Haproxy in front of Hunchentoot
<flip214>
and as a client? use ha-proxy in reverse direction?
<flip214>
loke: thanks, having HA-Proxy in front for load-balancing and HA would make sense anyway.
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
libre-man has joined #lisp
scymtym has quit [Remote host closed the connection]
scymtym has joined #lisp
Volt_ has joined #lisp
dacoda has quit [Remote host closed the connection]
Volt_ has quit [Ping timeout: 268 seconds]
dacoda has joined #lisp
FennecCode has quit [Quit: ERC (IRC client for Emacs 26.2)]
rumbler3_ has joined #lisp
rumbler3_ has quit [Ping timeout: 245 seconds]
dacoda has quit [Remote host closed the connection]
vutral has quit [Ping timeout: 268 seconds]
dacoda has joined #lisp
stacksmith has quit [Ping timeout: 268 seconds]
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
nanoz has quit [Ping timeout: 272 seconds]
buffergn0me has quit [Remote host closed the connection]
buffergn0me has joined #lisp
dacoda has quit [Remote host closed the connection]
frgo_ has quit []
Necktwi has quit [Ping timeout: 244 seconds]
frgo has joined #lisp
hhdave has joined #lisp
dacoda has joined #lisp
<aindilis>
any Lispers here interested in AI?
<ck_>
I think that depends on what you mean by AI. These days, I feel like it is mostly "deep learning", meaning data shoveling. As far as I can tell, that's not mainly the domain of lisp
<dmiles>
we are moving some of CYC's operation to YAP .. but there is so much to do I cant give a date
* dmiles
expected to be doing this over two years ago
<dmiles>
there is just so much work
<dmiles>
be great for instance we had an expert at using JNIL
<dmiles>
or someone that can port ugly AllegroCL to SBCL code
<dmiles>
or someone to take the STELLA-to-CommonLisp and convert it to CycLisp-to-CommonLisp
<dmiles>
or someone to port nice old demos to using CYC's blackboard instead get/set-props
rumbler3_ has joined #lisp
<dmiles>
or somoene to finish my CLOS<->BlackboardedCLOS
<dmiles>
BlackboardedCLOS uses a prolog-like backend
hackware has quit [Remote host closed the connection]
quazimodo has quit [Ping timeout: 245 seconds]
<dmiles>
you get a forward chained / reactionary DROOLS-like engine
rumbler3_ has quit [Ping timeout: 244 seconds]
<dmiles>
if i was doing "deep learning" or any sort of statistical annealing... I'd use a symbolic approach ot setting up training
<dmiles>
and to even just finding the right trained whatnot and wireing it up sanely
<dmiles>
you effectively need an Expert System to content manage the zoo/gym
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
<shka__>
isn't cyc just WAM?
<shka__>
can WAM be accelerated on the GPU?
<shka__>
i think that "reinventing prolog machine" can, and it is one reason i am interested in it
<shka__>
oh, btw
<shka__>
dmiles: i am working on supporting lists in my prolog currently
<pillton>
Well I'll be. From the CLHS entry for defpackage: "If :use is not supplied, it defaults to the same implementation-dependent value as the :use argument to make-package."
<jackdaniel>
yes, it may default to NIL, or to (CL), or to (CL EXT) or whatever
libertyprime has quit [Ping timeout: 268 seconds]
<pillton>
I was about to file a bug report in CCL.
<LdBeth>
GPU bad at symbolic processing is a myth
<dmiles>
shka__: yes.. CYC produces horn clauses, then pretty close to PTTP
<_death>
does it have knowledge sources contributing in the form of CLOS slot updates, building up instances?
<dmiles>
is example of a prolgram loading
<dmiles>
_death well that is something i wnt to do .. that the programmer can choose to have the object actually get push/pulled even if it doesnt get Blackboard-ified
<Xach>
pillton: this was a topic of much anguish when sbcl omitted CL from that list
<dmiles>
for example ... (implies (and (isa ?S Socket)(socketType ?S ?T) (servercePort ?T ?P)) (rempotePort ?S P))
cosimone has joined #lisp
<dmiles>
where ?S is actually a SOCKET
<dmiles>
somehwere an assertion of (servicePort :HTTP 80)
dacoda has quit [Remote host closed the connection]
dacoda has joined #lisp
<pillton>
Xach: Oh right. Sorry to (re)open old wounds. When was that?
<dmiles>
_death: a programmer might even set up the rules to have a socket be the consequent
<dmiles>
someone might set up rules about how GUI objects have to formulically work out
dacoda has quit [Remote host closed the connection]
<dmiles>
this CLOS<->BlackboardedCLOS project should be its very own thing but i am doing it inside CYC because I need it myself
<dmiles>
also there are cases that will have to be fixed .. like someones setcdring a value .. the update might not take place correctly
<_death>
maybe an easy path would be to join a blackboard architecture with Tilton's cells
<dmiles>
Tilton's cells might even smooth that out
<dmiles>
yeah i reather not have to replicate tilton's cells api
<dmiles>
(meaning i rather just use Tilton's cells)
<dmiles>
see, this is why i wish somone besides me was handling this job :)
<dmiles>
tilton's cells for instance notices when something naughty should be happening
<dmiles>
shouldn't be*
<dmiles>
this BlackboardedCLOS idea is not new... BAYLON does it mostly
<dmiles>
BABYLON*
<dmiles>
the idea simply needs modern love with a extremely modern expressive logic
<dmiles>
with an Expert System to manage that Blackboard
<dmiles>
so one can automate things into their proper desired states
<dmiles>
these last two parts are done at least
<Xach>
pillton: ages ago
<Xach>
pillton: many traditionalists were mad because it broke code that assumed cl was in the default list
<pfdietz>
You should definitely go to the many other languages that have the features of Common Lisp. /friendlysarcasm
<shka__>
well, there are languages that have cl features
<chris4197>
I could probably implement a subset of LISP based on functionality that is already inside of our application at work.
<shka__>
some subset
<shka__>
it is just cl wraps it together in one package
<pfdietz>
For example, a great many languages have a + operator.
<Xach>
It is easy to make a simple Lisp and difficult to make something like Common Lisp
<shka__>
maybe with exception of restarts
<shka__>
that i did not notice anywhere esle
<jackdaniel>
every sufficiently complicasted program has a Common Lisp subset implemented in it (informally specified of course)
<jackdaniel>
roughly half of it
<chris4197>
That was exactly what I intended to reference.
keep_learning_M has joined #lisp
<pfdietz>
PL/I had something much like restarts, with on-condition.
<pfdietz>
Anyway, not going with CL because it lacks features would be silly, IMO. If you are going to avoid CL, libraries and integration issues would be more important. And if you are a manager, worry about hiring people who know it.
<chris4197>
I am on the OTHER end of the ladder. Apprentice.
jmercouris has left #lisp ["Exit."]
Bike has joined #lisp
<beach>
pfdietz: The Common Lisp condition system was inspred by PL/I.
<beach>
chris4197: To my knowledge, there is no language that has strictly more features than Common Lisp.
<beach>
Or, rather, that has a superset of the features of Common Lisp.
<pfdietz>
On might more fruitfully ask which features of CL are "important" in making it CL (or a Lisp).
<pfdietz>
Homoiconity
<pfdietz>
(spelling)
<pfdietz>
That's the big lispy one
<beach>
Homoiconicity.
<_death>
backwards compatibility, stability...
<pfdietz>
The particular way OO works with generic functions
<pfdietz>
One little thing I just love is that integers are much closer to mathematical integers than they are in most other languages.
wxie has joined #lisp
<pfdietz>
Another slightly meta thing: often, the mechanisms to implement builtin things are themselves made available as utilities. setf expanders, for example. This could widened, I admit.
bgardner has joined #lisp
wxie has quit [Quit: wxie]
saravia has joined #lisp
lucasb has joined #lisp
jprajzne has quit [Quit: Leaving.]
q9929t has joined #lisp
sjl_ has joined #lisp
Arcaelyx has joined #lisp
smazga has joined #lisp
q9929t has quit [Quit: q9929t]
chris4197 has quit [Remote host closed the connection]
Lycurgus has joined #lisp
techquila has quit [Ping timeout: 276 seconds]
rippa has joined #lisp
bgardner has quit [Quit: leaving]
bgardner has joined #lisp
CloseToZero has quit [Ping timeout: 245 seconds]
saravia has quit [Remote host closed the connection]
mindCrime has joined #lisp
<pfdietz>
Wanted: a variety of special variable that can be bound, but not assigned.
cosimone has quit [Ping timeout: 268 seconds]
xkapastel has joined #lisp
andrei-n has joined #lisp
saravia has joined #lisp
keep_learning_M has quit [Quit: This computer has gone to sleep]
varjag has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
edgar-rft has quit [Quit: Leaving]
igemnace has joined #lisp
maxxcan has quit [Quit: maxxcan]
varjag has quit [Read error: Connection reset by peer]
varjag has joined #lisp
varjag has quit [Read error: Connection reset by peer]
<sjl_>
you didn't say you also wanted to be able to read it ;)
<_death>
you could go with that approach, and add flet and a symbol-macro so that assignment is prevented
varjag has quit [Ping timeout: 268 seconds]
t58 has joined #lisp
<sjl_>
flet is lexical though, and he wanted a special var presumably for the dynamic scope?
<_death>
well, the variable behind the flet would be special, and you can define another namespace so that you can shadow
Lycurgus has quit [Quit: Exeunt]
<_death>
or you could just make it simpler and instead of raw special variable use, define a reader function and a macro to bind
<_death>
or even simpler: just don't assign :)
<pfdietz>
The reason I'd want this was so the compiler could strength reduce accesses to the value of the special variable (and checks for boundp).
<jackdaniel>
that would be the opposite of sbcl's defglobal
<pfdietz>
More generally: compiler optimizations based on assumptions that are usually true, but where you can detect triggers that violate them, and then recover.
<pfdietz>
In this case, compile a function under the assumption that *FOO* is never assigned to.
<pfdietz>
If some function you call violates that, return not to the call site in the function, but to a safe version where that assumption was not made.
shka_ has joined #lisp
<pfdietz>
This is inspired by code I look at that calls FORMAT (and such) a lot, and is constantly loading *STANDARD-OUTPUT*.
<pfdietz>
But it would also apply to code that (for example) inlines accessors to classes. The trigger there would be redefinition of those classes or addition of new methods.
orivej has quit [Ping timeout: 248 seconds]
<ggole>
There are JIT compilers that do that sort of thing
<ggole>
They're complicated, but the approach does work
<ggole>
You can do things like assume the value of a global is constant and back off if it is ever redefined, etc
beaky_ is now known as beaky
iamdecim has quit [Read error: Connection reset by peer]
<pjb>
pfdietz: you can do that with symbol-macros.
<pjb>
Well, unless you want the newly bound variables to be of the same kind. Then you need a binding macro.
nanoz has joined #lisp
saravia has quit [Quit: Leaving]
hhdave has quit [Quit: hhdave]
nanoz has quit [Read error: Connection reset by peer]
<Fade>
hum. swig no longer supports cffi
<shka_>
i have a stylistic question
<pjb>
Fade: It's just lack of CL knowledge on the part of swig maintainres. Some lisper should volunteer.
martylake has joined #lisp
<shka_>
when writing a function that considers two cases, one of each let's say signals condition and the second actually does something more complex
<pjb>
Fade: on the other hand, so far swig hasn't given be good results. For example, it doesn't support packed structures, so it generates wrong cffi.
<shka_>
is it better to use if for both cases or first use when to check the first case?
<pjb>
Fade: which means, that I write by cffi by hand.
<Fade>
pjb: yes, that is true.
<Fade>
I was not using it for something new, I was looking at orthecredence's libsodium bindings, which use swig.
<jackdaniel>
shka_: the latter with return-from improves readibility if your function body has nesting bigger than 2-3 levels
<shka_>
jackdaniel: right
faheem has quit [Ping timeout: 268 seconds]
<shka_>
what do you think about situation when function body is not deeply nested but slightly long, let's say 30 lines of code for the ELSE case?
<shka_>
i would think that return-from is a good idea in such case as well
m00natic has quit [Read error: Connection reset by peer]
Arcaelyx has quit [Quit: Arcaelyx]
faheem has joined #lisp
CloseToZero has joined #lisp
myrkraverk has quit [Ping timeout: 248 seconds]
myrkraverk has joined #lisp
hh47 has joined #lisp
varjag has joined #lisp
stacksmith has joined #lisp
nanoz has joined #lisp
ym555 has joined #lisp
pygmypuppy has joined #lisp
varjag has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
<jackdaniel>
I would probably rewrite it that way as well
lavaflow has joined #lisp
ggole has quit [Quit: Leaving]
FennecCode has joined #lisp
scymtym has quit [Ping timeout: 250 seconds]
<sjl_>
Depending on what you're checking, sometimes you can do it another way. E.g. instead of (defun foo (x) (when (null x) (error "Cannot foo a NIL")) (whatever x 10)) you could replace the null check with (defun foo (x) (check-type x (not null)) (whatever x 10))
<sjl_>
which gives you a continuable error for free
<sjl_>
similarly for ASSERT and its places list
Volt_ has quit [Quit: exit();]
kajo has joined #lisp
<shka_>
ah, check-type is obviously awesome, when applicable
<shka_>
jackdaniel: thanks for answers
v88m has quit [Read error: Connection reset by peer]
edgar-rft has joined #lisp
amerlyq has quit [Quit: amerlyq]
v88m has joined #lisp
faheem has quit [Remote host closed the connection]
faheem has joined #lisp
seok has joined #lisp
<seok>
Uhh
<seok>
How would I get loop to return A B C D E rather than using collect to (A B C D E)?
<Bike>
Do you mean you want it to return multiple values, and not a list?
<seok>
yes
<seok>
Well, I'm using spinneret
<Bike>
Do you know that it's always going to be five values or does the number vary?
<seok>
(defmethod render-page ((page page))
<seok>
))))))
<seok>
Trying to fix this
<Bike>
long pastes in a pastebin, please
<Bike>
...well that's just nothing
<seok>
yes this doesn't work
<Bike>
i mean there is no code. you posted an empty method
<seok>
I want to return (:p "a") (:p "b") ... rather than ((:p "a") (:p "b")) ...
<Bike>
i think you are confused about other things. (loop for header-item in (head page) do `(,header-item)) does not collect anything. In fact, it does nothing.
<seok>
I am most certainly confused
<Bike>
the other loop is just syntactically invalid.
<seok>
and don't know how to achieve what I want
<seok>
Yes you are right
<Bike>
Okay, so what do you want overall here?
<seok>
neither work, but I don't know the solution
<seok>
I want the loop to return A B C D E rather than (A B C D E)
<seok>
hm, would this work if I collect and multible-value bind
<seok>
I will try that
<Bike>
I don't think that's going to help. Why would with-html-string want multiple values?
<Bike>
if i'm reading the spineret documents correctly, you'll need to use the :attrs argument, and return a plist (still one value)./
<pfdietz>
(apply #'values (loop for ... collect ...))
CloseToZero has quit [Ping timeout: 244 seconds]
<_death>
values-list.. but in this case all you need is to (spinneret:with-html-string (:html (dolist (x '("read" "the" "docs")) (:tag :name "p" x))))
pankajgodbole has quit [Ping timeout: 272 seconds]
<pfdietz>
well, that too :)
v88m has quit [Ping timeout: 246 seconds]
<jackdaniel>
shka_: np
cosimone has joined #lisp
<seok>
hmm, value-list or values don't seem to work with the spinneret macro
<seok>
I will try the suggestion made by _death
themsay has quit [Ping timeout: 272 seconds]
jackhill_ is now known as jackhill
jmercouris has joined #lisp
femi has quit [Ping timeout: 268 seconds]
v88m has joined #lisp
<shka_>
seok: macroexpand it
<shka_>
but i bet prog1
<Bike>
it's not using multiple values at all
smazga has quit [Ping timeout: 248 seconds]
<pjb>
multiple-value-prog1
femi has joined #lisp
t58 has quit [Ping timeout: 258 seconds]
smazga has joined #lisp
t58 has joined #lisp
smazga has quit [Ping timeout: 245 seconds]
smazga has joined #lisp
xrash has quit [Ping timeout: 246 seconds]
smazga has quit [Ping timeout: 248 seconds]
themsay has joined #lisp
cosimone has quit [Quit: WeeChat 2.4]
random-nick has quit [Ping timeout: 246 seconds]
orivej has quit [Ping timeout: 246 seconds]
femi has quit [Ping timeout: 258 seconds]
smazga has joined #lisp
femi has joined #lisp
varjag has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
varjag has quit [Read error: Connection reset by peer]
nanoz has quit [Quit: Leaving]
martylake has quit [Read error: Connection reset by peer]
martylake has joined #lisp
shka_ has quit [Ping timeout: 248 seconds]
andrei-n has quit [Read error: Connection reset by peer]
Ricchi has joined #lisp
andrei-n has joined #lisp
Lycurgus has joined #lisp
borodust has quit [*.net *.split]
michalisko has quit [*.net *.split]
michalisko has joined #lisp
libre-man has quit [Quit: WeeChat 2.1]
martylake has quit [Remote host closed the connection]
hh47 has quit [Quit: hh47]
<boeg>
I was looking at rackets documentation and it seems to have a very impressive gui story. Whats the gui story for common lisp?
<jmercouris>
super impressive if you will pay for an implementation
jmercouris has quit [Remote host closed the connection]
vlatkoB_ has quit [Remote host closed the connection]
bexx has joined #lisp
<bexx>
how can I build sbcl without a lisp?
<bexx>
i'm on alpine linux and seems like they don't have a package for sbcl
<aeth>
bexx: Get ECL or CLISP and use that to bootstrap, or use a generic Linux SBCL binary... iirc
<Bike>
yeah, to build sbcl you need a lisp. sbcl has binaries to download, i think
<Bike>
so you can download a binary sbcl and use it to build sbcl from source
<bexx>
thanks
Inline has quit [Quit: Leaving]
orivej has joined #lisp
random-nick has joined #lisp
<Lycurgus>
on linux, the distros current sbcl is easiest
<aeth>
Lycurgus: The question was for a distro without one, though. Also relevant for e.g. people making the binary for the distro
<Lycurgus>
yeah just looking at it, looks like a nightmare of didn have
<Lycurgus>
didn have nuthin
<Lycurgus>
but hella secure and simple
<aeth>
Hmm... Can Lisp-as-a-.SO greatly reduce memory consumption when more than one Lisp image is running at the same time from that Lisp? Does this exist in practice in e.g. ECL?
ryoshu has joined #lisp
cosimone has joined #lisp
<Lycurgus>
not significantly I would think
<aeth>
jackdaniel: do you have any numbers here?
<Lycurgus>
well significantly but not greatly is what I meant, which is what you said
mepian has joined #lisp
<stacksmith>
aeth: I doubt it makes much of a difference, since most of the memory is used as a GC'd object space, not code.. I can't imagine multiple OS-level instances sharing the same object space...
<aeth>
I was just thinking that e.g. if you had stumpwm, a CL-based Emacs, and an inferior-lisp (the third is not necessary, unlike in GNU Emacs, but it would still be nice not to crash the editor if you had a serious bug) then that's 3 CLs running at once.
Jesin has quit [Quit: Leaving]
<Xach>
but we have so much memory now, you could probably run 7 to 9 cls
<aeth>
Xach: S
<aeth>
So we're fine until someone has a CL web browser and a CL terminal and a CL POSIX shell and a CL...
xrash has joined #lisp
<aeth>
Actually, though, I think 2-3 is all you need to run simultaneously. CL desktop applications could probably use a common CL daemon sort of like Emacs Server.
<aeth>
(the 2 or 3 is because I'm not sure a window manager would like doing that)
amerlyq has joined #lisp
Jesin has joined #lisp
Krystof has joined #lisp
smazga has quit [Quit: leaving]
<PuercoPop>
aeth: but then you loose the advantage of being able to communicate by passing CL values around and are back to using serializations like in unix-land
cosimone has quit [Quit: WeeChat 2.4]
<aeth>
PuercoPop: what do you mean?
<aeth>
PuercoPop: You do want at least 2 CLs running no matter what if you're doing development since you can easily crash a CL, e.g. through CFFI stuff. inferior-lisp is a feature, even with a CLemacs.
<PuercoPop>
aeth: if you have everything in the same image calling the 'editor' would be akin to a function call
<jackdaniel>
shared objects mostly reduce module duplication (and eventual inconsistency), I don't think they do much to memory consumption
<PuercoPop>
so for example, the way slime/swank communicate is by passing around s-exps as strings, not as the values in the running image
<jackdaniel>
most of the consumed memory comes from what you have consed
<aeth>
PuercoPop: Right, but if developing something in the editor brings down everything from the window manager on up, that's basically the Windows 95/98 experience all over again.
<jackdaniel>
a way to go is to have one lisp process with different applications
<jackdaniel>
then they are able to communicate without marshalling/demarshalling data
bexx has left #lisp ["WeeChat 2.5"]
<jackdaniel>
common lisp has elaborate condition handling facilities, so unless there are hidden issues in the implementation it should be possible to wrap each application in handler-case and *not* bring everything down
borodust has joined #lisp
<aeth>
jackdaniel: It usually takes the CFFI to break SBCL. That or (safety 0)
<jackdaniel>
it is like saying that editor may crash kernel and everything goes down. sure, if you manage to segfault linux then you bring down x11
<seok>
hello,
<seok>
(defmacro render-page (page)
<seok>
collect body-item)))))))
<seok>
Anything wrong with this macro?
<pfdietz>
Yes
<seok>
What is wrong?
<pfdietz>
collect makes no sense there
<seok>
What do you mean
<pfdietz>
collect is treated as a variable there, which it tries to evaluate.
<Bike>
it's syntactically invalid there. it's not real code.
<pfdietz>
it's not bound.
<Bike>
is your paste messed up? maybe do pastebin again?
<pfdietz>
And then the same with body-item.
<PuercoPop>
aeth: I do understand the importance of what you are saying and I agree that it is probably the way to go. I just wanted to note the isolation is not without a cost. Like f/e writing a dmenu clone in Lisp. I would prefer if it could call it from inside StumpWM w/o shelling out
andrei-n has quit [Remote host closed the connection]
<seok>
Hm, you're right
<pfdietz>
To debug the macro, try using macroexpand on a form that uses the macro: (macroexpand '(when (foo) (bar))) ==> the code with the WHEN macro expanded
scymtym has joined #lisp
techquila has joined #lisp
Marlin1113 has joined #lisp
bugrum has quit [Ping timeout: 245 seconds]
<seok>
hmm
libertyprime has joined #lisp
<seok>
how come (access x :body) is ((:P "bye") (:P "hi"))
<seok>
but
<seok>
(macroexpand '(render-page x)) is
<seok>
(FORMAT NIL
<seok>
(defmacro render-page (page)
<seok>
what have I done wrong?
<Bike>
look, however you're pasting code into this channel, it's not working
<Bike>
you need to use pastebin or something
<seok>
small codes are not working too?
<seok>
ok
<Bike>
i see this: "(FORMAT NIL (defmacro render-page (page)"
<dmiles>
shka__: oh i see, i thought you were telling me about a list datatype yesterday.. you meant the trail
ym555 has quit [Read error: Connection reset by peer]
<dmiles>
the undo for sure is much saner stored in lists than in an array
zhlyg has quit [Ping timeout: 245 seconds]
xrash has quit [Ping timeout: 258 seconds]
<dmiles>
using arrays in the case of a thing that resizes millions of times per operation is funny premature optimization i never understood :P
ym555 has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
Bike has quit [Quit: Bike]
xrash has joined #lisp
<dmiles>
the reason for use of arrays in some prolog impls is that the bindings can be undone by just moving a fill pointer
<dmiles>
but in the case of undo closures that even have to be ran tun undo/unwind the arrays dont make as much sense
<dmiles>
but in the case of undo closures that even have to be ran to enact a undo/unwind the arrays dont make sense
mindCrime has quit [Ping timeout: 244 seconds]
<dmiles>
in 1998 i merged a the OCKB Lisp impl (written in Java) and Tarau's KeneralProlog (and written in Java) .. And found this Zen in making the lisp env and prolog trail work together
<dmiles>
but it sucks that in real life (not doing this from the backend language) it is not beautifull as it should be
<dmiles>
ECL when implementing WAM also reached this Zen
<dmiles>
(but it did so from the backend was why/how)
<dmiles>
if i had help porting CYC back into Lisp (instead of translated Lisp) I'd spend the time wuth jackdaniel's trying to revive ECL's WAM engine
<seok>
Why can't I use slot accessors in my macro?
<seok>
There is no applicable method for the generic function
<seok>
How else can I access slot values in macros?
<pjb>
seok: you could, if you passed an object to render-page, instead of a symbol or a sexp.
<pjb>
seok: just write a function!
<dmiles>
seok: if the maro was expanded expanded (in cource) therre is no error?
<seok>
x is an object
<seok>
hm
<dmiles>
seok: if the macro was expanded (in source) therre is no error?
<pjb>
Yes, but no.
<pjb>
X is a symbol (which indeed is a lisp object, but X is not a CLOS instance).
<seok>
So when I use access library, there is no error but it does not work as expected
<seok>
When I try slot-value above error shows up
<seok>
Oh, then how can I pass the object represented by x?
<seok>
(defmacro render-page (page)
<pjb>
With difficulties. Do you have a time machine?
<pjb>
Use a function.
<seok>
Like, write the whole thing as a function?
<seok>
I've been trying for a while,
<pjb>
Yes.
<seok>
It causes problem with with-html-string macro tho
<seok>
but I assumed it could be done without it using macros
<pjb>
So do you understand your problem with the macro?
<pjb>
Macros are functions that work on programs, not on data. They will take program chunks, such as variable names, or expressions, and generate a new expression from them. And they work during compilation TIME. Data is known at run TIME, and you will have functions working on the data. But this run TIME can occur THOUSANDS of YEARS after the compilation!
<pjb>
So if you want to write a macro that process the data, you need a time machine.
<pjb>
Of course, there may be some confusion here, since data is program and program is data. Of course, the variable name, or the expression are lisp data (symbols, lists, etc). And you can also consider any data as program that a macro can interpret and use to generate the lisp expression. But the problem is that those data will have to be known at compilation TIME (remember THOUSANDS of YEARS before run-TIME).
<pjb>
So it can work only on universal constants data, or old, historic data. Not on new data processed at run-TIME.
TheOldPhart has joined #lisp
amerlyq has quit [Quit: amerlyq]
nowhereman has joined #lisp
Ricchi has quit [Ping timeout: 252 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
TheOldPhart has quit [Ping timeout: 260 seconds]
Bike has joined #lisp
xrash has quit [Read error: Connection reset by peer]
<seok>
Then wouldn't there be a way to evaluate the value first and place it in the macro?
random-nick has quit [Ping timeout: 248 seconds]
dialectic has joined #lisp
teej has quit [Quit: Connection closed for inactivity]
t58 has quit [Quit: *beep*]
sindan has quit [Ping timeout: 258 seconds]
buffergn0me has quit [Ping timeout: 264 seconds]
<pjb>
seok: you seem to have some problems with time.
<pjb>
seok: what happens after cannot have happened before.
<pjb>
seok: there's what we call the arrow of time, and it cannot loop back (without a time machine).
<pjb>
seok: evaluation = run-time happens AFTER.
<pjb>
seok: so it cannot be first, and therefore we cannot use the value resuting from this evaluation BEFORE, in the macro.
<pjb>
seok: for this, you would need a time machine!
<pjb>
seok: now, there are different theories of time. In some case, time machines don't project you just "back in time", but actually will fork a new universe from that time in the past. In a way, it makes a copy of the old universe for you to use now. It's not really time travelling, it's universe copying and forwarding.
<pjb>
Notice that (double (random 10)) #| --> (8 4) |# we cannot send back in time the result of the evaluation of (random 10) (which was 8 the first time). Here the macro expands to (list (random 10) (random 10)) and this is evaluated at run-time.
<pjb>
so instead we compute (random 10) in compute-value-and-double-it, and use it to build an expression such as (double 3) and call eval to copy the universe and fork out to a new evaluation!
<pjb>
In this simple case, we could write the macro as (defmacro double (x) (let ((vx (gensym))) `(let ((,vx ,x)) (list ,vx ,vx)))) and use (double (random 10)) but x would still have been bound to (random 10), not to 3 or 5, and when you write such macro, it's a strong hint that you should have written a function (as I already told you a lot!). (defun double (x) (list x x)).
<pjb>
Now, if you have a (real) time machine, just tell us, and we will interface it with a CL system so you can do what you want!