dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
quazimodo has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
PuercoPop has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
PuercoPop has joined #lisp
whyNOP has joined #lisp
whyNOP has quit [Client Quit]
fikka has quit [Ping timeout: 260 seconds]
markong has quit [Ping timeout: 268 seconds]
dawnfantasy has joined #lisp
fikka has joined #lisp
kushal has quit [Ping timeout: 255 seconds]
ukari has quit [Ping timeout: 260 seconds]
zooey has quit [Ping timeout: 255 seconds]
ft has quit [Ping timeout: 260 seconds]
kushal has joined #lisp
ft has joined #lisp
ukari has joined #lisp
emaczen has joined #lisp
zooey has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
stardiviner has joined #lisp
energizer has quit [Ping timeout: 256 seconds]
Karl_Dscc has quit [Remote host closed the connection]
SirusGedo has joined #lisp
SirusGedo has left #lisp [#lisp]
trocado has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Xach has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
DataLinkDroid has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
pierpal has joined #lisp
trocado has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
pierpal has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 255 seconds]
eli_oat has joined #lisp
eponym has joined #lisp
fikka has joined #lisp
Kundry_W_ has joined #lisp
eponym has quit [Quit: QUIT]
fikka has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
EvW has quit [Ping timeout: 255 seconds]
Kundry_W_ has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
macdavid313 has joined #lisp
marvin3 has quit [Ping timeout: 268 seconds]
NinjaLoko has joined #lisp
asarch has joined #lisp
smokeink has joined #lisp
NinjaLoko has left #lisp [#lisp]
macdavid_ has joined #lisp
fikka has joined #lisp
macdavid313 has quit [Ping timeout: 250 seconds]
dvdmuckle has quit [Quit: Bouncer Surgery]
pjb has quit [Read error: No route to host]
fikka has quit [Ping timeout: 256 seconds]
dvdmuckle has joined #lisp
pjb has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
d4ryus1 has joined #lisp
Arcaelyx_ has joined #lisp
fikka has joined #lisp
Arcaelyx has quit [Ping timeout: 246 seconds]
d4ryus has quit [Ping timeout: 268 seconds]
damke_ has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Bike has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
damke has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
ldb has joined #lisp
milanj__ has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
dented42 has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
fisxoj has joined #lisp
eli_oat has quit [Quit: Leaving.]
fikka has joined #lisp
eli_oat has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
krkini is now known as kini
Mutex7 has quit [Remote host closed the connection]
energizer has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
megalography has quit [Quit: Leaving.]
JuanDaugherty has joined #lisp
johnvonneumann has joined #lisp
johnvonneumann is now known as Guest23348
eli_oat has quit [Quit: Leaving.]
igemnace has joined #lisp
dddddd has quit [Remote host closed the connection]
voidlily has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
macdavid313 has joined #lisp
macdavid_ has quit [Remote host closed the connection]
Kundry_W_ has joined #lisp
Kundry_W_ has quit [Remote host closed the connection]
energizer has quit [Ping timeout: 255 seconds]
fikka has quit [Ping timeout: 240 seconds]
Pixel_Outlaw has quit [Quit: Leaving]
voidlily has joined #lisp
mathZ has quit [Remote host closed the connection]
energizer has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
fikka has joined #lisp
pierpal has joined #lisp
eli_oat has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 246 seconds]
ryanbw has joined #lisp
macdavid313 has quit [Remote host closed the connection]
macdavid313 has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
fisxoj has quit [Quit: fisxoj]
voidlily has quit [Ping timeout: 246 seconds]
yoel has joined #lisp
clintm has joined #lisp
fikka has joined #lisp
yoel has quit [Client Quit]
shka_ has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
schoppenhauer has quit [Ping timeout: 240 seconds]
adolf_stalin has joined #lisp
voidlily has joined #lisp
schoppenhauer has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
energizer has quit [Remote host closed the connection]
eli_oat has quit [Quit: Leaving.]
eli_oat has joined #lisp
eli_oat has quit [Client Quit]
fikka has quit [Ping timeout: 260 seconds]
energizer has joined #lisp
fikka has joined #lisp
ldb has quit [Quit: Lost terminal]
fikka has quit [Ping timeout: 250 seconds]
rippa has joined #lisp
Bike has quit [Quit: Lost terminal]
iqubic has joined #lisp
fikka has joined #lisp
lnostdal has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
pierpa has quit [Quit: Page closed]
fikka has quit [Ping timeout: 260 seconds]
<beach>
Good morning everyone!
doanyway has joined #lisp
clintm has quit [Read error: Connection reset by peer]
iqubic` has joined #lisp
iqubic` has left #lisp [#lisp]
macdavid313 has quit [Remote host closed the connection]
fikka has joined #lisp
iqubic has quit [Ping timeout: 246 seconds]
macdavid313 has joined #lisp
macdavid313 has quit [Remote host closed the connection]
AxelAlex has joined #lisp
orivej_ has quit [Ping timeout: 250 seconds]
macdavid313 has joined #lisp
cgay_ has joined #lisp
macdavid313 has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 255 seconds]
oleo has quit [Quit: Leaving]
macdavid313 has joined #lisp
macdavid313 has quit [Remote host closed the connection]
nika has joined #lisp
Xof has quit [Ping timeout: 240 seconds]
macdavid313 has joined #lisp
macdavid313 has quit [Remote host closed the connection]
arescorpio has joined #lisp
Xof has joined #lisp
energizer has quit [Quit: Leaving]
pfdietz has quit []
mathZ has joined #lisp
macdavid313 has joined #lisp
macdavid313 has quit [Remote host closed the connection]
zymurgy has quit [Quit: WeeChat 1.4]
ebrasca has quit [Ping timeout: 240 seconds]
doanyway has quit []
Xof has quit [Ping timeout: 255 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
macdavid313 has joined #lisp
macdavid313 has quit [Remote host closed the connection]
macdavid313 has joined #lisp
CrazyEddy has quit [Remote host closed the connection]
scymtym has quit [Remote host closed the connection]
zymurgy has joined #lisp
adolf_stalin has quit [Quit: Leaving...]
energizer has joined #lisp
ukari has quit [Ping timeout: 256 seconds]
DataLinkDroid has joined #lisp
chens has joined #lisp
asarch has quit [Quit: Leaving]
<beach>
Hmm, I wonder whether I stumbled upon something really good by having a two-word header for every general instance in SICL, thereby making it possible to have a fairly simple, concurrent garbage collector for the global heap.
<beach>
Garbage collection is a strange domain, though. Only real code and real benchmarks can determine whether it is a good idea.
<White_Flame>
is the goal of SICL to be a functional reference implementation, or to have good performance as well?
<beach>
Performance is definitely an important goal.
<White_Flame>
well, I would suggest since you know it intimately, to go wild with GC ideas. It's harder to explore on more mature platforms
<pillton>
beach: What do you mean by "general instance"?
<White_Flame>
and as you mention, GC is something that needs banging at
<beach>
pillton: A heap-allocate object that is not a CONS cell.
<White_Flame>
i would love to see good concurrent collector ideas
<beach>
White_Flame: Yeah, I agree with you. So I need to finish the x86-64 backend.
ukari has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 268 seconds]
Xof has joined #lisp
ravi__ has joined #lisp
ravi has quit [Remote host closed the connection]
marusich has joined #lisp
arescorpio has quit [Quit: Leaving.]
mathZ has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
azrazalea has quit [Ping timeout: 240 seconds]
eSVG has joined #lisp
vlatkoB has joined #lisp
Sauvin has joined #lisp
Arcaelyx_ has quit [Ping timeout: 246 seconds]
Arcaelyx has joined #lisp
azrazalea has joined #lisp
fraya has joined #lisp
smokeink has quit [Remote host closed the connection]
emaczen` has joined #lisp
johnvonneumann_ has joined #lisp
Guest23348 has quit [Read error: Connection reset by peer]
fikka has joined #lisp
emaczen has quit [Ping timeout: 255 seconds]
Kaisyu7 has joined #lisp
flamebeard has joined #lisp
shrdlu68 has joined #lisp
dented42 has joined #lisp
fraya has quit [Quit: WeeChat 1.8]
<flip214>
I'm wondering whether it might be worth the effort to have 1 or 2 per-thread generations, and then some extension like (sicl-ext:in-generation 4 (make-instance ...)) to specify long-lived allocations
<flip214>
but I guess that was already done at some point
fikka has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
MichaelRaskin has quit [Quit: MichaelRaskin]
<pillton>
Isn't having a concurrent collector AND threads two separate decisions?
d4ryus1 is now known as d4ryus
ravi__ has quit [Remote host closed the connection]
ravi has joined #lisp
macdavid313 has quit [Remote host closed the connection]
shka_ has quit [Ping timeout: 240 seconds]
wigust has joined #lisp
macdavid313 has joined #lisp
SaganMan has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 240 seconds]
scymtym has joined #lisp
lnostdal has quit [Ping timeout: 264 seconds]
shrdlu68 has joined #lisp
dtornabene has joined #lisp
jmercouris has joined #lisp
schweers has joined #lisp
<beach>
flip214: My bet is that it's not going to be worth the effort.
<beach>
Already, my per-thread GC is more precise than a traditional copying collector.
<beach>
flip214: In fact, you can consider it to have a very large number of generations, because the allocation order is preserved, so that objects are always sorted in order of age.
<beach>
I need to run some errands, but I'll be back later to read any remarks.
Murii has quit [Read error: Connection reset by peer]
marusich has quit [Quit: Leaving]
marusich has joined #lisp
Murii has joined #lisp
rumbler31 has joined #lisp
jmercouris has quit [Remote host closed the connection]
rumbler31 has quit [Ping timeout: 246 seconds]
jmercouris has joined #lisp
fraya has joined #lisp
makomo has joined #lisp
milanj__ has joined #lisp
scymtym_ has joined #lisp
scymtym has quit [Ping timeout: 255 seconds]
quazimodo has quit [Ping timeout: 246 seconds]
<beach>
Hmm, no remarks. My plan must be perfect, then. :)
<jmercouris>
absolutely!
<jackdaniel>
maybe you fall into "it's easier to pass a quantum processor design than improve a single function – co-ops doesn't understand the former so they'll have no objections" trap
<beach>
There is always that possibility.
matijja has joined #lisp
<jmercouris>
jackdaniel: what are you saying?
<beach>
jmercouris: That not many people understand my design fully, so they don't know what to tell me.
<jackdaniel>
jmercouris: "maybe you fall into "it's easier to pass a quantum processor design than improve a single function – co-ops doesn't understand the former so they'll have no objections" trap"
<beach>
jmercouris: And that, of course, does NOT imply that my design is perfect.
<beach>
jackdaniel: :)
<jmercouris>
well, my comment was meant tongue in cheek
<jackdaniel>
seems pretty obvious: to be able to use scheme with swift
<jackdaniel>
as a dynamic "scripting language"
<jackdaniel>
like when you hook lua into something C-ish
<jmercouris>
jackdaniel: yes, that much is clear. I asked *why*, not what
<jackdaniel>
why someone would like to use scripting language which is scheme? probably because he wants scheme in his application as a scripting language ;-)
<jmercouris>
I also don't understand why in general, the scripting languages that extend systems would be in a different language than the system itself
<jackdaniel>
I don't really understand the question
<jmercouris>
that is the question, why would your extension language be a different language
marusich has quit [Quit: Leaving]
<beach>
jmercouris: I can explain that.
<jackdaniel>
well, you have swift (as a platform tool with libraries etc) and you want to use a language of your choice (in this case scheme)
<jackdaniel>
it is easier to add scheme to swift, then to rewrite whole ecosystem and convince apple to switch to your own scheme-like language
<jackdaniel>
than*
<beach>
jmercouris: People start by wanting "all the speed they can get". That desire incorrectly leads to a decision to use a static programming language such as C++. Then they feel the need for extensions at run-time. But that can only be done in a very primitive way with the language they chose for the implementation.
<beach>
jmercouris: So then they need a dynamic language for "scripting".
<jackdaniel>
people often work with limitations they have (some try to break through the ceiling by writing anew big projects)
<jmercouris>
interesting answers, I don't really see the ecosystem argument so much because there are ways to do FFI
<beach>
jmercouris: Now, you have the typical situation. Furthermore, advanced users will then start writing serious code using the scripting language. Now you have a combination that is slow, unsafe, hard to debug, and ugly.
<jmercouris>
but the one about speed makes sense, and legacy projects as well
<_death>
you need to use the simple-tree representation, not the xmls one
<p0a>
_death: There is no applicable method for the generic function #<.. CSS-SELECTORS::%DO-QUERY (1)> etc
<p0a>
ah
<p0a>
simple-tree? is that hte default? (css-selectors:query "p" (html5-parser:parse-html5 "<p>hi</p>")) doesn't work either
<p0a>
maybe there's examples onbline
<_death>
you need to load css-selectors-simple-tree
<p0a>
_death: ah nice! you are the developer
m00natic has joined #lisp
<p0a>
(I just noticed on github bcuz I )
<p0a>
because I searched for css-selectors-simple-tree
<_death>
yeah, I added it some time ago ;)
<_death>
you could also try plump/lquery, I think they're more actively maintained
<p0a>
those look good too! thanks
runejuhl has quit [Quit: WeeChat 1.9.1]
pfdietz has joined #lisp
<p0a>
I'm trying to write my own news reader
<p0a>
so that I waste less time reading the news, so that I can have more time to waste reading them
runejuhl has joined #lisp
rumbler31 has joined #lisp
<p0a>
so yeah this is a very important application I'm trying to code :P thanks again
p0a has quit [Quit: bye]
EvW has joined #lisp
<_death>
best news is lisp news
<_death>
and if you write something in lisp, you can blog about it and make news
<shrdlu68>
News? What news? Is the war over?
scymtym_ has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 246 seconds]
<jmercouris>
which one?
<shrdlu68>
"The war to end all wars"
charh has quit [Ping timeout: 248 seconds]
light2yellow has joined #lisp
charh has joined #lisp
<antoszka>
Guys, kind of remember there was a direct-regex reader macro for cl-ppcre. I googled a little and found one in Hoyte's LoL, but wasn't there a quicklispable one, too?
eSVG has joined #lisp
<Xach>
antoszka: cl-interpol maybe?
<antoszka>
let me see
damke_ has joined #lisp
igemnace has quit [Quit: WeeChat 2.1]
<loke>
Something that converts #/foo/ ⇒ (cl-ppcre:create-scanner "foo") ?
anaumov has quit [Read error: Connection reset by peer]
Quetzal2 has joined #lisp
Quetzal2 has quit [Changing host]
Quetzal2 has joined #lisp
scymtym has quit [Ping timeout: 255 seconds]
scymtym__ has joined #lisp
shrdlu68 has quit [Ping timeout: 250 seconds]
Oddity has joined #lisp
eSVG has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
Karl_Dscc has quit [Remote host closed the connection]
shrdlu68 has joined #lisp
scymtym__ has quit [Ping timeout: 255 seconds]
scymtym has joined #lisp
macdavid313 has quit []
<pfdietz>
I distrust hacking the reader. That's a good way to get libraries that don't play well together.
clog has joined #lisp
jdz has quit [Ping timeout: 256 seconds]
jdz has joined #lisp
dtornabene has quit [Read error: Connection reset by peer]
dtornabene has joined #lisp
<jmercouris>
+1 on that
mercourisj has joined #lisp
<mercourisj>
it's somehow a shared state in the interaction of packages that breaks the namespace boundary
dtornabene_ has joined #lisp
hhdave_ has joined #lisp
hhdave has quit [Ping timeout: 260 seconds]
hhdave_ is now known as hhdave
dtornabene has quit [Ping timeout: 240 seconds]
jmercouris has quit [Ping timeout: 240 seconds]
<jackdaniel>
named-readtables are a very good extension to mitigate the problem
<pjb>
Instead, provide functions to set up reader macros (to any character or dispatching character), and let the end-user choose what reader macro to set up.
dawnfantasy has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 246 seconds]
markong has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Louge has joined #lisp
fikka has joined #lisp
matijja has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 246 seconds]
matijja has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
Basrutten has joined #lisp
epony has quit [Remote host closed the connection]
chens has quit [Remote host closed the connection]
epony has joined #lisp
<flip214>
beach: sorry, I wasn't so quick. The idea mostly stems from the apache allocation framework, where you pass one or more pools for allocation around (short-lived vs. long-lived), and can (recursively) create and delete pools.
<flip214>
That is quite a nice model for programming if you're bound to something as low-level as C.
dtornabene_ has quit [Quit: Leaving]
fikka has quit [Ping timeout: 260 seconds]
capitaomorte has joined #lisp
scymtym has quit [Ping timeout: 255 seconds]
<White_Flame>
genera had that idea, of local heaps to use
<White_Flame>
obviously erlang takes it to the extreme
<White_Flame>
but even erlang doesn't let you actively manage & swap between which heap to currently allocate in
dddddd has joined #lisp
<White_Flame>
o fcourse, the 2 big advantages are the ability to throw away an entire RAM section quickly, and to perform local GCs. The former is a lot easier than managing the latter
fikka has joined #lisp
<White_Flame>
(depending on the visibility between heaps)
<pjb>
White_Flame: in C++ you have those allocator parameters, and in Cocoa, you can also specify the NSZone class (but "Zones are deprecated and ignored by most classes that have it as a parameter.")
<White_Flame>
well, C++ doesnt' deal with a GC, so it's kind of moot
<pjb>
Really without a garbage collector to move your objects from one heap to the other, it's not really useful indeed.
<pjb>
Ideally, you would make a zone per document, but it's too hard to track all the allocations.
<White_Flame>
Amiga also had allocation type flags, but again no GC
mercourisj has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 255 seconds]
jmercouris has joined #lisp
EvW1 has joined #lisp
light2yellow has quit [Quit: light2yellow]
FreeBirdLjj has joined #lisp
hazyPurple has quit [Ping timeout: 250 seconds]
Bike has joined #lisp
cgay_ has quit [Remote host closed the connection]
hazyPurple has joined #lisp
cgay_ has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
_whitelogger has joined #lisp
milanj__ has joined #lisp
python476 has quit [Ping timeout: 250 seconds]
DemolitionMan has joined #lisp
ebrasca has joined #lisp
fikka has joined #lisp
rumbler31 has joined #lisp
asarch has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
<shka>
clasp uses MPS (memory pool system) as well
<shka>
same idea
warweasle has joined #lisp
Basrutten has quit [Quit: Lost terminal]
fikka has joined #lisp
Louge has quit [Quit: Louge]
fikka has quit [Ping timeout: 264 seconds]
<beach>
flip214: I see. But I am willing to try my idea first.
<White_Flame>
well, your idea can expand outward to heaps taht are decoupled from threads
hazyPurple has quit [Ping timeout: 256 seconds]
<White_Flame>
it'd be nice to be forward compatible to that, instead of tightly complecting threads & heaps together early on
<beach>
Well, using per-thread heaps is a central idea, actually, because then each thread can trigger a GC without getting any other threads, nor the global GC involved.
mercourisj has joined #lisp
mercourisj has quit [Remote host closed the connection]
<White_Flame>
what's your plan for cross-thread references?
Tristam has quit [Ping timeout: 260 seconds]
<beach>
There won't be any.
<White_Flame>
so full-on erlang style private heaps?
<White_Flame>
with message passing?
FreeBirdLjj has quit [Remote host closed the connection]
<beach>
Nope.
<beach>
A write barrier traps an attempt to put a reference to a local object in a shared object.
jmercouris has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 256 seconds]
<beach>
The local object and its transitive closure is then promoted, thereby preserving the invariant that there are no references from shared objects to local objects.
<fe[nl]ix>
ooh, clever
<beach>
Thanks.
fikka has joined #lisp
<fe[nl]ix>
bonus, can you do that concurrently without stopping the world ?
<beach>
Yes, I can.
<White_Flame>
so lots of inter-thread comm will still drive a lot of global gc
<fe[nl]ix>
that would be so cool
<White_Flame>
but still, would be interesting to see how it plays out
<beach>
Yeah, that's why I am saying I am willing to test it.
<beach>
If it is not working, I would like to know why.
<White_Flame>
oh, I'm sure it would work. The question is on its performance scaling
<beach>
Sure. I kind of included performance in "working".
<White_Flame>
heh
fikka has quit [Ping timeout: 255 seconds]
rumbler31 has joined #lisp
jmercouris has joined #lisp
SaganMan has joined #lisp
<beach>
Furthermore, objects in the global heap don't move, so nothing needs to be done by the mutator threads as a result of a global collection.
rumbler31 has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
jxy has quit [Ping timeout: 240 seconds]
DemolitionMan has quit [Ping timeout: 260 seconds]
oleo has joined #lisp
jxy has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
DemolitionMan has joined #lisp
fikka has joined #lisp
Kundry_Wag has joined #lisp
nullman has quit [Ping timeout: 260 seconds]
damke_ has quit [Ping timeout: 268 seconds]
nullman has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
<flip214>
beach: and you should, because all I have is some papers that I've read and a few frameworks I've used, whereas you're trying new things!
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
stardiviner has quit [Quit: WeeChat 2.1]
FreeBirdLjj has joined #lisp
sjl has quit [Quit: WeeChat 1.9.1]
ryanbw has quit [Remote host closed the connection]
ravi__ has quit [Remote host closed the connection]
ravi has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
damke_ has joined #lisp
fikka has joined #lisp
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
fikka has quit [Ping timeout: 250 seconds]
<kolb>
beach: might be worth to take a look at poly lang, they do some pretty weird concurrent GC things that might be suitable for inspiration. What you are doing sounds really cool btw!
<kolb>
s/poly/pony
<dlowe>
<3 pony
<dlowe>
"for people who think rust is too simplified"
troydm has joined #lisp
fikka has joined #lisp
DemolitionMan has quit [Ping timeout: 260 seconds]
sjl has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
wheelsucker has joined #lisp
<shka>
hmmm
<shka>
this can be excelent, if only there is a way to build efficient synchronization channel
fikka has joined #lisp
<shka>
but in lisp variables often are dragged around in closures
<shka>
it is like you are supposed to move whole lexical env into separate memory pool
<shka>
beach: do you happen to have paper on this? Sounds fascinating!
<Bike>
closures usually only refer to small parts of the lexical environment
<shka>
Bike: that's true
<shka>
not counting dynamic-variables
<Bike>
those aren't part of the lexical environment anyway
<shka>
and probabbly should be in the shared pool to begin with
fikka has quit [Ping timeout: 246 seconds]
FreeBirdLjj has joined #lisp
<beach>
kolb: Sure, if there is documentation, I am always willing to look at it.
<beach>
shka: What I should do is to improve the description of it in the SICL specification so that it is very detailed.
<beach>
shka: Dynamic variables may be shared, yes, but the dynamic bindings are often per-thread.
Arnot has joined #lisp
Arnot has left #lisp [#lisp]
<shka>
beach: right
matijja has quit [Ping timeout: 255 seconds]
fikka has joined #lisp
nullman has quit [Remote host closed the connection]
nullman has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
fikka has quit [Ping timeout: 260 seconds]
LiamH has joined #lisp
<schweers>
Before I conduct any testing on this, which I’ll probably not do correctly anyway, I’ll just ask: should I expect a performance difference between a regular function and a generic function which has exactly one method?
<Bike>
yes.
<Bike>
the generic function can have methods added or removed whenever, so the compiler can't make really any assumptions about it that it can with functions.
<schweers>
should I expect a difference between having one method and more than one?
shrdlu68 has quit [Ping timeout: 246 seconds]
<beach>
schweers: Not very much, no.
<Bike>
maybe a little bit. it's probably not important comparatively
<schweers>
beach, Bike: not much difference between one and more than one method?
<beach>
Right.
<Bike>
yeah.
fikka has joined #lisp
<Bike>
the gf has to determine what methods to use at runtime in some fashion either way.
<schweers>
I’m asking because I want to know how to properly test code in isolation. I.e. how do I write a test for a function which uses other functions, without depending on these other functions to work properly? I think I’d want to insert mock variants of these functions, yet I worry that this might have a penalty in production.
<schweers>
My first thought on how to do this in the first place was to no longer use DEFUN at all, but to use generic functions instead.
<schweers>
But I’m not really happy with that idea.
<jackdaniel>
using generic functions has penalty
<beach>
schweers: Why not? I wouldn't worry about it if I were you.
<jackdaniel>
for instance ECL does not compile generic functions to native code at all at this point of time
<Bike>
testing a function that uses other functions without relying on those functions to work... i mean, that's a dependency
<Bike>
jackdaniel: eh? what about the method functions?
<jackdaniel>
method functions are compiled, yes
<Bike>
right, yeah ok.
<schweers>
beach: why shouldn’t I worry? because methods are not much slower than defuns?
<shka>
don't be afraid of GF slowness
<Bike>
because they're not much slower, and... also you're testing?
<Bike>
i don't really see how that part is related, honestly.
<shka>
exactly
<schweers>
Bike: I don’t worry about the penalty during testing, I worry about the penalty in production
<Bike>
it's worth being conscious of, but it's not like it's severe enough that you should just decide never to use generic functions ever
<beach>
schweers: Generic functions are CURRENTLY SOMEWHAT slower than normal functions. But generic function dispatch may become faster in the future, and it is also not clear that your code would depend a lot on the performance of function calls, as opposed to of what the functions actually do.
<jackdaniel>
schweers: you may always create macro define-function which expands to a generic function or normal function (depends on some compilation-time parameter)
<shka>
basicly GF expected speed is not that bad at all, it is just very dependent on cache and stuff
<schweers>
I don’t mock dependencies right now, I was just thinking about whether or not it’s a good idea to do so.
<jackdaniel>
of course if you'll use clos heavily, it won't be possible to map it
<jackdaniel>
I'm talking about simple scenarios
<pjb>
Methods are not slow, when dispatching is implemented with a cache. In the case of Objective-C, a message sending is asymptotically 2 function calls. I would expect the generic functions to be not much slower. (I'd say 3 function calls at most).
<shka>
yup
<schweers>
I hardly use CLOS at the moment
<beach>
schweers: Sorry to hear that.
<Bike>
it's like how optimization usually goes, where it makes sense to understand the differences in timing deeply, but programmers tend to simplify it to "X is slow" so they can program faster
<schweers>
beach: about what? not really using CLOS?
<beach>
Yes.
<schweers>
Bike: I didn’t want to fall into this trap, which is why I am asking ;)
<schweers>
Instead of just assuming
Guest9989 has quit [Ping timeout: 246 seconds]
<pjb>
a quick benchmark in ccl repl gives a ratio of less than 2.
<Bike>
yep, good work
<shka>
schweers: CLOS is both useful tool and excelent example of software engineering
<shka>
it is worth learning for both reasons :)
<pjb>
You may also want to perform a comparison generic function vs. function+typecase.
<schweers>
beach: I’m really glad to have CLOS and all it entails at my disposal, but to be honest, I really don’t need it in most places. At least at the moment.
<Bike>
This is why I tried to start with what I think could cause real slowness, the inability of the compiler to work with GFs
<Bike>
dispatch itself is going to be somewhere between fast and fast enough almost all of the time
<schweers>
But do you folks use gfs for everything? i.e. not ever using defun any more?
<Bike>
nah.
<beach>
schweers: No, not for everything.
edgar-rft has quit [Quit: edgar-rft]
<jackdaniel>
using CLOS everywhere does not make much sense
<Bike>
they're good when you want to allow extensions and redefinition later very easily, and/or when you have something that needs to work differently on its arguments depending on its classes.
<Bike>
i'd say.
<jackdaniel>
when I write software I usually start with functions and objects. when I need more, I simply promote function to generic function and benefit from CLOS
<jackdaniel>
by objects I mean hash tables and such
<jackdaniel>
and they also with time get sometimes promoted to class instances
<schweers>
jackdaniel: you mean you use classes instead of hashtables?
<jackdaniel>
no, I mean: I start with defun and make-hash-table
<jackdaniel>
but when I need more extensibility and/or control
nika has quit [Ping timeout: 256 seconds]
<jackdaniel>
functions become generic functions and hash tables become slots in class instances
<jackdaniel>
on the other hand, when you think about a specification for your software (you design it), arranging it around protocols makes more sense
<jackdaniel>
then you could start with CLOS from the very beginning
<beach>
GAH, can we please keep the terminology straight.
<beach>
You can't NOT use CLOS.
<beach>
A hash table is a class instance (of the class HASH-TABLE).
fikka has quit [Ping timeout: 255 seconds]
<jmercouris>
almost never does a project have an architecture in the beginning that resembles the final architecture
<jmercouris>
therefore, I think jackdaniel's approach is a good one
FreeBirdLjj has quit [Ping timeout: 248 seconds]
<jmercouris>
let the software naturally grow, as the need arises for more flexibility, manipulation, specificity, whatever ,then introduce custom classes
<jackdaniel>
beach: I don't know how to phrase the difference clearly if we insist of having terminology technically straight
<beach>
jackdaniel: Use STANDARD-OBJECT and STANDARD-CLASS when you want to refer to those.
DemolitionMan has joined #lisp
<jackdaniel>
I don't think it would be clear to the person I talk to (it doesn't seem clear when I try to imagine how the sentence would look like). but let's drop it, I'm getting back to other tasks
<beach>
"ordinary functions become generic functions and hash tables become slots of standard objects".
<schweers>
Anyway, thanks for the input. I’m off for a long weekend \o/
fikka has joined #lisp
<beach>
Take care.
<schweers>
Thanks, you too.
flamebeard has quit []
schweers has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
ebrasca` has joined #lisp
ebrasca has quit [Read error: No route to host]
DemolitionMan has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 250 seconds]
rumbler31 has joined #lisp
fikka has joined #lisp
DemolitionMan has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 246 seconds]
zxcvz has joined #lisp
vtomole has joined #lisp
cgay has quit [Quit: leaving]
FreeBirdLjj has joined #lisp
EvW1 has quit [Ping timeout: 250 seconds]
cgay has joined #lisp
fikka has joined #lisp
jcowan has joined #lisp
<jcowan>
I'm wondering if anyone has implemented Beta-style methods for CL (it should be possible with a MOP)
<beach>
What are "Beta-style methods"?
<jcowan>
the least-specific method is called, and then call-next-method invokes the next least-specific method, and so on
<jcowan>
(Beta is a programming language that works like this)
fikka has quit [Ping timeout: 250 seconds]
<beach>
Oh.
<jcowan>
the idea is that more general methods control when and how specialization is done by subordinate methods, rather than subordinate methods deciding when and how to invoke superior methods
<beach>
You can already do that with some of the existing method combinations.
<jmercouris>
jcowan: that's really cool
<jmercouris>
I wonder if you could build a new dispach on-top of CL to do that
pjb has quit [Read error: Connection reset by peer]
<fe[nl]ix>
rme: can you remove the slash from the lisp-implementation-version ? it breaks ASDF
igemnace has quit [Read error: Connection reset by peer]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
ravi has joined #lisp
<fe[nl]ix>
rme: also it's a bit redundant to have "1.11.5/v1.11.5-7-gb03cb8eecf28" in there
pjb has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pjb has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Read error: Connection reset by peer]
fikka has joined #lisp
Kundry_Wag has joined #lisp
<Xach>
asdf had it comin'
pjb has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Arcaelyx has joined #lisp
<fe[nl]ix>
:D
fikka has quit [Ping timeout: 255 seconds]
pierpal has joined #lisp
pierpal has quit [Client Quit]
pierpal has joined #lisp
pjb has quit [Read error: Connection reset by peer]
fikka has joined #lisp
pierpal has quit [Ping timeout: 264 seconds]
Quetzal2 has quit [Quit: ?? Bye!]
milanj has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
varjag has joined #lisp
pjb has joined #lisp
fikka has joined #lisp
<rme>
Hm. I wanted to have a version and also show version control information (git describe output, in this case).
<rme>
What is ASDF's problem?
<rme>
In this case only, I mean. I'm not inviting a general critique.
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
Satou has quit [Quit: Cya soon guys!]
asdfgh has joined #lisp
bexx has joined #lisp
<asdfgh>
Are there any advantages to dynamic typing over static typing besides macrology (which I think has been fixed with the "Type Systems As Macros" paper)?
Karl_Dscc has joined #lisp
zachk has quit [Changing host]
zachk has joined #lisp
cage_ has quit [Quit: Leaving]
<akkad>
ccl is pretty damn nice
pjb has quit [Read error: Connection reset by peer]
pjb has joined #lisp
pjb has quit [Remote host closed the connection]
EvW has joined #lisp
dented42 has joined #lisp
ebrasca has quit [Remote host closed the connection]
zaquest has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
zaquest has joined #lisp
Guest9989 has quit [Remote host closed the connection]
vlatkoB has quit [Remote host closed the connection]
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<asdfgh>
_death: I'm not terribly convinced. It only mentions static types 3 times and makes poor assumptions ("all static typing is like Pascal", etc).
<_death>
I see.. since you're not interested in reading it, I'm not interested in further discussing it with you
<_death>
it is also offtopic to this channel
FreeBirdLjj has quit [Ping timeout: 250 seconds]
fraya has quit [Quit: WeeChat 1.8]
rumbler31 has joined #lisp
<rme>
fe[nl]ix: I
<rme>
That is, I'll change it.
CrazyEddy has joined #lisp
__paul0 has joined #lisp
asdfgh has quit [Ping timeout: 260 seconds]
_paul0 has quit [Ping timeout: 264 seconds]
comborico1611 has quit [Quit: Konversation terminated!]
Arcaelyx has joined #lisp
earl-ducaine has joined #lisp
djeis has joined #lisp
wigust- has quit [Ping timeout: 255 seconds]
foojin has quit [Ping timeout: 240 seconds]
<theemacsshibe[m]>
> Are there any advantages to dynamic typing over static typing besides macrology (which I think has been fixed with the "Type Systems As Macros" paper)?
<theemacsshibe[m]>
it's much easier to leave types to the compiler, so that the functions you use define your inputs/outputs and not you tbh
djeis has quit [Client Quit]
foojin has joined #lisp
<theemacsshibe[m]>
here SBCL has identified `(lambda (x) (+ x 2))` as returning `((FUNCTION (T) (VALUES NUMBER &OPTIONAL)))`
djeis has joined #lisp
Chream has joined #lisp
cgay_ has quit [Read error: Connection reset by peer]
djeis has quit [Client Quit]
Chream has quit [Remote host closed the connection]
<Bike>
probably "static typing" here is meant to include things without manifest typing, like ML
wheelsucker has quit [Remote host closed the connection]
jmercouris has quit [Ping timeout: 256 seconds]
rumbler31 has quit [Ping timeout: 256 seconds]
LiamH has quit [Quit: Leaving.]
Karl_Dscc has quit [Remote host closed the connection]
Chream has joined #lisp
Chream has quit [Remote host closed the connection]
<rme>
fe[nl]ix: Current CCL sources (1.11.5 and 1.12-dev) no longer have a #\/ in lisp-implementation-version. Thanks for telling me about the problem that caused.
damke has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
damke_ has quit [Ping timeout: 268 seconds]
Bike has quit [Ping timeout: 260 seconds]
milanj has joined #lisp
mejja has joined #lisp
<fe[nl]ix>
rme: thanks
sjl has quit [Ping timeout: 255 seconds]
Kundry_Wag has quit [Read error: Connection reset by peer]
<jasom>
variadic and as a function; how would you implement it? (every #'identity X) (not (position nil X))? somethign else?
<pillton>
jasom: pardon?
<_death>
jasom: I'd think (every #'funcall conjuncts) but given your examples, the former..
Kundry_Wag has joined #lisp
<jasom>
sorry I'm feeling off today. I have a list X. I want to test if there are no NILs in the list. What's a clear way of writing that?
<_death>
your every, or notany..
<Josh_2>
some?
<jasom>
roughly the same effect that (apply #'and X) would have if cl:and were a function.
<jcowan>
_death: Most of the discussion is over my head, but I gather that there are some problems with compiling beta methods.
<Xach>
jasom: i use (notany #'null list) for that sometimes.
FreeBirdLjj has joined #lisp
<_death>
jcowan: I've read the discussion some years ago.. will have to read it again to reach a conclusion
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<_death>
jcowan: but do you think these problems are clisp-specific or apply to other implementations as well
sz0 has joined #lisp
can3p[m] has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
jeosol has quit [Ping timeout: 260 seconds]
zaquest_ has joined #lisp
EvW1 has joined #lisp
zaquest has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
Bike has joined #lisp
python476 has quit [Ping timeout: 250 seconds]
warweasle has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
<jcowan>
From what I gather they are because the MOP doesn't have anything to say about what happens at compile time.
EvW1 has quit [Remote host closed the connection]
fikka has joined #lisp
epony has quit [Remote host closed the connection]
epony has joined #lisp
<_death>
that may be.. the code presented, modified to make use of closer-mop, also has an issue.. I may look at it this weekend