dddddd has quit [Remote host closed the connection]
<pierpa>
check out Calendrical Calculations, and use whatever they use (and their software is written in CL, and is available from the publisher website, although with a weird license)
<didi>
pierpa: Thank you.
<pierpa>
;)
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
markoong has quit [Ping timeout: 260 seconds]
k4rtik has joined #lisp
k4rtik has quit [Changing host]
k4rtik has joined #lisp
elfmacs has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
k4rtik has quit [Ping timeout: 260 seconds]
nullniverse has quit [Quit: Undertaking stack overflow prevention]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
Younder has quit [Ping timeout: 240 seconds]
yxcv has joined #lisp
scymtym has quit [Remote host closed the connection]
scymtym has joined #lisp
EvW1 has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
skidd0 has joined #lisp
<skidd0>
can you register an :after to a make-instance, and, is this a bad idea?
<Xach>
skidd0: you can, and it's not automatically a bad idea
<Xach>
skidd0: what were you thinking of doing with it?
graphene has quit [Remote host closed the connection]
<White_Flame>
I've seen it done relatively often
<sjl_>
defining an after method on initialize-instance is a pretty common idiom. I don't know that I've seen it done on make-instance very much.
<skidd0>
when I make an instance of a list, i want to auto add that list to a .. list of lists..
graphene has joined #lisp
<Xach>
skidd0: that could work, if by "list" you mean some list-like CLOS object
<Xach>
standard-class instance
<skidd0>
I have an interactive function that prompts the user for info (like name, tags, about) and then pushes the new list onto a special var *task-lists*
<skidd0>
why a CLOS list-like object rather than a stock list?
<Xach>
lists are not made with make-instance.
<skidd0>
oh, sorry
<skidd0>
i undertand
<skidd0>
yes,my lists are a class. TASK_LIST
<skidd0>
TASK-LIST*
<skidd0>
I thought you were talking about the lisp list I pushed them too
<Xach>
skidd0: i think i would not do it that way, because it can be nice to make objects without causing a side-effect like that, e.g. when you're just testing things out.
<Bike>
yeah, i'd just have a separate, like, make-and-also-register-object function.
<White_Flame>
something like (make-registered-task ...)
<White_Flame>
yeah
<skidd0>
that makes sense
<skidd0>
but it's worth noting that I always want the task-lists to be added to the list of task-lists
<Bike>
always in normal use, i assume
<White_Flame>
then your own (make-task ...) which uses (make-raw-task ...)
Kundry_Wag has joined #lisp
<White_Flame>
where the former also registers it
<Bike>
for testing i've pretty much never regretted being able to make a thing without side effects
<skidd0>
fair point
<skidd0>
White_Flame: so make-raw-task doesn't register, but make-task does
<skidd0>
?
Josh_2 has quit [Remote host closed the connection]
graphene has quit [Remote host closed the connection]
yxcv has left #lisp ["ERC (IRC client for Emacs 26.1)"]
graphene has joined #lisp
<White_Flame>
you could also maybe do (defun make-task (... &key dont-register) ...)
<skidd0>
with make-task, i'm thinking that's basically taking the init args and then using them in a make-instance
<skidd0>
but that seems redundant
<skidd0>
and i don't know how i'd set it so I could skip an arg
<White_Flame>
there's many ways to incredibly over-engineer it in an explosion of OO
<skidd0>
which is what i'm trying to avoid
<skidd0>
with my first lisp project
<White_Flame>
&rest and APPLY are used to pass through args
subroot has joined #lisp
<skidd0>
i'm going to google that
<Bike>
you might not need the raw task part.
<Zhivago>
Isn't this just a matter of creating a constructor function which also adds the thing it constructs to a list somewhere?
<skidd0>
yes
<Zhivago>
(make-and-register-foo) or some-such?
<Zhivago>
Or (register-foo (make-foo)).
<Zhivago>
So, where's the OOP bit?
skapata has quit [Quit: Ping timeout: 65,535 years]
warweasle_ has joined #lisp
warweasle has quit [Read error: Connection reset by peer]
<skidd0>
well, i'm using CLOS for the tasks and task-lists
<skidd0>
and White_Flame was warning about over-engineering that
<White_Flame>
not a warning about your particular approach, per se
<skidd0>
i took it as general widom
<White_Flame>
but once you have automatic behavior, then you want to make it optional, you need to have side-band ways of passing in options to that automatic behavior
<skidd0>
and then, i'll have a really complex way to make lists, and have spent a while learning how to do that, and still not have tasks
terpri has joined #lisp
<Zhivago>
Why are you thinking about 'making lists'?
<White_Flame>
btw, (defun maker (&rest params) (let ((obj (apply #'raw-maker params))) ...)) is how you pass through parameters
<Zhivago>
Probably your problem involves 'making a data structure for some particular purpose', and that just happens to involve lists today.
<Zhivago>
So, why not abstract it with a make-thingy function?
karlosz has joined #lisp
robotoad has quit [Quit: robotoad]
froggey has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 240 seconds]
quazimodo has quit [Ping timeout: 260 seconds]
quazimodo has joined #lisp
<skidd0>
Zhivago: I see what you're getting at
<skidd0>
i think
<skidd0>
anyway, thanks all
skidd0 has quit [Quit: 0/]
robotoad has joined #lisp
rumbler31 has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
brettgilio has quit [Remote host closed the connection]
brettgilio has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
saki has quit [Quit: saki]
mlf|2 has joined #lisp
AetherWind has joined #lisp
mflem has quit [Ping timeout: 245 seconds]
loli has quit [Ping timeout: 268 seconds]
mindCrime has joined #lisp
mooshmoosh has quit [Ping timeout: 260 seconds]
mindCrime_ has quit [Ping timeout: 276 seconds]
mooshmoosh has joined #lisp
cnx has joined #lisp
<cnx>
hi there, somehow i can no longer load swank server due to `Package ASDF does not exist.'
k4rtik has joined #lisp
pierpa has quit [Quit: Page closed]
<akkad>
cnx sbcl?
nanoz has joined #lisp
AetherWind_GJ has joined #lisp
AetherWind has quit [Disconnected by services]
AetherWind_GJ is now known as AetherWind
potatonomicon has joined #lisp
<cnx>
yes, sbcl, and it worked normally a few days before
k-hos has quit [Ping timeout: 240 seconds]
<akkad>
cnx: did you load it through quicklisp?
<akkad>
i.e. (ql:quickload :swank)
cymew has joined #lisp
brettgilio has quit [Remote host closed the connection]
potatonomicon has quit [Read error: Connection reset by peer]
cymew has quit [Ping timeout: 240 seconds]
phoe has joined #lisp
kark has quit [Ping timeout: 276 seconds]
Pixel_Outlaw has joined #lisp
jibanes has quit [Ping timeout: 240 seconds]
k-hos has joined #lisp
<cnx>
no i didn't, i started slime in emacs
<cnx>
i also tried loading it directly with no luck
<White_Flame>
I don't think SLIME launches it with --script
<White_Flame>
that prevents your .sbclrc from starting
PuercoPope has joined #lisp
<White_Flame>
however, you shouldn't need a .sbclrc for swank to work
PuercoPop has quit [Quit: ZNC 1.6.3 - http://znc.in]
PuercoPope is now known as PuercoPop
<White_Flame>
it's always best to install SBCL from source, instead of from your package manager, due to weird issues like this
<White_Flame>
and install SLIME from quicklisp. there's a helper in there
<White_Flame>
then everything will have a nice standard base to go from
cymew has quit [Ping timeout: 265 seconds]
subroot has quit [Read error: Connection reset by peer]
<beach>
Good morning everyone!
cymew has joined #lisp
<akkad>
morning beach
<cnx>
good noon man
cymew has quit [Ping timeout: 265 seconds]
<cnx>
White_Flame: but it has worked just a few days ago
loli has joined #lisp
<cnx>
and I'm tired of letting my 14yo laptop compiling stuff
<White_Flame>
if you start SBCL from the commandline and type (require :asdf), what do you get?
cymew has joined #lisp
<White_Flame>
and type asdf:*central-registry* afterwards
phoe has quit [Ping timeout: 268 seconds]
<White_Flame>
I odn't know if slime REQUIREs it in, or if it has its own copy, though
phoe has joined #lisp
<cnx>
asdf loaded fine somehow
<cnx>
asdf:*central-registry* is nil
cymew has quit [Ping timeout: 240 seconds]
<White_Flame>
well, try reinstalling SLIME. something might have gotten deleted
<White_Flame>
it shouldn't just "break", so I would suspect something external in the environment
cymew has joined #lisp
mange has joined #lisp
<makomo>
morning
<cnx>
noon
<phoe>
mornin
cymew has quit [Ping timeout: 260 seconds]
cymew has joined #lisp
saki has joined #lisp
<cnx>
White_Flame: any idea how package path in cl works, i'm still a newbie
cymew has quit [Ping timeout: 240 seconds]
cymew has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<makomo>
phoe: did you take a look at the macros i wrote (regarding the FBIND thing we discussed) :D?
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
cymew has quit [Ping timeout: 268 seconds]
cymew has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
nowhere_man has joined #lisp
Pixel_Outlaw has quit [Quit: Leaving]
cymew has quit [Ping timeout: 268 seconds]
<White_Flame>
cnx: REQUIRE is a deprecated, implementation-specific thing that's usually only used for implementation built-ins
<White_Flame>
QL & ASDF have their own paths that they manage, to pull in "systems"
<White_Flame>
("package" is what namespaces symbols in Lisp)
<White_Flame>
asdf:*central-registry* is the list of directories it looks for .asd files to load
cymew has joined #lisp
<White_Flame>
quicklisp also has a couple for the quicklisp distributions as well as local-projects
<White_Flame>
but if asdf itself isn't loading, it's a pretty eary failure
<White_Flame>
*early
brettgilio has joined #lisp
cymew has quit [Ping timeout: 240 seconds]
cymew has joined #lisp
isospin has joined #lisp
cymew has quit [Ping timeout: 240 seconds]
<cnx>
so (require :asdf) return something doesn't mean that it is successfully loaded
Bike has quit [Quit: Lost terminal]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
<White_Flame>
cnx: because you asked for asdf:*central-registry*, that means that that symbol was defined in the package, aka it loaded
shka_ has joined #lisp
<White_Flame>
NIL means the value was defined. It would have blown up with an error if neither that package nor symbol existed
pjb has quit [Remote host closed the connection]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
pjb has joined #lisp
<cnx>
I'm feeling kinda sick now, I guess I'll try to get more sleep and debug this later, thanks White_Flame
cnx has left #lisp ["ERC (IRC client for Emacs 25.2.2)"]
lavaflow_ has quit [Read error: Connection reset by peer]
lavaflow_ has joined #lisp
Guest49727 has left #lisp [#lisp]
buffergn0me has joined #lisp
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
pierpal has quit [Quit: Poof]
orivej has joined #lisp
pierpal has joined #lisp
mflem has joined #lisp
brettg_ has joined #lisp
pjb has quit [Remote host closed the connection]
brettg_ has quit [Remote host closed the connection]
brettg_ has joined #lisp
brettg_ has quit [Remote host closed the connection]
mlf|2 has quit [Ping timeout: 245 seconds]
pjb has joined #lisp
brettgilio has quit [Ping timeout: 240 seconds]
brettgilio has joined #lisp
pjb has quit [Remote host closed the connection]
pjb has joined #lisp
k4rtik has quit [Ping timeout: 244 seconds]
brendyn has joined #lisp
robotoad has quit [Quit: robotoad]
pjb has quit [Read error: Connection reset by peer]
surya has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
sauvin has joined #lisp
surya_ has joined #lisp
surya has quit [Ping timeout: 240 seconds]
nanozz has joined #lisp
<makomo>
how do memos work again
<makomo>
minion: help
<minion>
There are multiple help modules. Try ``/msg minion help kind'', where kind is one of: "lookups", "helping others", "adding terms", "aliasing terms", "forgetting", "memos", "avoiding memos", "nicknames", "goodies", "eliza", "advice", "apropos", "acronyms".
nanoz has quit [Ping timeout: 260 seconds]
<makomo>
minion: memo for Bike: the "const-size" version of once-only implemented using the list version: https://plaster.tymoon.eu/view/850#850. no EVAL! i guess the most general way to go about it then is to always write a version which works with an arbitrary number of forms and then derive the const-size version from it.
<minion>
Remembered. I'll tell Bike when he/she/it next speaks.
<makomo>
minion: memo for pjb: the "const-size" version of once-only implemented using the list version: https://plaster.tymoon.eu/view/850#850. no EVAL! i guess the most general way to go about it then is to always write a version which works with an arbitrary number of forms and then derive the const-size version from it.
<minion>
Remembered. I'll tell pjb when he/she/it next speaks.
auricle has quit [Ping timeout: 252 seconds]
kerframil has quit [Quit: Leaving]
caltelt_ has quit [Ping timeout: 240 seconds]
quazimodo has quit [Ping timeout: 240 seconds]
Inline has quit [Quit: Leaving]
Younder has joined #lisp
quazimodo has joined #lisp
vlatkoB has joined #lisp
surya_ has quit [Ping timeout: 260 seconds]
rippa has joined #lisp
surya_ has joined #lisp
raynold has quit []
mooshmoosh has quit [Read error: Connection reset by peer]
mooshmoosh has joined #lisp
elfmacs has quit [Quit: WeeChat 2.1]
nanozz has quit [Ping timeout: 260 seconds]
chiyosaki has joined #lisp
acolarh has quit [Ping timeout: 240 seconds]
saki has quit [Ping timeout: 240 seconds]
logicmoo has quit [Read error: Connection reset by peer]
flamebeard has joined #lisp
dmiles has joined #lisp
mooshmoosh has quit [Ping timeout: 260 seconds]
mooshmoosh has joined #lisp
shrdlu68 has joined #lisp
acolarh has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
d4ryus1 has joined #lisp
nowhere_man has joined #lisp
d4ryus has quit [Ping timeout: 276 seconds]
cymew has joined #lisp
scottj has quit [Quit: leaving]
mathrick has quit [Ping timeout: 260 seconds]
zooey has quit [Remote host closed the connection]
mathrick has joined #lisp
zooey has joined #lisp
Arcaelyx has joined #lisp
angavrilov has joined #lisp
gector has joined #lisp
buffergn0me has quit [Ping timeout: 260 seconds]
xificurC has joined #lisp
Smokitch has joined #lisp
captgector has joined #lisp
shka_ has quit [Ping timeout: 244 seconds]
gector has quit [Ping timeout: 268 seconds]
gector has joined #lisp
captgector has quit [Ping timeout: 240 seconds]
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
lavaflow_ has quit [Read error: Connection reset by peer]
lavaflow_ has joined #lisp
mange has quit [Remote host closed the connection]
pierpal has quit [Read error: Connection reset by peer]
test1600 has joined #lisp
shifty has joined #lisp
pierpal has joined #lisp
Kaisyu7 has joined #lisp
brettgilio has quit [Quit: Leaving]
pjb has joined #lisp
light2yellow has joined #lisp
<shrdlu68>
"The quest for the ideal programming language and the ideal man-machine interface that would make the software crisis melt like snow in the sun had —and still has!— all the characteristics of the search for the Elixir and the Stone." -- Encountered in a Dijkstra essay
<pjb>
Dijkstra didn't understand lisp.
<minion>
pjb, memo from makomo: the "const-size" version of once-only implemented using the list version: https://plaster.tymoon.eu/view/850#850. no EVAL! i guess the most general way to go about it then is to always write a version which works with an arbitrary number of forms and then derive the const-size version from it.
<pjb>
The quest for the ideal programming language is archieved by lisp, for 1- ideal pl is not an absolute, but relative, 2- lisp let you mutate the language so you may make it the ideal pl for your current program.
<pjb>
makomo: don't eval a macro! macroexpand it!
<beach>
Theoretical computer scientists having opinions about programming is kind of like medical doctors having opinions on just about anything technical. Their colleagues deify them, but they don't necessarily know much about the topic.
<makomo>
pjb: i think you're missing the point. the context is the same as it was yesterday
<makomo>
i don't want ONCE-ONLY to appear in the expansion. the whole point of ONCE-ONLY is to be used within the macro itself
<makomo>
it should never ever be seen in the expansion
<pjb>
Then don't use a macro! Write once-only* function!
<makomo>
that was the point of the whole conversation yesterday!
pierpal has quit [Quit: Poof]
<makomo>
i *don't want to do that*
pierpal has joined #lisp
<makomo>
because i want to reuse ONCE-ONLY
<makomo>
otherwise i have to reimplement ONCE-ONLY myself
<makomo>
it would be great if the author of ONCE-ONLY did it while he was at it, but he did not
<makomo>
but yes, ideally i guess you would do either that or you would implement the arbitrary list version first, and then derive the constant-size version from it (which i did at the bottom from Bike's solution (which is a reimplemnetation of ONCE-ONLY as well btw))
<makomo>
the point was to constrain yourself to use just ONCE-ONLY, without imitating its behavior
<makomo>
as it turns out, the only way to do that is EVAL/MACROEXPAND
<makomo>
going afk, i'll check the logs later
* makomo
afk
surya_ has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 268 seconds]
parjanya has joined #lisp
<pjb>
You see, this is why I hate alexandria: it makes people freeze its API in their mind. This is open source! Just copy-and-paste the once-only macro and make it into a function!
parjanya has quit [Remote host closed the connection]
<pjb>
Write your one library!
mooshmoosh has quit [Ping timeout: 240 seconds]
mooshmoosh has joined #lisp
_cosmonaut_ has joined #lisp
<_death>
s/alexandria/CL/
<pjb>
Indeed, this is one old criticism of CL…
makomo has quit [Ping timeout: 256 seconds]
<pjb>
But I have the same answer; write your own library! (cf. eg. cl-stepper, ibcl, etc).
<pjb>
Even CLIM does it!
<pjb>
When you write a clim application, you don't use CL.
mindCrime_ has joined #lisp
parjanya has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
<White_Flame>
the end-all, be-all of programming will be true natural language understanding
<White_Flame>
until then, Lisp
<parjanya>
what do you mean? : o )
<White_Flame>
referencing discussion about the "ideal programming language" in the backlog
<_death>
pjb: that coin has two sides.. and you can learn to unfreeze so there's no need to "hate"
<White_Flame>
shrdlu68: I don't mean "natural-language-ish programming languages" I mean "true natural language understanding"
<pjb>
of course. You can always do PR.
milanj has joined #lisp
<pjb>
parjanya: you can be a high-level, natural programming language programmer, by becoming a CTO, and telling your teams the specs of your program. Magically, the program gets developped, by a bunch of HI, AI, and DC.
<parjanya>
White_Flame: isn’t there too much ambiguity in natural languages? even among humans we get problems of interpretation
<White_Flame>
right, it's an AI problem
<shrdlu68>
White_Flame: That's an AI-complete problem, we probably won't be programming by then.
<antoszka>
No, it's unsolvable problem.
<antoszka>
Unless you want your systems to have unpredictable behaviour :)
<pjb>
shrdlu68: consider the system as a whole. With GAI, just use HI+AI.
<dim>
pjb: that's called a product manager these days, I've heard
<pjb>
s/With/Without/
<shrdlu68>
antoszka: No it's not. Natural languages, while incredibly complex, still have grammar. It's just difficult, not impossible.
<pjb>
dim: yes, when you have several programs to do at the same time, you delegate to PMs.
<White_Flame>
shrdlu68: and it's not just grammar, it's understanding of context & implications
<White_Flame>
that's where the real expressive power of NL lies
<shrdlu68>
White_Flame: Still not in the realm of impossibility.
<antoszka>
…and the ambiguity.
<White_Flame>
I know
<White_Flame>
(*2)
<parjanya>
"I saw John and William today. He said he hates his brother."
<White_Flame>
I never said true NLU is impossible, just that it'd be the ultimate programming environment, finally including DWIM functionality :)
<shrdlu68>
Terry Winpgrad's SHRDLU showed there is a way, it's just difficult and no one currently knows of a way to scale SHRDLU.
<parjanya>
just to stay with cataphora
<pjb>
parjanya: the thing is that you can also write misleading code, code that is interpreted differently by the human reader and by the compiler,a nd even code that is interpreted differently by different compilers!
<pjb>
parjanya: this is why we aim at conforming code, and clear code.
pagnol has joined #lisp
<pjb>
the same can be done in NL.
<shrdlu68>
But then again, the world's best minds have supposedly been working on this problem for decades and made virtually no progress, so who am I to say?
<White_Flame>
shrdlu68: yes, that's the sad part
<parjanya>
well, as we have it... we have a variable in us managing to know what we want and knowing how to express it. the computer’s behaviour just follows the code. we can see where the problem is, with some luck. if computers accept natural language, they will have more than one way of interpreting what we say, so we won’t be sure even of its behaviour. I’m not saying it’s impossible, it’s
<parjanya>
just that as a linguist I can’t see how.
<_death>
remember that DWIM stands for Do What Interlisp Means ;)
<shrdlu68>
parjanya: I have the audacity to think I'll do it some day.
<White_Flame>
_death: heh
<parjanya>
shrdlu68: I hope you will manage :) I wonder what would it mean practically, hmm
<White_Flame>
parjanya: it all comes down to the ability to be able to form, update, and reuse general concepts, not having dictionaries of symbol definitions & strict grammar rules
<White_Flame>
as well as being able to ask clarifying questions, but that's been obvious for a long long time
<parjanya>
ah, that remidns me of some Lisp system that manipulated objects in 3d based on commands "put this on top of that" etc
<White_Flame>
that's shrdlue
<White_Flame>
-e
<White_Flame>
but it was still 100% strict human-written rule following
<White_Flame>
just with a nicely designed ruleset
<White_Flame>
but a fixed ruleset, and fixed grammar rules
<TMA>
and fixed and small domain
<White_Flame>
with compounded complexity in its design that it became pretty un-editable
scymtym has joined #lisp
<White_Flame>
(these all might be fixable problems)
<parjanya>
well, I have no idea... but the concept is very very interesting
graphene has quit [Remote host closed the connection]
milanj_ has joined #lisp
graphene has joined #lisp
milanj has quit [Ping timeout: 240 seconds]
dddddd has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
littlelisper has joined #lisp
orivej has joined #lisp
<littlelisper>
https://pastebin.com/kdS0DjJj warning while (requre :mcclim). mcclim works fine, but is there any way to clean the warning
housel has quit [Remote host closed the connection]
housel has joined #lisp
pagnol has quit [Ping timeout: 276 seconds]
<beach>
littlelisper: I suggest you ask loke in #clim.
<beach>
... or jackdaniel.
<littlelisper>
beach: ok i ll look in #clim
lumm has joined #lisp
JuanDaugherty has joined #lisp
m00natic has joined #lisp
littlelisper has left #lisp [#lisp]
AetherWind has quit [Quit: Leaving]
isospin` has joined #lisp
isospin has quit [Ping timeout: 240 seconds]
Kaisyu has quit [Quit: Connection closed for inactivity]
_cosmonaut_ has quit [Ping timeout: 244 seconds]
makomo has joined #lisp
_cosmonaut_ has joined #lisp
froggey has joined #lisp
random-nick has joined #lisp
vlatkoB_ has joined #lisp
vlatkoB has quit [Ping timeout: 260 seconds]
<_death>
it's just asdf stupidity.. I removed the warning emitting code from my copy
daniel-s has joined #lisp
trittweiler has quit [Ping timeout: 260 seconds]
dmiles has quit [Ping timeout: 244 seconds]
hhdave has joined #lisp
logicmoo has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
lumm has quit [Ping timeout: 240 seconds]
surya has joined #lisp
jmercouris has joined #lisp
wigust- has quit [Read error: Connection reset by peer]
<jmercouris>
So when you use DEFUN, what exactly happens? we somehow associate a symbol with a lambda?
<jmercouris>
is a defun creating a lambda under the hood?
wigust has joined #lisp
<jmercouris>
Let's say I do something like (defparameter q #'(lambda (n) (* n n)))
<jmercouris>
why can't I then do (q 2) ?
<jmercouris>
why do I have to do (funcall q 2)?
<loke>
jmercouris: because when you do (FOO), you are funcalling the value in the function slot of the symbol
<loke>
(well, assuming there is no lexical binding of the function FOO)
<jmercouris>
who can I set the function slot of a symbol?
<jmercouris>
s/who/how
<jmercouris>
without using defun
<jmercouris>
Ah, so that is why a function and a variable can both have the same symbol, the symbol has different slots for each?
<loke>
jmercouris: You can do (setf (symbol-function 'foo) (lambda () (print "hello")))
<beach>
jmercouris: There is no such thing as "a lambda".
<_death>
it's actually quite educational to expand defun and try to understand everything that happens.. for example on sbcl you're led to the global info db
<jmercouris>
okay, when I say lambda, I mean "anonymous function"
<beach>
jmercouris: Yes, DEFUN creates an anonymous function and associates the name with it.
<jmercouris>
very very interesting
<jmercouris>
that makes sense indeed
<beach>
jmercouris: There are (at least) two namespaces in Common Lisp, one for functions and one for variables.
<jmercouris>
how can I find out what slots the symbol class has?
<jmercouris>
beach: namespaces? like packages?
<beach>
jmercouris: When you type (foo x), FOO is looked up in the function namespace, and X in the variable namespace.
<beach>
jmercouris: No, orthogonal to packages.
<jmercouris>
Ok
<beach>
jmercouris: The function may not be stored in a slot of the symbol.
<beach>
jmercouris: In SICL, it is not, for instance.
<jmercouris>
Is that an implementation detaiL?
<beach>
Yes.
<jmercouris>
Okay, because I just did (describe 'symbol) in SBCL and it doesn't show any slots
<beach>
Try (describe 'car) instead.
<jmercouris>
I see
<beach>
jmercouris: You can use (SETF FDEFINITION) to associate a name with a function.
<beach>
clhs fdefinition.
<specbot>
Couldn't find anything for fdefinition..
<jmercouris>
A lot to think about, thanks for explaining
<beach>
jmercouris: Put yourself in the position of a commercial Common Lisp vendor. If every customer could say (edit (fdefinition 'compile)) then they would have no trade secretes.
<jmercouris>
I guess I've never been in that position :D
<beach>
jmercouris: Also consider that the ANSI committee was largely composed of vendor representatives.
<jmercouris>
That makes sense, as they are the ones with any actual money
<beach>
Exactly.
<_death>
jmercouris: maybe pjb's ibcl lets you do that
<jmercouris>
Ah, I may check it out if I have some time later
<beach>
jmercouris: Also, you need to get used to thinking in terms of protocols. It is not just because there is a function called SYMBOL-FUNCTION that the symbol must have a slot containing the function.
<beach>
jmercouris: What should tip you off here is that function names can also be of the form (SETF <symbol>).
<jmercouris>
beach: Yeah, I guess the implementation can be whatever it wants behind this protocol, it's just that in A Gentle Introduction to Symbolic Computation, the author very frequently talks about things in terms of a very specific implementation in mind
<jmercouris>
so I am never sure whether that is the author just assuming, or if it is part of the specification
<beach>
jmercouris: He would not be the first one to make such incorrect assumptions. Even the Common Lisp HyperSpec uses "function slot of the symbol" sometimes.
markoong has joined #lisp
<jackdaniel>
right, I had to "fix" eql to equal in a few places in ECL's compiler wrt function names
<beach>
jmercouris: On the contrary. They spent a lot of time and a lot of energy thinking about what could be done, given that it must be possible to write a high-performance compiler for the language. These are no dopes, as opposed to many other language designers.
<_death>
shrdlu68: maybe you're thinking about the research into early use of email based on the committee's discussions
<jmercouris>
beach: I believe it
<jmercouris>
especially since many other languages have a single inventor who created the language in what feels like a weekend worth of time
lumm has joined #lisp
<beach>
jmercouris: Now, this was the 1990s and compiler technology has made some progress. So you will occasionally find a restriction that was justified at the time, but that could be relaxed nowadays.
<jmercouris>
for example, if you look at the story about the creation of ruby, it sounds like all the guy had to do was get emacs syntax highlighting to work, and that was his green light
<shrdlu68>
_death: Yes, it was an analysis of how people attempt to make up for the lack of non-verbal cues in communication, hence inventing symbols like :)
<jmercouris>
shrdlu68: those symbols are known as emoticons
<shrdlu68>
*in text communication.
<beach>
jmercouris: I don't know of Ruby in particular, but yes, there are many languages that have been created by people with no clue, and that's fine. What is NOT fine is that these languages sometimes catch on and become "standard".
<shrdlu68>
jmercouris: At the time of the paper's writing, I believe those symbols were a new phenomenon.
<_death>
I think Fahlman (a member of the CL standardization committee) is credited with the invention of the smiley..
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
dddddd has quit [Ping timeout: 256 seconds]
surya has joined #lisp
<beach>
shrdlu68: I might read that book some day. Thanks for pointing it out.
nullman has quit [Ping timeout: 264 seconds]
Josh_2 has joined #lisp
<shrdlu68>
beach: My pleasure.
nullman has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
milanj_ has joined #lisp
muresanvlad_ has quit [Quit: Salve]
skeuomorf has quit [Ping timeout: 260 seconds]
muresanvlad_ has joined #lisp
Kaisyu has joined #lisp
scymtym_ has joined #lisp
scymtym has quit [Ping timeout: 265 seconds]
dddddd has joined #lisp
mooshmoosh has quit [Ping timeout: 264 seconds]
<jmercouris>
I'm trying to split apart a string into a list, based on two rules
<jmercouris>
here is an example "define fish :topic ocean" should split into (list "define" "fish" ":topic" "ocean")
<jmercouris>
here is a more challenging example: "define fishing rod :topic ocean" should split into (list "define" "fishing rod" ":topic" "ocean")
<LdBeth>
Ah, you mean tokenize
<jmercouris>
Yes, I am trying to write a tokenizer
<jmercouris>
The approach I am thinking about now is just splitting by spaces, and joining if the next term doesn't start with a ":"
<jmercouris>
with an exception of the first term
<LdBeth>
In such situation it’s better to have a keyword table maintained
<jmercouris>
keyword table? there an infinite amount of keywords, I don't want to have to update my tokenizer when a new keyword is invented
NoNumber has joined #lisp
<LdBeth>
A keyword table like Lisp’s, where keywords are automatically interned to.
Josh_2 has quit [Remote host closed the connection]
<LdBeth>
Especially useful if you want to parse some notations like 1*3+3
xaotuk has joined #lisp
<LdBeth>
Where no delimiters are present between tokens
mooshmoosh has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
<jmercouris>
Okay, let's say I do have a keyword table, how would I use it?
<jmercouris>
wouldn't I still need to iterate and split based upon presence of keywords?
anewuser has joined #lisp
Murii_ has joined #lisp
brettgilio has quit [Remote host closed the connection]
<shka>
jmercouris: if you are doing it from scratch...
<jmercouris>
I am, I just want a little defun, I'm almost done anyways
<shka>
what people here are using for numerical stuf in cl? i am looking namely for approximated integrals
anewuser has quit [Read error: Connection reset by peer]
xaotuk has quit [Ping timeout: 240 seconds]
eli_oat has joined #lisp
LiamH has joined #lisp
milanj_ has quit [Quit: This computer has gone to sleep]
Bike has joined #lisp
surya has quit [Ping timeout: 240 seconds]
<loke>
shka: You can do exact integrals using Maxima
<jkordani>
beach: re: What should tip you off here is that function names can also be of the form (SETF <symbol>).
makomo has quit [Quit: WeeChat 2.0.1]
EvW has joined #lisp
<jkordani>
so the idea that a function associated with a symbol "is stored in a slot of the symbol" is actually an implementation specific description of "where to access a function"
<beach>
Exactly.
mindCrime has joined #lisp
<beach>
If there were a function slot for each symbol, there would then have to be two, one for the function named after the symbol and another for the function named (SETF <symbo>).
<jkordani>
I don't understand that part
<beach>
It's not that important. I guess some implementations would have two "cells" in each symbol.
<beach>
But you can look at it historically as well...
<beach>
Before the standard, there were no functions named (SETF <symbol>).
<beach>
So implementations that existed than might have a single function cell in each symbol.
<jkordani>
well that last sentence still doesn't make sense to me, what is a function named (setf <symbol)
<beach>
Then the standard comes along. What do the maintainers of the implementation do?
<beach>
Oh.
<beach>
(defun (setf bla) (new-value thing) ...)
<beach>
Like (setf car) (setf slot-value), etc.
<jkordani>
oh I see what you mean
<beach>
From the glossary: function name n. 1. (in an environment) A symbol or a list (setf symbol) that is the name of a function in that environment. 2. A symbol or a list (setf symbol).
<jkordani>
in order to use the right setf for a given symbol it too needs to be stored somewhere, and is also a function
<beach>
Right.
<jkordani>
one association could simply be as a slot in the symbol, or could be some other implementation
<beach>
So if you go the "cell-in-symbol" route, you would need two cells.
<beach>
True, and I think SBCL does that.
<beach>
It stores one function in the symbol and the other one elsewhere.
<beach>
I would not do it that way.
<beach>
I would either have two cells in each symbol or none.
<jkordani>
setf is some magic I should read up on next. And thank you
<beach>
Sure.
<beach>
As it turns out, in for SICL, I store the functions in a first-class global environment object instead of in the symbols.
<White_Flame>
what sort of lookup complexity do you have to retrieve the function?
<beach>
Constant time. One memory access.
<White_Flame>
huh, is it sort of like a thread local table offset lookup?
<jkordani>
^
<beach>
At least for the case where the function name is known at compile time.
pfdietz has joined #lisp
pjb has quit [Ping timeout: 256 seconds]
<beach>
No, I create a cell in the environment. When the code is loaded from FASL, or compiled, the code refers directly to the cell in a lexical variable.
brettgilio has joined #lisp
<shka>
loke: sadly, i can't do that in my use case
<White_Flame>
beach: and when it's not known at compile time?
<beach>
White_Flame: (fdefinition (read))
ebrasca has joined #lisp
<beach>
But I handle all cases such as (<function-name> <arg> ...).
<White_Flame>
sure, I'm just curious about the implementation detail & tradeoffs
<beach>
Of course.
<Bike>
it's just a hash lookup, isn't it?
<beach>
When the name is not known at compile time, yes.
<Bike>
the variable case. i imagine most implementations do basically a hash
<beach>
No, most implementation access the function cell in the symbol.
<White_Flame>
well, most implementations probably have the symbol-function as a slot on the symbol object itself
<Bike>
er. right, you could store it right in the... right right
<White_Flame>
the READ is generally not part of it
pjb has joined #lisp
<Bike>
i was thinking of other environment things
pjb is now known as Guest41056
<Bike>
like i think sbcl stores compiler macros and type definitions in a global table rather than the symbol
<White_Flame>
it might reduce the memory footprint
<White_Flame>
given the ratio of fdefined symbols vs non-fdefined ones, and the overhead of the hashtable
<beach>
White_Flame: My motivation was multi-user, sandboxing, and bootstrapping.
<White_Flame>
yes, I have those desires myself. Just not to embark on a total rewrite myself :)
<beach>
Oh, are you the maintainer of an implementation?
<beach>
I guess I must have missed that.
<White_Flame>
not of a CL implementation, but I like many others have tons of notes on a lisp-derived language
<White_Flame>
I've implemented quite a few languages of varying sorts for internal commercial use
<beach>
Oh, I see.
warweasle has joined #lisp
<Bike>
honestly, it kind of surprises me how first class environments aren't in anything important. we all used them when we wrote our first scheme implementation
<Bike>
but even in scheme proper they're like, "namespaces" or something
<shka>
hm
<beach>
Bike: I think most suggested implementations take a hash-table lookup hit for each function call, and that is unacceptable.
<beach>
Bike: Scheme people don't care as much because they are often not into performance as much as Common Lisp people are.
Guest41056 has quit [Ping timeout: 256 seconds]
<Bike>
yeah, i think it's a disconnect with compilation
<beach>
Bike: I think my main contribution with that paper is a solution to that problem.
<Bike>
i've implemented a scheme derivative (not mine) with them, but the language overall was outright hostile to compilation
<beach>
I see.
serviteur has joined #lisp
<Bike>
and yeah, your load time thing is neat.
<beach>
Thanks!
<White_Flame>
at some point, probably after I'm retired, I might attempt a JIT/dynarec Lisp implementation
<Bike>
it's too bad about how hard sandboxing CL is
<warweasle>
White_Flame: SafeLisp?
test1600 has quit [Ping timeout: 264 seconds]
<White_Flame>
FastLisp :)
<warweasle>
DesignedByComitteeLisp
<White_Flame>
or at least, FigureOutYourOwnDeclarationsLisp
serviteur has quit [Remote host closed the connection]
serviteur has joined #lisp
<warweasle>
MyDogsLisp
<jmercouris>
Sandboxing CL is not hard
isospin` has quit [Quit: ERC (IRC client for Emacs 26.1)]
<jmercouris>
just make a VM and run CL in the VM
<jmercouris>
voila, CL sandboxed
<jmercouris>
or make a BSD Jail if you don't want to make a VM
<jackdaniel>
security is not a problem, just put the computer offline
TRS-80 has joined #lisp
Guest41056 has joined #lisp
<jmercouris>
physical access security is also a type of security
<jmercouris>
you'd be best off dismantling the machine into individual atoms
<TRS-80>
(hello (everyone))!
<beach>
Hello TRS-80.
kaun has joined #lisp
<Bike>
individual atoms would bond with each other and worse, possibly atoms of an attacker. totally insecure
<TRS-80>
having bit of issue in Emacs trying to set up CalDAV sync using org-caldav, however I feel like my problem is lisp related, missing parenthesis, backtick, etc... because I had it all working last step, but next incremental step now not working. Pasta incoming.
matijja has quit [Ping timeout: 276 seconds]
<jmercouris>
TRS-80: elisp is not common lisp
<jackdaniel>
TRS-80: Emacs questions are usually asked on #emacs
<jackdaniel>
this channel is about CL (as jmercouris said) lookup the topic
<TRS-80>
tried there, no reply (yet?)
<beach>
TRS-80: #lisp is better in that respect, but unfortunately (for you) reserved for Common Lisp.
<jackdaniel>
IRC is an asynchronous protocol, getting an answer may take time (or questions may be not answered) - either way that's the place to ask such questions
<warweasle>
There is no better example of the iterated 3-tank problem than why common lispers uses emacs.
<beach>
I once asked a question in some Linux music channel and it took someone a few weeks to answer. :)
<jmercouris>
TRS-80: you could ask in #lispcafe
<jmercouris>
many of the people on this channel are there
<kaun>
beach: kudos to your patience!
<warweasle>
TRS-80: This is the dark underbelly of the internet. It was one of the first applications to gain traction and is still in use because it is so simple.
<warweasle>
And us old geysers don't like change.
<beach>
warweasle: What is the "iterated 3-tank problem"?
Guest41056 has quit [Ping timeout: 240 seconds]
<beach>
kaun: Yeah, I wasn't in a hurry and I would rather have the experts work on it. :)
<warweasle>
You know the 3 tank problem where there are 3 tanks, strong, medium and weak? Well the weak one usually wins.
<warweasle>
Now add more tanks.
<kaun>
Are pre-RTFM questions OK here? I was wondering if visibility of fields in CLOS classes could be controlled?
<beach>
warweasle: Never heard about that problem before.
EvW has quit [Ping timeout: 240 seconds]
<flip214>
kaun: "visibility" as in "when reflecting"?
<minion>
flip214, memo from jmercouris: Thanks for the heads up, I'll have to consider the tradeoffs in distribution vs execution time (e.g. the binary size vs startup time)
<beach>
kaun: Yes, use packages.
<TRS-80>
kaun: did you see the link jackdaniel just posted? lol
<kaun>
nope!
<TRS-80>
warweasle: I'm not so young myself. Not old but not young.
<serviteur>
define old
<kaun>
Wasn't it sufficiently smart to qualify the question as pre-RTFM? ;-)
<beach>
kaun: The package system is used to control visibility of any name that is a symbol, and that includes slot names.
<warweasle>
TRS-80: GET OFF MY LAWN! (See, I'm older)
EvW has joined #lisp
<jmercouris>
TRS-80: Not everyone in this channel agrees with everything everyone else says
<TRS-80>
warweasle: you have no idea how often I say that (I don't actually even have a laen, but...)
matijja has joined #lisp
<beach>
jmercouris: I totally agree.
<kaun>
beach: thanks.
<warweasle>
jmercouris: Yes we do!
<shka>
i can disagree with someone just to prove the point
<shka>
:P
<jmercouris>
I was just trying to make the point, that I clicked the link, and disagreed with it
daniel-s has quit [Remote host closed the connection]
<jmercouris>
The introduction immediately put me off, makes it sound like I have to go through some gang initiation to get support for my problems
xaotuk has joined #lisp
<warweasle>
jmercouris: What about our lisp gang sign?
graphene has quit [Read error: Connection reset by peer]
<warweasle>
Oh, wait. We were rolled into the Bloods after their corporate buyout...
<warweasle>
I think we are Disney now.
<kaun>
I think SBCL's Nikode
graphene has joined #lisp
varjag has joined #lisp
<kaun>
mus wrote in some blog's comments, that ...
test1600 has joined #lisp
<kaun>
... the package system is brought too late in tutorials/guides.
cymew has quit [Remote host closed the connection]
<beach>
I believe it's the first thing handled in "Common Lisp Recipes".
cymew has joined #lisp
<kaun>
People who only started programming in the 21st century look for visibility control, I think. Not finding it soon enough increases the perception that Lisp isn't suited for typical systems.
<beach>
kaun: Please, not that kind of argument again.
<jmercouris>
I don't see why visibility control is important at all in general?
<jmercouris>
Okay, I'll hold my peace
<jmercouris>
s/peace/piece?
<kaun>
Well, I haven't read all of the guides. Gave up on Touretzky's as too basic, now happily munching through PAIP.
<beach>
kaun: We get lots of that kind of stuff here, and it gets really boring after a while. It seems directed to some kind of body of people in charge of everything abound Common Lisp, and the members of this body are told to do things differently, so that newcomers can be happier. The problem is that there is no such body, so nobody is listening.
<beach>
kaun: You are just going to have to roll up your sleeves and write one in the style that you would like to see.
<warweasle>
CLOS blew my mind when I first learned it.
surya has joined #lisp
milanj_ has joined #lisp
<kaun>
beach: It was an observation. I had to ask to get to know about it. It isn't something to be fixed.
<kaun>
beach: true. I think the biggest problem for fledgling hobbyists is the terseness of Lisp code; it makes the initial hobby projects look childish.
Guest41056 has joined #lisp
<Xach>
I know I've thought more than once "how can something so small be useful?" and it usually is very, very useful.
<loke>
Hello xaxh
<loke>
xach
<warweasle>
Xach: PAIP's unification code was that for me.
<jmercouris>
(getf (list :salmon "fish of the sea") :salmon) -> "fish of the sea"
shrdlu68 has quit [Ping timeout: 244 seconds]
<Xach>
hi loke
<jmercouris>
(getf (list (intern ":salmon") "fish of the sea") :salmon) -> nil
<Xach>
warweasle: yes!
<loke>
Hello Xach. I was about to bug you about 1530, but I noted it's been taken care of. :-)
<jmercouris>
I know I'm doing something wrong, but I'm trying to intern a symbol in the keyword package, from a string
<Xach>
jmercouris: (intern "SALMON" (find-package "KEYWORD")) is one way to do that.
<beach>
kaun: If you need help, all you have to do is ask. Common Lisp is not mainly meant for fledgling hobbyists, so I can see why they would have problems initially, especially if they expect a toy language.
<Xach>
jmercouris: as you know, ":" is not part of the symbol name, but a marker between the package name and the symbol name.
<Xach>
and keyword symbols print that info in a special way
<jmercouris>
Xach: I did not know, but now I won't forget, thanks
<TRS-80>
Xach jmercouris is this different in Emacs lisp? Looks very similar to me.
<Xach>
You could approximate what you want with (read-from-string ":salmon")
<Xach>
TRS-80: there are superficial similarities.
<beach>
Does Emacs Lisp have packages now?
gigetoo has quit [Ping timeout: 240 seconds]
Guest41056 has quit [Ping timeout: 256 seconds]
<TRS-80>
in fact jmercouris issue looks almost exactly like the one I'm wrestling with presently
<kaun>
beach: the problem is mainstream languages set expectations toy-language level, you need to gain perspective after learning a bit of CL to realize your hobbies can afford to be a lot more ambitious.
igemnace has joined #lisp
<TRS-80>
beach: there are packages in Emacs, yes. And a package manager (package.el) And repositories (ELPA, Org, MELPA, etc.). Not sure if that answer your question?
<flip214>
can I TRACE a closure?
<Xach>
TRS-80: those are different types of package.
<Xach>
a different definition.
<TRS-80>
gotcha
<beach>
TRS-80: A package in Common Lisp is a mapping from symbols to objects. It is used to control access to "modules".
kuwze has joined #lisp
brettgilio has quit [Remote host closed the connection]
<beach>
TRS-80: We call what you refer to "systems".
<TRS-80>
interesting
shrdlu68 has joined #lisp
<TRS-80>
I seem to be having very similar list related issue (well maybe not, I could be misunderstanding) but since I just had it working prior to latest step I feel like I am missing something simple, some ( or backtick or something. Anyway here it is: https://paste.pound-python.org/show/ue52FvKMIeqWyF8vBmTq/ Line 2 is what worked before, but line 7 now is not working. :/
kaun has quit []
graphene has quit [Read error: Connection reset by peer]
gigetoo has joined #lisp
al-damiri has joined #lisp
Inline has joined #lisp
nowhere_man has joined #lisp
housel` is now known as housel
_cosmonaut_ has quit [Ping timeout: 240 seconds]
stnutt has quit [Ping timeout: 260 seconds]
Cymew_ has joined #lisp
terpri has quit [Ping timeout: 260 seconds]
cymew has quit [Ping timeout: 240 seconds]
kerframil has joined #lisp
xuxuru has joined #lisp
xrash has quit [Ping timeout: 244 seconds]
surya has quit [Ping timeout: 264 seconds]
shrdlu68 has quit [Ping timeout: 265 seconds]
<jmercouris>
TRS-80: this is not an elisp question, this is an emacs org-mode configuraiton question, you should ask on #emacs, there are many many users present
<jmercouris>
s/configuraiton/configuration
surya has joined #lisp
<Xach>
frabjous day, july quicklisp dist update is now available.
Cymew_ has quit [Remote host closed the connection]
<beach>
Excellent!
kuwze has quit [Ping timeout: 252 seconds]
matijja has quit [Ping timeout: 260 seconds]
kozy has joined #lisp
FreeBirdLjj has joined #lisp
stnutt has joined #lisp
nowhere_man has quit [Ping timeout: 240 seconds]
kozy has quit [Remote host closed the connection]
mindCrime has quit [Ping timeout: 240 seconds]
graphene has joined #lisp
scymtym_ has quit [Ping timeout: 240 seconds]
k4rtik has joined #lisp
cymew has joined #lisp
kozy has joined #lisp
kozy has quit [Remote host closed the connection]
test1600 has quit [Ping timeout: 260 seconds]
sabrac has quit [Ping timeout: 264 seconds]
kozy has joined #lisp
cymew has quit [Ping timeout: 260 seconds]
mejja has joined #lisp
kozy has quit [Remote host closed the connection]
sabrac has joined #lisp
graphene has quit [Ping timeout: 244 seconds]
cymew has joined #lisp
fikka has joined #lisp
kozy has joined #lisp
kozy has quit [Remote host closed the connection]
serviteur has quit [Remote host closed the connection]
xaotuk has quit [Ping timeout: 256 seconds]
pierpal has quit [Quit: Poof]
shifty has quit [Ping timeout: 265 seconds]
cymew has quit [Ping timeout: 268 seconds]
<antoszka>
Better than the July the 5th Android Security Update!
kozy has joined #lisp
pierpal has joined #lisp
<shka>
antoszka: context?
<antoszka>
16:34:36 Xach frabjous day, july quicklisp dist update is now available.
mindCrime has joined #lisp
<shka>
and what about android security update?
cymew has joined #lisp
<antoszka>
Nothing, it was just a "funny" way to cheer upon the QL dist update announcement.
Kaisyu has quit [Quit: Connection closed for inactivity]
<beach>
I wrote some code for testing the Doug Lea style memory allocator that I wrote the other day. The testing code submits random sequences of requests for allocating or freeing chunks. I use a Markov process so that it is likely that there are long-ish sequences of allocations and long-ish sequences of frees.
Inline has joined #lisp
<beach>
Memory is simulated, so each "memory" access takes a long time. I started a test with 10 million operations and it has been running for several hours. By now it has completed almost 3 million operations without any problem.
<beach>
shka: ↑
<shka>
beach: congrats!
<beach>
Thanks.
<beach>
The allocator is now up to 385 lines of code.
<antoszka>
Xach: can I find the maintainer of a package from the quicklisp quicklisp dist?
kozy has joined #lisp
<beach>
It will grow a bit as I introduce symbolic constants, write more comments, etc.
cymew has quit [Ping timeout: 240 seconds]
k4rtik has quit [Ping timeout: 240 seconds]
<shka>
memory allocator developed at work is utter crap and was overwritting memory even after few years since first commit
<shka>
so i know that this is non trivial
emacsomancer has quit [Remote host closed the connection]
<beach>
But Doug Lea's algorithm is really very simple.
kozy has quit [Remote host closed the connection]
_cosmonaut_ has quit [Ping timeout: 240 seconds]
emacsomancer has joined #lisp
graphene has joined #lisp
<shka>
beach: everything can be made complicated ;-)
cymew has joined #lisp
kozy has joined #lisp
<beach>
I guess. But it is more likely that the person who wrote your allocator tried to come up with his or her own algorithm and data structure, and then just got it wrong.
<shka>
actually, he did
<shka>
but he is my boss :P
<beach>
Bosses often get it wrong.
<shka>
gladly, i don't work at this project anymore
EvW has quit [Remote host closed the connection]
robotoad has joined #lisp
cymew has quit [Ping timeout: 248 seconds]
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
cymew has joined #lisp
<beach>
I picked Doug Lea's algorithm and data structure because Paul Wilson, in his allocator survey, found that this one is the best one he tested. Plus, like I said, it is dead simple.
cymew has quit [Ping timeout: 244 seconds]
Khisanth has joined #lisp
kozy has quit [Remote host closed the connection]
cymew has joined #lisp
kozy has joined #lisp
robotoad has quit [Quit: robotoad]
cymew has quit [Ping timeout: 268 seconds]
iskander has joined #lisp
<Xach>
antoszka: not easily. it's easier to check out the quicklisp-projects repo.
orivej_ has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
graphene has quit [Remote host closed the connection]
housel has quit [Remote host closed the connection]
graphene has joined #lisp
blackwolf has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
warweasle__ has quit [Read error: Connection reset by peer]
warweasle_ has joined #lisp
copec has quit [Ping timeout: 245 seconds]
housel has joined #lisp
<shka>
beach: just reading it
<beach>
The code? It is not pretty right now.
<beach>
There are a lot of "magic literals" in there.
copec has joined #lisp
<beach>
And you might need the documentation (which does not quite reflect what I ended up coding).
<shka>
beach: survey
<beach>
Oh, OK.
<beach>
Excellent document!
<shka>
i would love to see updated version though
<beach>
Not going to happen.
surya has quit [Ping timeout: 244 seconds]
<shka>
this much is certain
<antoszka>
Xach: thanks, I just found the library on github and filed an issue.
<beach>
shka: They basically conclude that all the research done on memory allocation prior to their survey came to the wrong conclusions because of bad assumptions.
<shka>
but i wonder how this would stack against slab/slob allocators
surya has joined #lisp
k4rtik has joined #lisp
robotoad has joined #lisp
<shka>
well, article looks like impressive piece of work
<shka>
i will read it for sure
FreeBirdLjj has quit [Remote host closed the connection]
<beach>
I scanned the Wikipedia articles on SLAB, SLOB, SLUB and they look very specialized compared to what Doug Lea is doing.
<beach>
Specialized to specific situations in the kernel.
<shka>
yeah
<shka>
they are
Mutter has joined #lisp
lumm has quit [Ping timeout: 240 seconds]
<beach>
About the survey, when was it published again? 1990s?
EvW1 has joined #lisp
<shka>
it looks like it
<shka>
but i can't see the date
<shka>
at least after 95
<beach>
I still get objections to my suggested memory management like "but what about fragmentation?", and this is despite the fact that it has been known for 20 years that fragmentation results were caused by incorrect assumptions about program behavior. For a field that is supposed to move as fast as CS, it is moving pretty slowly.
<shka>
beach: those objections being that you don't try to defragmentate memory?
PinealGlandOptic has joined #lisp
<beach>
Yes. That objects in the global heap do not move, and that I use an ordinary malloc()/free() style allocator for the "racks".
flamebeard has quit []
<beach>
Not only that. I also use nursery heaps that are compacting, so objects that are promoted to the global heap are very likely to be long-lived.
Domaldel has quit [Quit: Leaving]
<beach>
I can be wrong of course, and only experience can tell, but I feel pretty good about this being the right way.
pjb has joined #lisp
scymtym has joined #lisp
xaotuk has quit [Ping timeout: 240 seconds]
orivej_ has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
Murii_ has quit [Ping timeout: 244 seconds]
terpri has joined #lisp
buffergn0me has joined #lisp
EvW1 has quit [Ping timeout: 265 seconds]
karlosz has quit [Quit: karlosz]
jmercouris has quit [Ping timeout: 240 seconds]
<shka>
beach: well, having objects staying in one place is so common
<shka>
mostly because of C libs
<shka>
but nontheless, even in the land of JS, most browsers just don't bother with that
<beach>
Sure. They have no choice.
<shka>
so it looks like consensus is that copying GC is not worth the trouble
<beach>
I would not go that far.
<beach>
I do have nursery collectors that are compacting.
<shka>
well, I can because nobody listens to me anyway :-)
<beach>
Aww! :(
<beach>
There is also the question of performance.
<beach>
malloc()/free() is a much slower mechanism than bumping a pointer.
<beach>
So in a Common Lisp environment where presumably allocation is more frequent, it is good to have something faster.
<beach>
My plan is for the nursery to be fast, and to handle short-lived objects.
<beach>
Plus the nursery is a sliding collector, so the ages of objects are much more precise than in a semi-space copying collector.
<beach>
I am hoping objects get promoted only if they are very likely to be long lived.
<didi>
Just one data point, but my current problem isn't with the speed of the GC, but with the space it needs to work. It needs almost double the memory to work.
<beach>
didi: Yes, that's another characteristic of a traditional semi-space copying collector.
<beach>
didi: Though, if you look at the literature, basically any collector has this kind of trade-off. If you give it significantly less than twice the amount of memory you actually need, it is going to collect increasingly more often.
<JuanDaugherty>
CS as a whole moves fast in some areas, particularly hardware but there's the generational turnover
<JuanDaugherty>
which tends to form a perpetually callow workforce
hhdave has quit [Ping timeout: 264 seconds]
<didi>
beach: In my case, I would gladly take this offer.
<didi>
It's the difference between having a result eventually against no results at all.
<beach>
didi: I see. Well the sliding collector can be tuned for that.
warweasle__ has joined #lisp
<didi>
Nice.
lumm has quit [Ping timeout: 240 seconds]
<JuanDaugherty>
some cultures also move faster than others, compare CL in 1989 vs now to SML then vs haskell now
warweasle_ has quit [Read error: Connection reset by peer]
<shka>
JuanDaugherty: haskell is paradgim shift
<shka>
CL is still CL
<shka>
so it is not exactly fair
<shka>
you can compare CL to Shen or other, novel lisp
<JuanDaugherty>
alls fair in love and CS
<shka>
anyway, time to go home!
<shka>
good bye
<beach>
shka: take care!
graphene has quit [Remote host closed the connection]
<shka>
beach: anyway, i don't see anything wrong with your assumption and they seem to follow my expirence closely
kerframil has quit [Quit: Leaving]
<shka>
so yeah
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
graphene has joined #lisp
didi has quit [Remote host closed the connection]
buffergn0me has quit [Ping timeout: 264 seconds]
m00natic has quit [Remote host closed the connection]
andrei-n has quit [Read error: Connection reset by peer]
andrei-n has joined #lisp
nowhere_man has joined #lisp
NoNumber has joined #lisp
surya has quit [Read error: Connection reset by peer]
pjb has quit [Remote host closed the connection]
milanj_ has quit [Quit: This computer has gone to sleep]
pjb has joined #lisp
pjb is now known as Guest77796
k4rtik has quit [Ping timeout: 240 seconds]
<phoe>
Hey people
<phoe>
I just worked around the issue with LISP-BINARY
<phoe>
I split the file binary.lisp in two halves and it compiles on SBCL under normal heap sized.
<phoe>
sizes.
pjb` has joined #lisp
Guest77796 has quit [Read error: Connection reset by peer]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<p_l>
JuanDaugherty: a lot of Haskell "speed" was due to explicit disregard for usability outside of academic papers
<JuanDaugherty>
i take it you mean speed of development, given that it was gradual from the mid 90s
warweasle_ has joined #lisp
warweasle__ has quit [Read error: Connection reset by peer]
<JuanDaugherty>
it inflated during the 96-06 period to roughly the current thing, then deepened
warweasle_ has quit [Read error: Connection reset by peer]
<p_l>
JuanDaugherty: well, code evolution etc.
warweasle_ has joined #lisp
<JuanDaugherty>
cl on the other more or less just stagnated, insofar as innovation is concerned, with a solid free implementation and some pkgs being the main thing I know of
<JuanDaugherty>
*hand
<JuanDaugherty>
not that that's necessarily a bad thing in a mature culture
<p_l>
JuanDaugherty: a lot of difference is that Haskell is the baby of academic PL research, you can see similar effort in Racket which has same case
<JuanDaugherty>
maintaining a good thing is better than friviolous innovation
shka_ has joined #lisp
<JuanDaugherty>
lookin at you blarney starsoup
<JuanDaugherty>
it's baby of those that want CS to be pure math
* phoe
gently nudges JuanDaugherty and p_l a little bit towards #lispcafe
k4rtik has joined #lisp
mflem has joined #lisp
warweasle_ has quit [Read error: Connection reset by peer]
warweasle_ has joined #lisp
orivej has joined #lisp
warweasle_ has quit [Read error: Connection reset by peer]
warweasle_ has joined #lisp
groovy2shoes has quit [Quit: moritura te salutat]
Josh_2 has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
karlosz has quit [Ping timeout: 244 seconds]
jasmith has quit [Ping timeout: 248 seconds]
Josh_2 has joined #lisp
lumm has joined #lisp
ym has quit [Ping timeout: 244 seconds]
nowhere_man has quit [Ping timeout: 256 seconds]
w17t has joined #lisp
w17t has quit [Max SendQ exceeded]
<jasom>
beach: One thing I've noticed is that some of the literature assumes most allocations are small; e.g. comparisons of space overhead in mark/sweek vs. semispace often assume that the typical allocation size is 2 words (i.e. a cons cell). I also agree with didi, in that a lot of real world code these days run on VMs, which are often quite tightly memory bound, so going over your memory allocation means swapping,
<jasom>
which hurts more than more frequent GCs. Also I have often seen SBCL quit with the heap exhausted just because it is so conservative about when to GC that it waits until it is too late...
JuanDaugherty has quit [Quit: Exeunt]
w17t has joined #lisp
w17t has quit [Max SendQ exceeded]
<jasom>
Were earlier time-share systems that lisp ran on single address space? VMs tend to have fixed partitioning of RAM, which means CPU time can be time shared, but memory cannot...
shrdlu68 has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
groovy2shoes has joined #lisp
warweasle__ has joined #lisp
warweasle_ has quit [Read error: Connection reset by peer]
EvW has joined #lisp
rjid has joined #lisp
rjid has left #lisp [#lisp]
gabiruh has quit [Ping timeout: 244 seconds]
gabiruh has joined #lisp
random-nick has quit [Ping timeout: 264 seconds]
<p_l>
jasom: VMs can have both dynamic and static ram setups
<p_l>
jasom: for GC size, there's tunable
<jasom>
p_l: see "tend to have"
<p_l>
jasom: also, a lot of problems with GC'ed languages these days is at the huge heap sizes
<jasom>
when renting space on someone elses machine, RAM is the primary cost.
<p_l>
yeah, ram tends to be scarcer resource than CPU
<p_l>
reminds me that I should reduce the core count on my custer
<jasom>
for maximizing throughput you put off GC as long as possible, but that has repercussions...
<p_l>
jasom: yes
<p_l>
Azul, Shenandoah and similar make for nice solutions, but they aren't exactly doable for SBCL
<p_l>
(they should be trivial for some implementations though)
<jasom>
I ran into a similar issue with a wear-leveling flash file system. It would have great throughput, but then just stop responding for 30 seconds. Investigation determined that it was delaying moving data as long as possible to decrease write amplification.
rawste has joined #lisp
<jasom>
p_l: well the graph on the right was made after implementing a simple workaround for sbcl (just manually GC on a timer)
<p_l>
jasom: that's sometimes called "metronome" approach, and comes from realtime GC
<jasom>
It also tuned the nursery size actually (rereading what they did now).
<p_l>
implementing Metronome would be interesting
<jasom>
p_l: though the true metronome requires an incremental collector; if you set aside X% of CPU time for GCing and you can GC incrementally, you are now realtime.
<jasom>
or rather you can achieve realtime. True hard realtime systems require a lot of analysis, so it's the job of the various tools to make analysis tractible.
<p_l>
jasom: well, so long as you ensure that GC runs within specified quanta and not any longer you technically have metronome
<p_l>
jasom: I believe IBM implementation used wall-clock, not cpu time
<jasom>
the two are closely related on fixed-clock single-core systems
<jasom>
but you are probably right, wall-clock is what matters in the final analysis
Ven`` has joined #lisp
<jasom>
but yes, SBCL with a 1GB heap and a background thread invoking the GC every few seconds can probably be made to meet a hard realtime requirement of 2-3 seconds :)
<jasom>
though there are a troublingly large number of places where GC is excluded in the runtime.
scymtym has quit [Ping timeout: 240 seconds]
anewuser has joined #lisp
asdf123 has quit [Remote host closed the connection]
asdf123 has joined #lisp
lumm has quit [Read error: Connection reset by peer]
lumm has joined #lisp
lumm_ has joined #lisp
k4rtik has quit [Ping timeout: 256 seconds]
saki has joined #lisp
chiyosaki has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
lumm has quit [Ping timeout: 240 seconds]
lumm_ is now known as lumm
igemnace has quit [Remote host closed the connection]
random-nick has joined #lisp
Murii_ has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
nowhere_man has joined #lisp
Arcaelyx has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
warweasle_ has joined #lisp
warweasle__ has quit [Ping timeout: 256 seconds]
nowhere_man has quit [Ping timeout: 240 seconds]
andrei-n has quit [Ping timeout: 264 seconds]
_whitelogger has joined #lisp
shka_ has quit [Ping timeout: 260 seconds]
TRS-80 has quit [Ping timeout: 240 seconds]
warweasle_ has quit [Read error: Connection reset by peer]
warweasle__ has joined #lisp
warweasle__ has quit [Read error: Connection reset by peer]
warweasle__ has joined #lisp
karlosz has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
housel has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 240 seconds]
scymtym has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
EvW has quit [Ping timeout: 265 seconds]
warweasle__ has quit [Read error: Connection reset by peer]
warweasle has joined #lisp
karlosz has quit [Quit: karlosz]
terpri has quit [Ping timeout: 260 seconds]
<beach>
jasom: I think I understand.
karlosz has joined #lisp
TRS-80 has joined #lisp
hvxgr has quit [Quit: leaving]
anewuser has quit [Ping timeout: 256 seconds]
ym has joined #lisp
quazimodo has quit [Ping timeout: 248 seconds]
anewuser has joined #lisp
EvW1 has joined #lisp
quazimodo has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
warweasle has quit [Read error: Connection reset by peer]
warweasle has joined #lisp
EvW1 has quit [Remote host closed the connection]
karlosz has quit [Ping timeout: 240 seconds]
pierpal has quit [Remote host closed the connection]
TRS-80 has quit [Ping timeout: 248 seconds]
angavrilov has quit [Remote host closed the connection]
warweasle has quit [Read error: Connection reset by peer]
warweasle has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
rawste has quit [Quit: Quit...]
vlatkoB_ has quit [Remote host closed the connection]
k4rtik has joined #lisp
warweasle has quit [Read error: Connection reset by peer]
warweasle has joined #lisp
<stacksmith>
Good morning. Is there some hook in the pretty-printer to track its progress across the list being printed? For instance to know what object is printed on a fresh line, etc.
warweasle has quit [Read error: Connection reset by peer]
warweasle_ has joined #lisp
xaotuk has joined #lisp
hvxgr has joined #lisp
dddddd has quit [Ping timeout: 240 seconds]
Murii_ has quit [Remote host closed the connection]
pierpa has joined #lisp
milanj has joined #lisp
test1600 has joined #lisp
k4rtik has quit [Ping timeout: 240 seconds]
k4rtik has joined #lisp
k4rtik has quit [Changing host]
k4rtik has joined #lisp
test1600 has quit [Client Quit]
dddddd has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
housel has joined #lisp
warweasle_ has quit [Read error: Connection reset by peer]
mooshmoosh has quit [Read error: Connection reset by peer]
warweasle_ has joined #lisp
mooshmoosh has joined #lisp
karlosz has joined #lisp
jfb4 has joined #lisp
LiamH has quit [Quit: Leaving.]
Bike has quit [Ping timeout: 252 seconds]
lumm has quit [Ping timeout: 240 seconds]
warweasle_ has quit [Read error: Connection reset by peer]
warweasle has joined #lisp
karlosz has quit [Ping timeout: 264 seconds]
xrash has joined #lisp
warweasle has quit [Client Quit]
xaotuk has quit [Ping timeout: 268 seconds]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pjb` is now known as pjb
k4rtik has quit [Ping timeout: 240 seconds]
Ven`` has joined #lisp
pjb has quit [Ping timeout: 240 seconds]
Ven`` has quit [Client Quit]
karlosz has joined #lisp
pagnol has joined #lisp
pjb has joined #lisp
pjb is now known as Guest69217
Bike has joined #lisp
Smokitch has quit []
karlosz has quit [Ping timeout: 264 seconds]
hhdave has joined #lisp
Guest69217 has quit [Ping timeout: 256 seconds]
karlosz has joined #lisp
Jesin has joined #lisp
k4rtik has joined #lisp
shifty has joined #lisp
Guest69217 has joined #lisp
zooey has quit [Ping timeout: 250 seconds]
random-nick has quit [Read error: Connection reset by peer]
Guest69217 has quit [Ping timeout: 256 seconds]
hhdave has quit [Ping timeout: 264 seconds]
terpri has joined #lisp
sjl_ has quit [Quit: WeeChat 2.2-dev]
zooey has joined #lisp
blackwolf has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
karlosz has quit [Quit: karlosz]
sjl has quit [Ping timeout: 240 seconds]
terpri has quit [Ping timeout: 264 seconds]
Guest69217 has joined #lisp
k4rtik has quit [Ping timeout: 265 seconds]
mejja has quit [Quit: mejja]
Guest69217 has quit [Ping timeout: 256 seconds]
Guest69217 has joined #lisp
jasmith has joined #lisp
housel has quit [Remote host closed the connection]
Guest69217 has quit [Remote host closed the connection]
pagnol has quit [Ping timeout: 268 seconds]
Guest69217 has joined #lisp
caltelt_ has joined #lisp
Guest69217 has quit [Remote host closed the connection]
caltelt_ has quit [Ping timeout: 240 seconds]
brettgilio has joined #lisp
shifty has quit [Ping timeout: 244 seconds]
Guest69217 has joined #lisp
nirved has quit [Ping timeout: 255 seconds]
Jesin has quit [Quit: Leaving]
mange has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
Khisanth has quit [Ping timeout: 248 seconds]
housel has joined #lisp
cods has quit [Ping timeout: 240 seconds]
<pillton>
You could use the pretty print dispatch tables.
<pillton>
It won't tell you what object is printed on a fresh line, but you could possibly use a custom stream and an entry in the dispatch table to get that information.
<pillton>
What do you need the information for?
Guest69217 has quit [Ping timeout: 265 seconds]
TRS-80 has joined #lisp
Khisanth has joined #lisp
Guest69217 has joined #lisp
xuxuru has quit [Quit: xuxuru]
<stacksmith>
pillton: a browser/debugger of sorts. I would love to not reinvent the wheel with layout/indentation but have some idea about where things wind up.
caltelt has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
<pillton>
You might get ideas from the SLIME inspector.
<stacksmith>
Yeah, that's my next stop.
Guest69217 has quit [Ping timeout: 276 seconds]
TRS-80 has quit [Quit: WeeChat 1.6]
kerframil has joined #lisp
kozy has quit [Remote host closed the connection]
robotoad has joined #lisp
Kaisyu has joined #lisp
Josh_2 has joined #lisp
sjl has joined #lisp
xuxuru has joined #lisp
kozy has joined #lisp
BitPuffin has quit [Remote host closed the connection]