comborico1611 has quit [Quit: Konversation terminated!]
fikka has joined #lisp
bbobb has quit [Ping timeout: 256 seconds]
eli_oat has joined #lisp
Mutex7 has quit [Remote host closed the connection]
eli_oat has quit [Quit: Leaving.]
logicmoo is now known as dmiles
innovati has joined #lisp
tomsen has quit [Ping timeout: 240 seconds]
vhost- has quit [Ping timeout: 276 seconds]
terpri has quit [Ping timeout: 240 seconds]
terpri has joined #lisp
siraben has joined #lisp
grand-beginner-t has joined #lisp
tomsen has joined #lisp
vhost- has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
daniel-s has joined #lisp
fikka has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fyodost has joined #lisp
DataLinkDroid has joined #lisp
<skeuomorf>
PuercoPop: Is there a way to get the generated page title in coleslaw to be == post title?
TCZ has joined #lisp
<grand-beginner-t>
I've been pondering lisp OS's (and smalltalk/forth, et al.). I suppose the biggest issue in writing one would be the drivers and interrupt mechanics (maybe GC doesn't mix too well with these things, I'm not qualified to make an assertion). Any thoughts or comments? Thought it might be an interesting discussion.
<Fare>
grand-beginner-t, Rust
<Fare>
With a proper type system (see also prescheme), you can write the low-level parts in Lisp.
<skeuomorf>
grand-beginner-t: I remember hearing Gerry Sussman a while back complaining explicitly about writing drivers in functional languages and how much of a challenge it is :)
<grand-beginner-t>
I understand that a DSL could be written that acts similarly to C or Rust, but I'm referring to the nature of the OS itself - being object-based and similar to a smalltalk environment
<grand-beginner-t>
or emacs-based, etc.
<skeuomorf>
Hey jackdaniel, do you happen to know if there is a way to get the generated
<skeuomorf>
page title in coleslaw to be == post title?
<skeuomorf>
03:02 *** TCZ JOIN
<skeuomorf>
Gee, thanks emacs!
<TCZ>
yes i join its true
<TCZ>
o.O
stnutt has quit [Ping timeout: 260 seconds]
<grand-beginner-t>
I think my question (and the direction of my thought) may not actually make proper sense.
<skeuomorf>
Hey jackdaniel, do you happen to know if there is a way to get the generated page title in Coleslaw to be == post title?
<TCZ>
i used irc in emacs once and i spammed channel with some stupid shortcut
<skeuomorf>
TCZ: haha
<eschatologist>
grand-beginner-t: if you’re thinking about Lisp operating systems, first look at Mezzano and read the Symbolics Genera and TI Explorer documentation
<grand-beginner-t>
Ah I've heard of mezzano, I'll read up on the latters though
<eschatologist>
You can also read the code for Smalltalk-80 and its successors, which run on a variety of hardware.
<eschatologist>
Do not expect to find a UNIX-like OS model.
<grand-beginner-t>
I won't
<eschatologist>
And GC isn’t nearly the big deal people seem to think it is.
<eschatologist>
Oh no, there has to be some wiring of memory and locking of accesses in drivers, just like in every operating system!
<grand-beginner-t>
I think technically unix does "gc" as well when processes are destroyed.
<eschatologist>
Not all that similar except at the very highest levels.
<grand-beginner-t>
From a high-level perspective lol.
<grand-beginner-t>
Yes
<grand-beginner-t>
This isn't entirely lisp oriented but has anyone read of COS? It's an object system with dynamic, multiple dispatch copying CLOS but for C.
foojin has quit [Quit: leaving]
<skeuomorf>
When using slime, it keeps idling showing me
<skeuomorf>
continuing to work, repeatedly, what's up?
<skeuomorf>
arguments: (0 . 1), 2" in the minibuffer then
<skeuomorf>
"error in process filter: Wrong number of
<skeuomorf>
When using slime, it keeps idling show me "error in process filter: wrong number of arguments: (0 . 1), 2" in the minibuffer then continuing to work repeatedly, what's up with that?
skeuomorf has quit [Read error: Connection reset by peer]
skeuomorf has joined #lisp
<White_Flame>
do you have a slime version mismatch on startup?
<White_Flame>
the emacs-loaded slime code and the lisp-loaded swank server can get out of date with each other depending on what you update when
<skeuomorf>
White_Flame: nope, I don't get mismatch on startup
<Bike>
you could try toggle-debug-on-error and have a fun time debugging
<skeuomorf>
Bike: It doesn't error out, it's just a message that appears in the minibuffer while causing slime to idle for a bit
<Bike>
yeah, it should just print a backtrace and stuff when the error's signaled, even if it's handled later
<Bike>
worked when i hit a different error in process filter
grand-beginner-t has quit []
fisxoj has quit [Quit: fisxoj]
<skeuomorf>
Bike: Well, I tried, I enabled `slime-toggle-debug-on-swank-error`, didn't do anything
<Bike>
weird
d4ryus1 has joined #lisp
mooog has left #lisp [#lisp]
mooog has joined #lisp
mooog has left #lisp [#lisp]
jameser has joined #lisp
d4ryus has quit [Ping timeout: 260 seconds]
karlosz has quit [Quit: karlosz]
eli_oat has joined #lisp
Arcaelyx has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
vhost- has quit [Ping timeout: 248 seconds]
Arcaelyx has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
energizer has quit [Remote host closed the connection]
energizer has joined #lisp
jfrancis_ has quit [Remote host closed the connection]
vhost- has joined #lisp
jfrancis has joined #lisp
eli_oat has quit [Quit: Leaving.]
xrash has quit [Remote host closed the connection]
tomsen has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
dented42 has joined #lisp
eli_oat has joined #lisp
damke has joined #lisp
emaczen has quit [Read error: Connection reset by peer]
eli_oat has quit [Client Quit]
jfrancis has quit [Remote host closed the connection]
jfrancis has joined #lisp
TCZ has quit [Quit: Leaving]
damke_ has joined #lisp
skeuomorf has quit [Remote host closed the connection]
damke has quit [Ping timeout: 244 seconds]
willmichael has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
surya has quit [Ping timeout: 276 seconds]
smurfrobot has quit [Remote host closed the connection]
<fiddlerwoaroof>
skeuomorf: you have to have the git version of slime for that error
<fiddlerwoaroof>
Are you using emacs 26? some of emacs's apis changed and the relevant slime changes are not released yet.
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
deng_cn has quit [Quit: deng_cn]
kmurphy4 has quit [Quit: kmurphy4]
quazimodo has joined #lisp
EvW has joined #lisp
robotoad has quit [Quit: robotoad]
energizer has quit [Quit: Leaving]
tomsen has joined #lisp
figurehe4d has joined #lisp
kmurphy4 has joined #lisp
smurfrobot has joined #lisp
AetherWind has joined #lisp
smurfrobot has quit [Remote host closed the connection]
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
jfrancis has quit [Remote host closed the connection]
jfrancis has joined #lisp
igemnace has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
innovati has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
karlosz has joined #lisp
BillyZane has quit [Ping timeout: 256 seconds]
Nilby has quit [Read error: Connection reset by peer]
robotoad has joined #lisp
smurfrobot has joined #lisp
kmurphy4 has quit [Quit: kmurphy4]
fikka has quit [Ping timeout: 240 seconds]
<beach>
Good morning everyone!
Bike has quit [Quit: Lost terminal]
smurfrobot has quit [Remote host closed the connection]
fikka has joined #lisp
<Fare>
Bonjour!
<Fare>
are you in France? It's very early there!
<beach>
Not that early. 5am.
<beach>
Waking up early is a genetic defect in my family.
smurfrobot has joined #lisp
tomsen has quit [Ping timeout: 256 seconds]
robotoad has quit [Quit: robotoad]
smurfrobot has quit [Remote host closed the connection]
tomsen has joined #lisp
schoppenhauer has quit [Ping timeout: 248 seconds]
schoppenhauer has joined #lisp
robotoad has joined #lisp
Fare has quit [Ping timeout: 248 seconds]
aindilis has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
Nilby has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
parjanya has joined #lisp
parjanya has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
smurfrobot has quit [Ping timeout: 256 seconds]
devon has quit [Ping timeout: 248 seconds]
nickenchuggets has quit [Read error: Connection reset by peer]
Lord_Nightmare has quit [Ping timeout: 244 seconds]
Lord_Nightmare2 is now known as Lord_Nightmare
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
mflem has quit [Read error: Connection reset by peer]
Ven`` has quit [Read error: Connection reset by peer]
tomsen has quit [Ping timeout: 260 seconds]
Ven`` has joined #lisp
<beach>
merskiasa: Are you planning to offer such a person some money?
<merskiasa>
beach, yes
<merskiasa>
The thing has four modes: 1) solve, 2) quantified solve, 3) calculation and 4) prove.
<merskiasa>
1) solve and 4) prove are basically identical, because they differ only in predicate to prove (equality for solve and arbitrary comparison for prove). Prove needs a way to interpret results
<merskiasa>
I know how to formulate problem in CNF/BDD form. I also know how to use SAT solver. I haven't implemented interpretation of unsatisfability results.
<merskiasa>
beach, you interested in the project?
<beach>
Nope. Sorry.
earl-ducaine has quit [Quit: No Ping reply in 180 seconds.]
earl-ducaine has joined #lisp
smurfrobot has quit [Ping timeout: 244 seconds]
<siraben>
brb restarting erc
siraben has quit [Remote host closed the connection]
skeuomorf has joined #lisp
siraben has joined #lisp
shka_ has joined #lisp
flamebeard has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 244 seconds]
skeuomorf has quit [Remote host closed the connection]
milanj has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
flamebeard has quit [Remote host closed the connection]
pierpal has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
muresanvlad__ has quit [Read error: Connection reset by peer]
flamebeard has joined #lisp
skeuomorf has joined #lisp
varjag has joined #lisp
orivej has joined #lisp
xaotuk has quit [Ping timeout: 260 seconds]
aindilis has quit [Read error: Connection reset by peer]
wigust has joined #lisp
<merskiasa>
Anyone want to work on the project with me?
<beach>
merskiasa: It's a bit far from the interests of most #lisp participants.
siraben has quit [Remote host closed the connection]
smurfrobot has joined #lisp
<shka_>
not enough detail
<shka_>
s
beizhia has quit [Ping timeout: 240 seconds]
<merskiasa>
shka_, How so? What would you like to know?
siraben has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
Murii has joined #lisp
aindilis has joined #lisp
EvW has joined #lisp
energizer has quit [Quit: Leaving]
trittweiler_ has joined #lisp
smurfrobot has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
Lord_Nightmare2 has joined #lisp
loli1 has quit [Ping timeout: 256 seconds]
damke has joined #lisp
atchoum has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Ping timeout: 268 seconds]
Lord_Nightmare has quit [Ping timeout: 276 seconds]
Lord_Nightmare2 is now known as Lord_Nightmare
damke_ has quit [Ping timeout: 244 seconds]
makomo has quit [Ping timeout: 256 seconds]
msb has quit [Ping timeout: 268 seconds]
Lord_Nightmare2 has joined #lisp
lumm has quit [Quit: lumm]
msb has joined #lisp
Lord_Nightmare has quit [Ping timeout: 276 seconds]
Lord_Nightmare2 is now known as Lord_Nightmare
EvW1 has joined #lisp
elfmacs has quit [Quit: WeeChat 2.1]
hhdave has joined #lisp
EvW1 has quit [Ping timeout: 248 seconds]
shrdlu68 has quit [Ping timeout: 260 seconds]
Lord_Nightmare2 has joined #lisp
makomo has joined #lisp
loli1 has joined #lisp
hhdave has quit [Ping timeout: 240 seconds]
Lord_Nightmare has quit [Ping timeout: 248 seconds]
Lord_Nightmare2 is now known as Lord_Nightmare
MichaelRaskin has quit [Quit: MichaelRaskin]
<merskiasa>
shka_, ??
bjorkintosh has quit [Remote host closed the connection]
<beach>
merskiasa: I suspect shka_ would not be interested anyway, but I might be wrong.
<shka_>
beach: busy with my own stuff, but merskiasa didn't even said what the heck he is doing
damke_ has joined #lisp
pierpal has joined #lisp
damke has quit [Ping timeout: 244 seconds]
pierpal has quit [Read error: Connection reset by peer]
sjl_ has joined #lisp
sjl has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
hhdave has joined #lisp
wigust- has joined #lisp
shrdlu68 has joined #lisp
pierpal has quit [Ping timeout: 244 seconds]
<skeuomorf>
PuercoPop: Here?
wigust has quit [Ping timeout: 256 seconds]
loli1 has quit [Ping timeout: 244 seconds]
smurfrobot has joined #lisp
Lord_Nightmare has quit [Ping timeout: 245 seconds]
smurfrobot has quit [Ping timeout: 260 seconds]
Lord_Nightmare has joined #lisp
charh has quit [Ping timeout: 260 seconds]
azimut has quit [Ping timeout: 245 seconds]
charh has joined #lisp
azimut has joined #lisp
addsub has joined #lisp
<addsub>
greets, I can't find lisp games channel
<addsub>
anybody happen to know whereis at.
<White_Flame>
it's hidden in the cryptically named #lispgames
<xificurC>
White_Flame: a good lisper writes lisp-games
<addsub>
:D
<p_l>
an old lisper writes lspgms
<shrdlu68>
sacrilege
<White_Flame>
and older lisper writes LISP games
<p_l>
no, no, you see, the symbol had to fit in 36bits, so case is irrelevant but only 6 letters ;)
<p_l>
how do you think RPLACA happened? :D
pierpal has joined #lisp
<TMA>
it is for similar reasons the unix syscall is called creat
damke has joined #lisp
<p_l>
think so
<p_l>
it's definitely the reason for Pascal function names
damke_ has quit [Read error: Connection reset by peer]
<p_l>
(and case insensitivity - 60bit symbols in Pascals case)
<merskiasa>
<merskiasa> The thing has four modes: 1) solve, 2) quantified solve, 3) calculation and 4) prove.
<merskiasa>
<merskiasa> 1) solve and 4) prove are basically identical, because they differ only in predicate to prove (equality for solve and arbitrary comparison for prove). Prove needs a way to interpret results
<merskiasa>
<merskiasa> I know how to formulate problem in CNF/BDD form. I also know how to use SAT solver. I haven't implemented interpretation of unsatisfability results.
Lord_Nightmare has quit [Ping timeout: 256 seconds]
Lord_Nightmare2 is now known as Lord_Nightmare
<beach>
shka_: Did you wake up on the wrong side of the bed this morning?
<shka_>
eh, kinda
<shka_>
i have a bit of personal issues at the moment
<beach>
Sorry to hear that.
<shka_>
no worries, i shouldn't be a asshole for sure
<merskiasa>
:/
<shrdlu68>
Sounds interesting, but a little too involved to just casually waddle into for me.
devon has joined #lisp
<shka_>
merskiasa: maybe you can simplify the problem by using prolog?
<shka_>
sorry, i need to restart my machine
shka_ has quit [Quit: Konversation terminated!]
_cosmonaut_ has joined #lisp
Lord_Nightmare has quit [Ping timeout: 255 seconds]
Lord_Nightmare2 has joined #lisp
Lord_Nightmare2 is now known as Lord_Nightmare
shka_ has joined #lisp
elfmacs has joined #lisp
Kevslinger has joined #lisp
elfmacs has quit [Client Quit]
elfmacs has joined #lisp
<merskiasa>
shka_, That could be possible, how exactly?
<merskiasa>
What were you thinking
<shka_>
well, you can use paip prolog
<shka_>
there is one in quicklisp already
<shka_>
it is rather messy and if i would have more time i would write my own (with thread safety and perhaps even parallel unification built in) but it should be enough for you
<shka_>
anyway
<shka_>
i have issue with (locally (defclass
skeuomorf has left #lisp ["Killed buffer"]
<shka_>
namely: defmethods complain about class not existing
<shka_>
i think i know what may be wrong
<beach>
Why would you want to wrap DEFCLASS in LOCALLY?
<shka_>
beach: to add (declare (optimize (safety 3)))
<beach>
I see.
<shka_>
well, i have no idea what is going on here
<shka_>
if i compile defclass forms independly it works
<shka_>
but when loading asdf, it starts to be problematic
<shka_>
it is almost like locally forms are skipped, and loaded at the end
fikka has quit [Ping timeout: 256 seconds]
<shka_>
beach: maybe i should simply declaim instead?
capisce has quit [Read error: Connection reset by peer]
<beach>
It ought to work, I think. What are the symptoms of the problem?
fikka has joined #lisp
<shka_>
well, i have file with few locally defclass and few methods (initialize-instance)
capisce has joined #lisp
<shka_>
when i attempt to load with quicklisp (which just calls asdf i think) it won't load because of unkown class
<shka_>
but when i load file on my own, it just works
<beach>
Yes, I think that's correct.
<beach>
The body of LOCALLY is not treated as top-level forms.
<beach>
Nope, sorry, I was wrong.
<beach>
So it should work.
<lieven>
yeah the last sentence of LOCALLY says: If a locally form is a top level form, the body forms are also processed as top level forms.
<beach>
Indeed. Just checked.
<beach>
Now, what about DEFCLASS.
<shka_>
i wonder what about (let () instead
<beach>
That's definitely not going to be top-level then.
<beach>
You are not trying to instantiate the class at compile time, are you?
<lieven>
defclass is used as an example in the ISSUE about locally and I see no reason why it shouldn't work
<lieven>
also 3.2.3.1.1 mentions it
foojin has joined #lisp
<shka_>
beach: actually i do, but it looks like separate problem
<shka_>
or not
<shka_>
added eval-always and it works?
<shka_>
what the heck
jsjolen has joined #lisp
<shka_>
maybe i misread error message
damke has quit [Ping timeout: 244 seconds]
<shka_>
yes
<shka_>
beach: ok, got it
<shka_>
thanks for help
damke has joined #lisp
pierpal has quit [Ping timeout: 244 seconds]
bjorkintosh has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
AetherWind has quit [Quit: Leaving]
Kaisyu has quit [Quit: Connection closed for inactivity]
fikka has joined #lisp
terpri has quit [Ping timeout: 244 seconds]
<theemacsshibe[m]>
How
<theemacsshibe[m]>
Phone messed up. Hi.
<shka_>
theemacsshibe[m]: hello
<shka_>
beach: fixed, i wanted to clever and extracted list of slots during macroexpand
fikka has quit [Ping timeout: 248 seconds]
<shka_>
not a great idea i gess
Folkol has joined #lisp
<p_l>
hmm, is there a list somewhere of what is included in Allegro Free Edition and what isn't?
jsjolen has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
fikka has joined #lisp
damke has quit [Ping timeout: 244 seconds]
<beach>
shka_: Yeah, that is problematic.
<shka_>
well, fixed
<beach>
Congratulations!
<shka_>
but i will have to give accessors manually
<shka_>
which is semi-annoying
damke has joined #lisp
smurfrobot has joined #lisp
johnvonneumann_ has joined #lisp
margeas has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 256 seconds]
Guest49652 has quit [Ping timeout: 268 seconds]
margeas is now known as markong
markong is now known as markoong
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 244 seconds]
tomsen has joined #lisp
makomo has quit [Ping timeout: 245 seconds]
Arcaelyx_ has joined #lisp
Arcaelyx has quit [Ping timeout: 240 seconds]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
TCZ has joined #lisp
smurfrobot has joined #lisp
damke_ has joined #lisp
smurfrobot has quit [Remote host closed the connection]
damke has quit [Ping timeout: 244 seconds]
andrei-n has joined #lisp
xaotuk has joined #lisp
tomsen has quit [Ping timeout: 244 seconds]
johnvonneumann_ has quit [Read error: Connection reset by peer]
johnvonneumann_ has joined #lisp
Arcaelyx_ has quit [Read error: Connection reset by peer]
quazimodo has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
_cosmonaut_ has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
isBEKaml has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
fikka has quit [Ping timeout: 240 seconds]
makomo has joined #lisp
Arcaelyx has joined #lisp
fikka has joined #lisp
xaotuk has quit [Ping timeout: 276 seconds]
jmercouris has joined #lisp
_cosmonaut_ has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
skeuomorf has joined #lisp
pfdietz has quit []
tomsen has joined #lisp
zaquest has quit [Remote host closed the connection]
zaquest has joined #lisp
smurfrobot has quit [Remote host closed the connection]
terpri has joined #lisp
tomsen has quit [Ping timeout: 240 seconds]
kini has quit [Quit: No Ping reply in 180 seconds.]
jfrancis has quit [Remote host closed the connection]
jfrancis has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
fikka has joined #lisp
jfrancis has quit [Ping timeout: 256 seconds]
kini has joined #lisp
Bike has joined #lisp
FreeBirdLjj has joined #lisp
jfrancis has joined #lisp
igemnace has joined #lisp
Kevslinger has joined #lisp
igemnace has quit [Remote host closed the connection]
warweasle has joined #lisp
FreeBirdLjj has quit [Ping timeout: 244 seconds]
jfrancis has quit [Ping timeout: 256 seconds]
figurehe4d has quit [Ping timeout: 256 seconds]
jfrancis has joined #lisp
TCZ has quit [Quit: Leaving]
Ven`` has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
jfrancis has quit [Ping timeout: 276 seconds]
devon has quit [Ping timeout: 240 seconds]
pierpal has quit [Ping timeout: 240 seconds]
Folkol has quit [Ping timeout: 268 seconds]
dddddd has joined #lisp
bbobb has quit [Ping timeout: 256 seconds]
pierpal has joined #lisp
smurfrobot has joined #lisp
Ven` has joined #lisp
Ven` has quit [Read error: Connection reset by peer]
Ven` has joined #lisp
fikka has joined #lisp
Ven`` has quit [Ping timeout: 256 seconds]
jeosol has quit [Quit: Page closed]
fikka has quit [Ping timeout: 240 seconds]
Fare has joined #lisp
__rumbler31 has joined #lisp
LiamH has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 244 seconds]
TCZ has joined #lisp
fikka has joined #lisp
devon has joined #lisp
TCZ has quit [Quit: Leaving]
Folkol has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
skeuomorf has quit [Ping timeout: 244 seconds]
shenghi has quit [Quit: WeeChat 2.0.1]
shenghi has joined #lisp
Ven` has quit [Read error: Connection reset by peer]
Ven`` has joined #lisp
mejja has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
devon has quit [Ping timeout: 260 seconds]
damke has quit [Ping timeout: 244 seconds]
damke has joined #lisp
cpc26 has quit [Ping timeout: 260 seconds]
EvW has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
TCZ has joined #lisp
bbobb has joined #lisp
TCZ has quit [Quit: Leaving]
skeuomorf has joined #lisp
devon has joined #lisp
jfrancis has joined #lisp
jfrancis_ has joined #lisp
smurfrobot has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
jfrancis has quit [Ping timeout: 244 seconds]
fikka has quit [Ping timeout: 255 seconds]
smurfrobot has quit [Ping timeout: 244 seconds]
_cosmonaut_1 has joined #lisp
wheelsucker has joined #lisp
Ven`` has joined #lisp
pierpal has joined #lisp
siraben has quit [Read error: Connection reset by peer]
_cosmonaut_ has quit [Ping timeout: 240 seconds]
siraben has joined #lisp
jfrancis_ has quit [Remote host closed the connection]
jfrancis has joined #lisp
smurfrobot has joined #lisp
sjl has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
jfrancis has quit [Ping timeout: 240 seconds]
s0lar_ has joined #lisp
smurfrobot has quit [Ping timeout: 244 seconds]
BitPuffin has joined #lisp
Folkol has quit [Ping timeout: 256 seconds]
skeuomorf has quit [Ping timeout: 260 seconds]
BepBep has joined #lisp
<BepBep>
Anyone have an opinion on using TXR or Guile for scripting?
stnutt has joined #lisp
pierpal has joined #lisp
<edgar-rft>
BepBep, we of course suggest using Common Lisp instead :-)
<dlowe>
The "any lisp goes" channel is ##lisp
pierpal has quit [Ping timeout: 244 seconds]
SenasOzys has joined #lisp
<beach>
BepBep: In other words, this channel is dedicated to Common Lisp.
<beach>
BepBep: Choice 1: Write your entire application in Common Lisp. Choice 2 (if you already have an application written in some static language): Use ECL.
SenasOzys has quit [Remote host closed the connection]
<Xach>
I have a long-running interest in exposing cl-js as a scripting system for a Common Lisp application
<beach>
Xach: What makes you need anything other than Common Lisp itself?
<shka_>
that's… weird
<BepBep>
beach: I'm looking to run one-liners in the shell mostly. Do you think that's do-able with any implementations?
<shka_>
only issue i see is that it is difficult to sandbox lisp code in existing implementations
pierpal has joined #lisp
<beach>
BepBep: Oh, so you don't mean adding a dynamic language to an existing application written in some static language? In that case, I have no advice for you. Maybe someone else knows more. But again, this is a Common Lisp channel, so you will get biased answers.
fikka has joined #lisp
<BepBep>
beach: all my static applications are already written in Common Lisp. I'd just script it with it like a sane person if that were the case.
surya has joined #lisp
<beach>
BepBep: I think we must be talking past each other.
<dlowe>
BepBep: sbcl has a --script option that can be used with #!
<dlowe>
and it will behave sensibly in a unix environment
smurfrobot has joined #lisp
sjl_ has quit [Quit: WeeChat 2.1]
varjagg has joined #lisp
zazzerino has joined #lisp
<Fare>
or #!/usr/bin/cl-launch keeps it portable.
lumm has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
<dlowe>
portable to computers with cl-launch installed
<Fare>
some computers have cl-launch but no sbcl
<Fare>
and/or you may prefer a different implementation
pierpal has quit [Ping timeout: 248 seconds]
<Fare>
or may want to switch implementation depending on being on one platform or the other.
rpg has joined #lisp
daniel-s has quit [Remote host closed the connection]
rippa has joined #lisp
BepBep has quit [Quit: WeeChat 2.1]
flamebeard has quit []
lumm has quit [Remote host closed the connection]
shrdlu68 has quit [Ping timeout: 256 seconds]
lumm has joined #lisp
nsrahmad has joined #lisp
nowhere_man has quit [Ping timeout: 240 seconds]
varjagg has quit [Ping timeout: 276 seconds]
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Ven`` has quit [Read error: Connection reset by peer]
<beach>
So I guess I have the wrong idea about what "scripting" means?
lumm has quit [Ping timeout: 260 seconds]
Ven`` has joined #lisp
<dlowe>
For me, scripting means "simulating the actions that a user would take"
Krenium has quit [Ping timeout: 276 seconds]
<beach>
Oh!
<dlowe>
It's a fuzzy term, and my definition is obviously not authoritative, but it seems to cover most of the de facto uses
<beach>
I thought it meant "a user adding functionality to an existing application through the use of some dynamic language"
<dlowe>
well, if you are performing actions with this dynamic language that a user could perform through the ui, that's scripting
devon has quit [Ping timeout: 244 seconds]
<dlowe>
if you are adding capabilities that are not available through the ui, that's usually called a plugin
<dlowe>
"scripting" is also short for "shell scripting" though
<beach>
I see.
<beach>
Wikipedia seems to be using "extension language" for what I was describing.
<jmercouris>
I think scripting language is ambiguous
<jmercouris>
but basically people just use it as a way to allow users to extend an application
<jmercouris>
it's like an API/language for the end user of an application
<jmercouris>
that is how I think of them
<beach>
The way I have seen "plugin" used is for modules that are written in the same (static) language as the main language of the application, but that are compiled and then loaded through some dynamic-linking mechanism. I guess I need to get my terminology right, or at least clear.
<beach>
jmercouris: yes, that's how I have been using it.
<jmercouris>
It's not that you need to get your terminology right, it is rather that there is no terminology
<jmercouris>
at least no consistent application of it
<jmercouris>
beach: I think you are right in thinking of it that way
<jmercouris>
the problem is when people start to say stuff like "javascript is a scripting language"
<beach>
Then I must make sure I express my self in a way that it unambiguous to my audience.
<jmercouris>
what would that even mean??
<jmercouris>
what makes a language a scripting language vs a non-scripting language?
<beach>
Right, as my slides explain, "scripting language" does not mean much.
<jmercouris>
javascript outside of the browser, aka node.js is a full blow language
<jmercouris>
s/blow/blown
fikka has quit [Ping timeout: 240 seconds]
<jmercouris>
yeah, I think best to avoid these terms, as they mean many things to different people
<beach>
Anyway, thanks. I should be more careful.
<dlowe>
yeah, there's no consistent terminology
<dlowe>
but as long as everyone knows it, I think it's okay to be vaguely hand-wavey
<beach>
True. But when I give a talk to industry, there is little feedback, so it is best to be clear.
<Fare>
I argued at some previous ELS that the important part of "scripting language" was "low overhead computing".
<dlowe>
a "scripting language" is a language that is good for, or often used to, simulate a user's actions
<Fare>
i.e. with minimal overhead (e.g. #!/usr/bin/cl ) you can write code that will run and do what you want.
<dlowe>
clearly there's transition between doing things to 10 things and doing things to 1,000,000
<jmercouris>
Fare: you have something like /usr/bin/cl on your machine?
<beach>
Fare: So you assume an environment that is basically hostile to Common Lisp?
<Fare>
as opposed to the complex ceremony you need to get anything to run with a C program
<Fare>
jmercouris, apt install cl-launch
<beach>
Fare: Otherwise, just typing the Common Lisp form would be low overhead.
<jmercouris>
Fare: I'm not running Ubuntu/Debian
<Fare>
beach: cl -iw '(+ 1 1)'
<Fare>
jmercouris, what are you using?
<jmercouris>
I guess I could do /opt/local/bin/sbcl...
<jmercouris>
Fare: I am using MacOS and FreeBSD
<jmercouris>
I use Mac for my Laptop, and FreeBSD for deployment
<Fare>
I'm not sure whether cl-launch has been packaged for either, but it will run.
wheelsucker has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
wheelsucker has joined #lisp
lumm has joined #lisp
terpri has quit [Ping timeout: 260 seconds]
jfrancis has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fisxoj has joined #lisp
fikka has joined #lisp
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<Xach>
beach: for other people, not me
<beach>
I see.
smurfrobot has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
EvW has quit [Ping timeout: 255 seconds]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
jfrancis_ has joined #lisp
innovati has quit [Ping timeout: 260 seconds]
jfrancis has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
innovati has joined #lisp
fikka has joined #lisp
damke_ has joined #lisp
damke has quit [Ping timeout: 244 seconds]
_cosmonaut_1 has quit [Ping timeout: 268 seconds]
smurfrobot has joined #lisp
nickenchuggets has joined #lisp
damke_ has quit [Ping timeout: 244 seconds]
fikka has quit [Ping timeout: 268 seconds]
rpg has joined #lisp
cage_ has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
jmercouris has quit [Ping timeout: 268 seconds]
jmercouris has joined #lisp
elfmacs has quit [Ping timeout: 248 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
fikka has joined #lisp
TCZ has joined #lisp
lnostdal has quit [Ping timeout: 268 seconds]
FreeBirdLjj has joined #lisp
comborico1611 has joined #lisp
pierpal has joined #lisp
hhdave has quit [Ping timeout: 256 seconds]
pjb has joined #lisp
jeosol has joined #lisp
pierpal has quit [Ping timeout: 244 seconds]
<p_l>
beach: well, environment that is accessible... For LispM the equivalent would be to write some utility functions and (on symbolics only) a Command Processor applet
nsrahmad has quit [Quit: Leaving]
cage_ has quit [Read error: Connection reset by peer]
cage_ has joined #lisp
mflem has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
siraben` has joined #lisp
siraben has quit [Ping timeout: 244 seconds]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
cage__ has joined #lisp
cage_ has quit [Read error: Connection reset by peer]
smurfrobot has quit [Ping timeout: 244 seconds]
<edgar-rft>
AFAK in the old times "scripting" had something to do with a chisel and stone
fisxoj has quit [Quit: fisxoj]
<aeth>
I think a lot of people think that there are two kinds of languages, "systems languages" and "scripting languages", and that there is a clear line between the languages, even though these terms describe roles not languages. For instance, CL can do both. And this division makes it unclear where to place languages like Java and C#. And, of course, Wikipedia lists 5 different kinds of "scripting". https://en.wikipedia.org/wiki/Scripting_langua
<makomo>
the hardest thing in CS is naming things, that is for sure
<dlowe>
It's not a very good distinction.
<makomo>
people abuse terminology *ALL* the time, and it sucks
<makomo>
the term "interpreter" has been overloaded over a billion times
<makomo>
imo it has the same status as the term "scripting language"
<makomo>
i.e. "scripting languages use interpreters, system languages use compilers"
<makomo>
along those lines
<makomo>
systems*
<aeth>
Imo, the only reason some general purpose languages are called "scripting languages" is because their current implementations are too slow. You can obviously use any general purpose language for anything, but performance requirements might restrict your choices.
<aeth>
makomo: And, yes, I was as vague as possible but the more you add to it (and it's often things like you said), the less accurate it is.
<aeth>
The worst part is that a lot of intro textbooks have stuff like that.
smurfrobot has joined #lisp
<makomo>
yup, endless confusion :^(
<aeth>
Or they'll talk about the interpreted vs. compiled benefits and drawbacks and literally all of the benefits of "interpreted" would also apply to SBCL, which is AOT compiled.
<aeth>
In fact, SBCL does it better.
<aeth>
So if those sources are authoritative, then SBCL obsoletes all interpreters.
<dlowe>
The main benefit of "intrepreted" is that it's easy to code
skeuomorf has joined #lisp
TCZ has quit [Quit: Leaving]
<TMA>
there are several layers of meaning to 'scripting language'. without a proper clarification the term is almost but not quite useless
<dlowe>
and I'm pretty sure sbcl doesn't fall under that category
<aeth>
dlowe: Okay, you're right about that. And another one that doesn't apply to SBCL is "sandboxing".
<aeth>
dlowe: But if it's a list of 20 only those 2 won't apply to SBCL and thus are actually inherent of interpreters.
nowhere_man has joined #lisp
energizer has joined #lisp
<dlowe>
Lack of sandboxing is more a limit of the CL design.
<aeth>
(And if you want sandboxed interpreters, you're stuck with Lua or JS)
<dlowe>
It could be done.
<aeth>
cl-cl is the language of the future.
dented42 has joined #lisp
<akkad>
as a system it's fantastic, as a lisp, meh
smurfrobot has quit [Ping timeout: 248 seconds]
Khisanth has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
joast has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 248 seconds]
terpri has joined #lisp
<shka_>
beach has wonderful idea regarding first class environments
<dlowe>
first class environments + capabilities would be lovely
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<shka_>
yes, after beach explained it to me it starts to look like something truly awesome
<shka_>
not sure if it will be only in sicl or also in clasp though
<Bike>
eventually, hopefully.
<Bike>
but it has a few holes as far as sandboxing goes. that's not what beach came up with them for.
Khisanth has joined #lisp
raynold has joined #lisp
smurfrobot has joined #lisp
<jmercouris>
makomo: surely you recognize teh difference between an interpreter and a compiler right?
tomsen has joined #lisp
<jmercouris>
s/teh/the
joast has joined #lisp
<jmercouris>
a compiler produces machine code! an interpreter does not!
<dlowe>
these days even machine code is interpreted
<makomo>
well i'd like to think so, but "interpreter" is a VERY fuzzy term
<dlowe>
compiler is just a transformation between one code to another code.
<dlowe>
*compilation
<makomo>
part of the problem imo is treating "machine code" as a special kind of code
<scymtym>
Fare: and thank you for cl-launch. it is really handy
<makomo>
i.e. people make a difference between a "compiler" and a """transpiler"""
<shka_>
Bike: well, being able to actually use SICL as your lisp implementation would be cool
<shka_>
for start
<pjb>
dlowe: it's not because it's an interpreter that: 1- the language is easy to understand and program with, 2- the system provides you with a REPL and a good interactive debugger.
<makomo>
because somehow for them, a compiler between two languages, of which neither is machine code, is not a real compiler
<aeth>
makomo: "transpiler" is shorter than "source-to-source compiler" and everyone still knows what you mean
<jmercouris>
there could as well have existed an interpreter for C code...
<dlowe>
there is such a thing
<Bike>
shka_: yes
<jmercouris>
right, those REPLs right?
<makomo>
aeth: but it's not a real thing, formally it's just a compiler
<aeth>
A duck's a bird. A transpiler's a compiler.
<makomo>
what makes machine code not source code? absolutely nothing
<dlowe>
but an interpreter is also a very definite thing too
FreeBirdLjj has quit [Remote host closed the connection]
<nirved>
makomo: you make it
<aeth>
makomo: You target machine code in a different way than you target source code.
EvW has joined #lisp
FreeBirdLjj has joined #lisp
<jmercouris>
I think the distinction here is that a transpiler is not intended to produce machine code
<pjb>
makomo: Once you have an implementation of a language, (be it a compiler or an interpreter or anything else), you have a machine for that language, so programs written in that language are machine code (for that "virtual" machine).
<makomo>
jmercouris: well exactly, and from that lots of other terminology ensues
<jmercouris>
whereas a compiler is usually intended, or at least connotated with producing machine code
<makomo>
jmercouris: yes, exactly, it has the implication of producing "machine code"
<makomo>
i.e. code for a processor, a hardware device
<pjb>
Just have a look at cuda!
smurfrobot has quit [Ping timeout: 256 seconds]
<jmercouris>
well, we have to use abstractions as programmers
<jmercouris>
we should pretend that anything below the hardware level does not exist :D
<jmercouris>
at least for our sanity...
<makomo>
true, but that's how the terminology becomes fuzzy, because people use "compiler" and "interpreter" to mean a lot of things
fikka has joined #lisp
<pjb>
the abstraction is the T forms for compilers, the V forms for machines and the I form for interpreters.
* edgar-rft
interpretes everything much different than all of you
<makomo>
but formally, the processor is an interpreter for machine code, although it's implemented in hardware
<pjb>
and sometimes in "firmware".
<aeth>
makomo: Because over time interpreters look more like compilers and compilers look more like interpreters. Just like any other division in languages. Although some divisions are going away faster, like static vs. dynamic typing.
<makomo>
i guess you're referring to stuff such as microcode by that?
<nirved>
it's very simple - compiler compiles, interpreter interprets
fisxoj has joined #lisp
<nirved>
compiler outputs transformed code
<nirved>
interpreter executes code
<makomo>
the difference between the two is fine, but the meaning of "interpreter" itself is fuzzy
<jmercouris>
nirved: Damn! why didn't we think of it!
<jmercouris>
Luckily we have you to tell us about how simple it is!
<makomo>
people call main python program an interpreter, even though it does the exact same thing as java
<makomo>
it has a bytecode compiler
<makomo>
the main*
FreeBirdLjj has quit [Ping timeout: 256 seconds]
<makomo>
and then an interpreter which interprets the bytecode
<shka_>
you guys have way to much time :-)
<makomo>
they call the whole package "an interpreter"
<jmercouris>
makomo: could just be legacy
<makomo>
whatever it is, it's annoying
<nirved>
after compiling to bytecode, it is interpreted
<makomo>
same thing goes with the term "JIT"
<jmercouris>
at any rate, I'd prefer to call the JVM an interpreter
<nirved>
bytecode is not executed
<jmercouris>
rather than calling the python interpreter a PVM
<makomo>
jmercouris: JIT would like to have a word with you :-)
<jmercouris>
Well, since we are making up definitions willy nilly, anything is possible :P
cage__ has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 244 seconds]
<makomo>
i also think of it as an interpreter, because it reads the java bytecode and "executes" it
<aeth>
jmercouris: There is only one meaningful distinction in programming language design. "blub" and "Lisp"
<makomo>
i always wondered about the Blub thing, how do we know, as lispers, that lisp isn't just another blub that we can't see past :D
<aeth>
Defining Lisp is actually a pretty hard thing.
<jmercouris>
aeth: Ah yes, blubcode
<dlowe>
makomo: I think that was one of the points of the essay
<nirved>
any blub is subset of lisp
<makomo>
dlowe: i never read that out of it
<dlowe>
any actual implementation is blub compared to the platonic lisp ideal
<aeth>
dlowe: Obviously the point was that Common Lisp is yet another blub and Arc is the way forward.
<aeth>
We'll still be using Arc in 100 years.
<nirved>
since lisp is indefinitely extensible, anything else than lisp is blub
nickenchuggets has quit [Read error: Connection reset by peer]
<makomo>
dlowe: actual implementation of lisp?
<dlowe>
aeth: I believe that was one of the points
cage_ has joined #lisp
<jmercouris>
I believe we should be programming in assembly, it places no limits on the programmer
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
<jmercouris>
Alright, I'm done :D
<aeth>
jmercouris: (1) express assembly in s-expression form, (2) enjoy your real macros
<makomo>
lol
<aeth>
You can probably build the rest as needed
<jmercouris>
aeth: I mean, I don't see why not
<dlowe>
I had that idea and it turns out that assemblers are actually annoyingly large and complicated.
<makomo>
well, it's interesting to note that machine code is homoiconic as well
<jmercouris>
I guess we could right our own assembly language
<aeth>
Imagine a language that was literally just Lisp macros on asm.
<jmercouris>
s/right/write
<jmercouris>
man I am tired
<dlowe>
aeth: ^
<aeth>
dlowe: Then get some sleep
<jmercouris>
yeah dlowe, get some sleep :P
<dlowe>
har har
ZombieChicken has joined #lisp
<Xach>
aeth: RPW used to go on and on about BLISS-II
al-damiri has joined #lisp
<aeth>
I think the biggest confusion in language categorization is probably dynamic vs. static typing. e.g. CL is not dynamically typed. Some implementations might be. SBCL is gradually typed, but afaik most of the error-catching benefits of static types stay within one file.
<shka_>
uhm
<shka_>
aeth: you have access to the type information in the runtime = dynamic typing
<makomo>
aeth: how is CL not dynamically typed though?
<pjb>
You cannot really say lisp is dynamically typed, opposing that with static typing, because this is not the most meaningful distinction of the lisp type system.
<aeth>
makomo: Gradual typing is combining static and dynamic typing. SBCL does this.
<pjb>
What lisp does, is to assign types to values, instead of assigning it to variables like it's done in "statically" typed languages.
<aeth>
I suppose you could say that it's *both*, though.
<shka_>
this is incorrect
Bike has left #lisp [#lisp]
Bike has joined #lisp
<Bike>
the type system does a bunch of different things that don't always cohere together. values being typed instead of variables is a pretty good start though.
<aeth>
In SBCL if you use type declarations, it does static type checking within one file or compilation unit. It then also does dynamic, runtime type checking on those type declarations unless (safety 0)
<pjb>
When you have values lost in memory, in lisp, they still have their type. The garbage collector can find them, and call their finaliser function. But in usual C implementations, if there's no variable to refer to the value, then the value is just bits, without a type, and nothing can be done with them.
<aeth>
At the very least, if you view it as dynamic xor static typing, SBCL does blur the lines, and other languages are finally catching up there, too
fikka has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Naergon has quit [Ping timeout: 260 seconds]
rpg has joined #lisp
<pjb>
I would just say that there are compilation-time analysis, local or global analysis, and there are run-time ("JIT") statistics and checks, and that you can use both to optimize the processing.
<shka_>
1+ pjb
pierpal has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
light2yellow has quit [Quit: light2yellow]
lnostdal has joined #lisp
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
lnostdal has quit [Remote host closed the connection]
pierpal has quit [Ping timeout: 256 seconds]
lnostdal has joined #lisp
mindCrime has joined #lisp
tomsen has quit [Ping timeout: 256 seconds]
pierpal has joined #lisp
<aeth>
Lisp has a different view of compilation time than most compilers. (eval-when (:compile-toplevel) (uiop:launch-program "ksudoku"))
fikka has joined #lisp
sauvin has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
jeosol has quit [Ping timeout: 260 seconds]
* edgar-rft
charges his Lisp to make some static types
vlatkoB has quit [Remote host closed the connection]
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
addsub is now known as zappan
zappan is now known as zapan
Kundry_Wag has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Remote host closed the connection]
epony has quit [Remote host closed the connection]
epony has joined #lisp
pierpal has joined #lisp
smurfrob_ has joined #lisp
d4ryus1 is now known as d4ryus
yrdz has joined #lisp
fikka has joined #lisp
smurfrob_ has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
dented42 has joined #lisp
jfrancis has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
jfrancis has quit [Ping timeout: 256 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
jfrancis has joined #lisp
jfrancis has quit [Remote host closed the connection]
jfrancis has joined #lisp
rpg has joined #lisp
isBEKaml has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 240 seconds]
yrdz has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
TCZ has joined #lisp
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
capisce has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 268 seconds]
mgsk has joined #lisp
<mgsk>
Were the ELS talks filmed this year / slash will they be available eventually?
xaotuk has joined #lisp
cage_ has quit [Quit: Leaving]
capisce has joined #lisp
<Xof>
yes
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<mgsk>
Xof: lovely. Any idea on ETA?
pierpal has quit [Quit: Poof]
innovati has joined #lisp
pierpal has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<p_l>
makomo: the problem with dynamic/static is that people mistake it for weak/strong :)
<makomo>
p_l: true, but that's an even fuzzier term :-)
<p_l>
CL is dynamic/strongly typed language. The former because of runtime type checks (with gradual static support as optimizations in compilers), the latter because it has a very strong notion of what a type is etc. (a bit too strong, in a sense, with satisfies)
figurehe4d has joined #lisp
fikka has joined #lisp
Xof has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 256 seconds]
innovati has quit [Read error: Connection reset by peer]
innovati has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
pierpa has joined #lisp
fikka has joined #lisp
Xof has joined #lisp
innovati has quit [Client Quit]
fyodost has joined #lisp
<Xof>
mgsk: none at all. (I was only a speaker, not the poor victim who has to edit the videos)
fikka has quit [Ping timeout: 256 seconds]
<aeth>
p_l: Calling CL dynamic is misleading when some compilers, perfectly permitted by the standard, do both static and dynamic, making "gradual typing" a more accurate descriptor.
<White_Flame>
"gradual" never seems right to me. Each instance is a boolean, either assuming or checking the type
<aeth>
Calling it "dynamic" implies that you can't (defun foo (x) (declare (single-float x)) ...) although, yes, that isn't entirely portable behavior because in theory some non-existent (afaik) implementation could assume types instead of either statically typing (SBCL) or ignoring the declaration (most implementations).
<aeth>
SBCL at safety 0 is a bit tricky. It assumes the types at runtime, but probably still does its limited static type checking at compile time.
<White_Flame>
why would safety 0 decrease the amount of type inference applied?
Mutex7 has joined #lisp
fikka has joined #lisp
<aeth>
I said probably because I'm not going to write a test case right now, but I'd be surprised if it removed the limited static type checking.
<White_Flame>
ah, miserad
<White_Flame>
*misread
<aeth>
White_Flame: "gradual typing" implies that you're going to start out dynamic and then gradually add static typing as your program advances. I think "mixed typing" would probably be a better name, but since dynamic/static is often confused with strong/weak, I'm sure "mixed typing" could confuse people into thinking that the language is both strongly typed in places and weakly typed in places or something.
<White_Flame>
"optional" is probably what I'd use
<White_Flame>
but again, the doesn't distinguish itself as being part of the strong/weak or static/dynamic spectrum
<p_l>
aeth: dynamic is perfectly fine with (defun foo (x) (declare (single-float x)) ...) - it just means that type check will be done at runtime
<copec>
Are there any good type abusing examples?
<aeth>
One problem with CL, though, is that :type in CLOS isn't really respected. Only CCL seems to respect it by default, although SBCL respects it with high debug values, implying that it's only useful for debugging.
<copec>
with the weak corners
fikka has quit [Ping timeout: 240 seconds]
<aeth>
Another problem with static-typing-in-CL is that there aren't typed lists (trivial to write your own with structs if you can accept a performance loss) or hash tables, and non-T arrays are very limited in what types that they can have.
<p_l>
that's so long as you keep to portable standard, yes (though lists I believe are untyped in all implementations)
<aeth>
p_l: You're incorrect about type declarations. SBCL will do the type check at compile time as well, as long as it's within the same compilation-unit. SBCL actually has typed functions, with typed parameters and a typed return value (although the latter is rarely seen).
<aeth>
It's limited, though, because the function can be recompiled at any moment to have a completely different function type so SBCL will only trust it in limited cases, most commonly when it's in the same file.
<p_l>
aeth: I'm trying to stick to what the standard says, and even on SBCL you can end up with uncompiled code trying to call the functions so unless you do (safety 0) the type check will happen
<aeth>
p_l: Yes, in SBCL it's both statically and dynamically typed when you use type declarations, unless it's safety 0. Although I would assume most gradually typed languages that come at the problem from the dynamically-typed side would behave similarly.
<White_Flame>
I'm always amused when SBCL compiles an expression it warns about to a simple call to raise an error
<pjb>
aeth: non typed lists is a good thing, trust me!
<pjb>
You'd have to see what they do in C!
<copec>
eww, typed lists
<p_l>
aeth: that's what I'm getting at. By default we get dynamic, but compilers are free to go further where possible. Meanwhile with many "statically" typed you need to write your own type checks and variant code
<aeth>
pjb: Typed collections are wonderful. You type-check on setting or initialization and you can trust the type on access, providing more information to the compiler's type inference, without having to have a fancy macro inserting THEs all over the place (which SBCL won't even trust, so you'd need truly-the for SBCL)
<aeth>
pjb: For things set rarely and accessed often, that's a major win.
fikka has joined #lisp
<White_Flame>
there's always Haskell, if you want to program in types as your primary feature
<aeth>
And you couldn't even trust a the/truly-the macro because the user somewhere else could just bypass it.
<pjb>
aeth: it's ludicruous: all the reference types, and most integer types are compiled into the same binary!
<pjb>
aeth: in anycase, you can always use libecl, or greenspun like crazy, of course. But this is not what C programmers do.
<copec>
imo going into experimental programming thinking about type is like going in thinking about optimization before you've even flushed out your idea
<pjb>
C programmers are just crazy.
<aeth>
White_Flame: I'm not sure why you'd recommend Haskell when I said "set rarely and accessed often". I think Haskell wouldn't be the ideal language for setting (i.e. mutation) because it's discouraged.
<White_Flame>
no, but it's focused on programming in types first, then adding a bit of implementation glue
dddddd has quit [Remote host closed the connection]
<copec>
^^
<White_Flame>
so it might be a good example to glean ideas form
<White_Flame>
*from
<copec>
"I don't know how the hell I'm going to do something, but heres the type?"
fikka has quit [Ping timeout: 244 seconds]
<White_Flame>
also, very few people here are as obsessed with C-style micro-optimizations
dddddd has joined #lisp
rumbler31 has quit [Ping timeout: 268 seconds]
jmercouris has quit [Ping timeout: 276 seconds]
<White_Flame>
in terms of avoiding typechecks and compiling down to exactly 1 working case
<p_l>
excuse me, we are very obsessed with optimizations, we just do it without creating crazy UB in compiler
<aeth>
p_l: You could write an entirely statically typed program in CL. Sure, the staticness wouldn't be portable, but you could probably write a portable static checker like people do for various languages that don't even have an implementation like SBCL. The define syntax would be inconvenient, but a wrapper macro on top of defun is so trivial I've probably done at least a dozen such define-foos in one program.
rumbler31 has joined #lisp
<p_l>
aeth: yep
<aeth>
You don't need something like TypeScript in CL.
<Fare>
scymtym: thanks for noticing. Why didn't gitlab.common-lisp.net warn me that the issue was open???
<p_l>
aeth: I'm actually tempted to branch out further from "keep to very simple CL" and do a lot of macrology this time, because I'm trying to write a performant Lisp Machine emulator :)
<White_Flame>
what would happen when you need to redefine something?
<aeth>
p_l: And assuming type T when no type is specified is actually the reasonable default. Why do otherwise?
<aeth>
Even statically typed languages should behave like that!
<p_l>
White_Flame: it's something I'm actually tackling recently, where I have a function that recompiles a bunch of very statically controlled stuff when I need to
<p_l>
(in my case, it involves a lot of macros iterating over objects and constructing a function from them)
figurehe4d has quit [Remote host closed the connection]
dmiles has quit [Read error: Connection reset by peer]
<White_Flame>
p_l: yeah, CL needs to move into the JIT world if further gains on speed are going to be introduced
<p_l>
White_Flame: ... umm... nope?
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<p_l>
the biggest JIT tricks are included in code generated by compilers
<White_Flame>
well, that's what you're talking about, isn't it? recompiling things if the assumptions change?
<White_Flame>
but yeah, the literal acronym "JIT" isn't sufficient to describe such optimizations. I guess "dynamic recompilation" would be a better fit
<p_l>
White_Flame: I'm essentially making macros that build functions that are then processed by macros to build an uber-function that implements the dispatch unit of a Symbolics Ivory chip
<White_Flame>
(even though that term is already taken up by emulators)
<p_l>
the function to rebuild this is going to be called manually, when I change something like adding new instruction or modifying the macros that help me build the instruction-functions
trittweiler_ has quit [Ping timeout: 260 seconds]
<scymtym>
Fare: thank you
<p_l>
that... won't be helped by "JIT" stuff
<aeth>
White_Flame: You only need JIT if you can't directly specify what you mean. That's probably why LuaJIT is such a performance win over Lua. When everything is a table, you need JIT magic to magic things into more appropriate representations.
<p_l>
White_Flame: inlining is partially what I'm going for with my crazy macros
<p_l>
but I want actual control over what's happening
lemoinem has quit [Ping timeout: 240 seconds]
<White_Flame>
yeah, that's what I'm breaking away from
<White_Flame>
"hand-holding the CPU through what it needs to do" has become my bane
andrei-n has quit [Ping timeout: 260 seconds]
<p_l>
in my case I strongly suspect I might hit timing bugs
<aeth>
White_Flame: Imo what CL's best at is this: Specify exactly what to do, in a macro, and give a high-level declarative interface. Most languages that give you the opportunity to do the latter don't give you enough control over the former.
<Fare>
scymtym, thank YOU
wigust- has quit [Ping timeout: 256 seconds]
lemoinem has joined #lisp
<White_Flame>
I want to teach it how to get things done, and how to figure out how to gain performance on its own. I've spent decades doing all that by hand, and it's a repetitive waste of time
<White_Flame>
sure, it's a fun puzzle in the beginning
<White_Flame>
but srsly, gotta actually get things done at some point
<Fare>
I see there are 5 more issues open against cl-launch :-(
<Fare>
That I didn't know about because of faulty email relay
<aeth>
White_Flame: That's what frameworks are for imo.
<White_Flame>
especially for large, complex projects, hand-tuning everything gets superlinearly burdensome
fikka has joined #lisp
<Fare>
If you have an account on gitlab.common-lisp.net, you may want to check your email setting
<White_Flame>
and that includes creating simple macros and such to help manually declare the hand-tuning
nowhere_man has quit [Ping timeout: 240 seconds]
<White_Flame>
we're supposed to be meta-programmers, just programmers!
<White_Flame>
*not just programmers!
<aeth>
White_Flame: I find it more convenient to use a define-function macro as a target for my macros, rather than directly using defun. It'll handle things like (declaim (inline foo)), type declarations, etc., and since I directly control it I can add whatever else I need.
<aeth>
I originally intended only for the highest level to use fancy macros that hide most things, but it seems to work well at most middle levels, too.
dmiles has joined #lisp
<White_Flame>
"since I directly control it", ie, you put yourself & manual effort in the critical path ;)
<aeth>
I've been aggressively reducing reptition. e.g. I wrote a with-accessors* that is just like with-accessors except (foo bar (quux baz)) becomes ((foo foo) (bar bar) (quux baz)) because it's very common for me to just name the symbol macro created by with-accessors after the accessor.
<White_Flame>
anyway, that's my personal soapbox to yell from
<aeth>
And, sure, I directly control most of these convenience macros, but most of them are trivial.
fikka has quit [Ping timeout: 256 seconds]
<aeth>
I compose quite a few trivial macros to do more elaborate things and simplify the more advanced macros.
<aeth>
Using define-function and with-accessors* gets rid of a lot of repetition in the macros. Combine the two in one macro and now I no longer have to handle type declarations directly in that macro and I don't have to have the (lambda (x) `(,x ,x)) all over my code that with-accessors (and similar interfaces) would produce
<White_Flame>
it's not about reducing repetition
<White_Flame>
it's about offloading actual autonomous programming & optimization work to the environment
<White_Flame>
ie, the machine itself makes decisions without you telling it to
EvW has quit [Ping timeout: 245 seconds]
<White_Flame>
obviously, compiler work really pushes those fields
<aeth>
That's the thing, though. This work only has to be done once, then it's a framework for someone else to use.
<White_Flame>
I'm not talking about frameworks
<aeth>
The CL community is small. That's the only reason why "doing it once" is often you doing it, and not finding a framework
<aeth>
Very few things have to be done at the implementation level.
<White_Flame>
but again, as I said, this is my soapbox. People who are working on different problems don't necessarily see the need for other people's desired solutions
smurfrobot has joined #lisp
<aeth>
White_Flame: I guess my point is that you don't have to worry about performance in CL if someone else has done that worry for you in the domain you're in. It's just that the small community means that that is unlikely.
aindilis has quit [Remote host closed the connection]
fikka has joined #lisp
zazzerino has joined #lisp
__rumbler31 has quit [Ping timeout: 244 seconds]
<p_l>
White_Flame: you might want to search for information about "Programmer's Apprentice", I believe that was the name
<White_Flame>
the domain is highly dynamic, changing assumptions that should be reflected in compiled code
<p_l>
it was interesting approach to augmenting programmer
nowhere_man has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<p_l>
White_Flame: also, look for Marko Heisig (iirc) presentation at ELS2015 (I think it was 2015) where he describes dynamic programming (i.e. auto-adapting) on a supercomputer :)
<White_Flame>
as such, the entire body of work for statically arriving at an optimal static compilation is a red herring
<White_Flame>
at least, in terms of practical envrionmental effect
<White_Flame>
p_l: that certainly sounds interesting :)
makomo has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 240 seconds]
<rpg>
Oddball question: if I have a structure of class node, and there's an extension of node, counter-node, that adds a slot, is there some way to copy a node instance to a fresh counter-node instance? I was trying to copy-node my node instance, and then change-class the fresh node into a counter-node, but change-class doesn't work on structure-class objects...
zotan has quit [Ping timeout: 268 seconds]
zotan has joined #lisp
<rpg>
possibly the right thing is to simply replace my structure class with an object class, but that's at least a mild pain.
wheelsucker has quit [Quit: Client Quit]
lumm has quit [Read error: Connection reset by peer]
LiamH has quit [Quit: Leaving.]
fikka has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Fare has quit [Ping timeout: 268 seconds]
butterthebuddha has quit [Max SendQ exceeded]
fikka has joined #lisp
xaotuk has quit [Ping timeout: 240 seconds]
butterthebuddha has joined #lisp
Fare has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
quazimodo has joined #lisp
skeuomorf has left #lisp ["Killed buffer"]
butterthebuddha has left #lisp [#lisp]
Tristam has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
fisxoj has joined #lisp
tomsen has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
yrdz has joined #lisp
smurfrobot has joined #lisp
tomsen has quit [Ping timeout: 244 seconds]
<zazzerino>
Is `eq` the correct equality function to compare keywords? (It works on sbcl, but I'm wondering if this is portable...)
<aeth>
eq will be slightly faster if the type is unknown because eql will use = on numbers and char= on characters, but I think most people would use eql in their style
<aeth>
oh, actually eql doesn't use =, I misread it
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<aeth>
It uses = on the same type of number
<pierpa>
EQL means equivalent. The two objects must act identically on every possible operation, with the only possible exception of EQ.
robotoad has quit [Quit: robotoad]
<aeth>
I wonder if (eql -0f0 0f0) => nil is correct because "If x and y are both numbers of the same type and the same value" seemed to give me the impression that (eql -0f0 0f0) => t
<aeth>
oops, it clarifies in the spec
<aeth>
I was looking at the examples, not in the text.
<aeth>
Confusingly worded then if they had to add that clarification.
<White_Flame>
zazzerino: symbols are usually interned. So :foo and :foo will always be the exact same object in memory, so you can use the most specific comparator
<White_Flame>
(if you want a non-interned symbol, you have to do extra things)
<zazzerino>
White_Flame: most specific being `eq`, right?
<White_Flame>
yes
<zazzerino>
Cool, thank you all
<edgar-rft>
aeth: In a spec it's sufficient to look at the pictures, you don't need to read the text.
<White_Flame>
at a practical leve, you can consider eq to be a CPU register equality comparison
<aeth>
edgar-rft: well, you'd think that they'd put the edge cases in the examples in addition to the text
<White_Flame>
eql will also compare larger numbers and characters, which might be boxed (ie, larger than 1 machine register, living on the heap somewher)
<aeth>
Someone needs to make a version of the spec with better examples
<White_Flame>
then equal and equalp traverse through larger composites
<White_Flame>
and there are more type specialized comparisons, like = for numbers specifically, string=, etc
<aeth>
equalp uses = for numbers, equal uses eql for numbers. eql, I guess, can be thought of as using = on numbers of the same type except for the -0 vs +0 issue on floats if the float representation has them as distinct values.
<aeth>
I guess there's no concise way of explaining eql's behavior there, especially because of bignums and boxed floating point representations.
EvW has joined #lisp
<White_Flame>
I really dislike that equalp ignores string case
<White_Flame>
I wonder what the original idea behind that was
fikka has joined #lisp
terpri has quit [Ping timeout: 240 seconds]
<aeth>
White_Flame: time for an equal? that ignores string case including unicode string case
<White_Flame>
but it doesn't traverse structures
<aeth>
of course not
<White_Flame>
so if you want to value-compare composite data structures, you either do it case-insensitively, or write your own descender (or override EQUALP to a custom function)
<White_Flame>
it seems awfully odd to default that way
shka_ has quit [Quit: Konversation terminated!]
Pixel_Outlaw has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Kaisyu has joined #lisp
<pillton>
White_Flame: It is possible that equalp was defined in accordance to principles of the "Common" in Common Lisp.
innovati has joined #lisp
<aeth>
On the one hand you get an ugly, inelegant language that is compatible with things no one uses anymore. On the other hand, attempts to start a Lisp from scratch miss very obvious features that large applications need.
<White_Flame>
pillton: certainly, I"m curious what that history is, for that particular issue
<aeth>
White_Flame: check old manuals
<aeth>
old manuals are basically the hyperspec in PDF form for historic Lisps
BitPuffin has quit [Remote host closed the connection]
<White_Flame>
I've gone through pretty much all the genera manuals, but I think that was probably too recent