<ixelp>
GitHub - phoe/trivial-package-local-nicknames: Common Lisp PLN compatibility library.
<Kingsy>
Bubblegumdrop: yeah its free. I can share it when I am done. its nothing special. just another web framework really with hunchentoot. hehe there are so so many. but I wanted to write my own so I could learn cl better and also get the features I want
<Bubblegumdrop>
Kingsy You've asked a lot of great questions here and I'm excited to see what you build
<Bubblegumdrop>
lisp 4 life :')
<Kingsy>
haha more nagging than great questions. but yeah hopefully it will work well when its done
Inline has quit [Quit: Leaving]
akoana has joined #commonlisp
<elderK>
Bubblegumdrop: Is trivial-package-local-nicknames still needed today?
<elderK>
I was curious as to how "standard" PLNs are now.
<paulapatience>
It's useful to manually fiddle with PLNs rather than via uiop:define-package
<aeth>
0% on CLISP, CMUCL, CORMAN, JSCL, MEZZANO, MKCL
<elderK>
aeth: That's a shame. PLNs are really, really useful.
<aeth>
CLISP hasn't gotten (officially) updated in forever, JSCL is apparently still very incomplete (at the very least, with all of the de facto standards) and probably isn't the way forward (wasm probably is)
<elderK>
paulapatience: Why is that?
<elderK>
Couldn't you emulate PLNs with some clever symbol tricks?
pyooque has joined #commonlisp
puke has quit [Killed (iridium.libera.chat (Nickname regained by services))]
pyooque is now known as puke
<aeth>
so Mezzano seems to be the only interesting one missing PLN
<Bubblegumdrop>
elderK presumbly unportable
<Bubblegumdrop>
"less portable" perhaps is a better term
<elderK>
Not to sound like, frank but is the major CLs support it, that would be good enough.
<elderK>
Then again, in the open source space, what else is there than ECL and SBCL?
<Bubblegumdrop>
I try to use trivial-* when possible
<elderK>
Sure, there's CCL but isn't that basically dead now?
<aeth>
,(lisp-implementation-type)
<ixelp>
(lisp-implementation-type) => "Clozure Common Lisp"
<Bubblegumdrop>
Latin is "dead" but still taught in schools :)
<paulapatience>
If you want to introduce PLNs outside of a uiop:define-package form, you need to use either trivial-package-local-nicknames, or resort to implementation-specific functions
<elderK>
paulapatience: Ah, thank you. I wasn't aware of that.
<paulapatience>
t-p-l-n just wraps those implementation-specific functions into a common interface
<Bubblegumdrop>
Does everyone use uiop:define-package? I really like :use-reexport
<aeth>
Latin's only dead because it split into many languages (5 or so major ones)... e.g. you don't say Greek's dead because there's only one (standard) Modern Greek
<aeth>
dead/not-dead in that sense isn't too useful
<paulapatience>
That's what many of the trivial-* libraries do
<aeth>
by the standards of Latin being dead, Lisp is dead, too, because the original LISP split into a bunch of languages
<aeth>
none using the name "Lisp" without some non-version qualifier (unlike Fortran)
attila_lendvai has quit [Ping timeout: 272 seconds]
NicknameJohn has quit [Ping timeout: 256 seconds]
<aeth>
Lisp is Latin, Common Lisp is French (?), Scheme is Spanish, Racket is Portuguese, Clojure is Romanian...
<paulapatience>
Romanian is the closest language to Latin that is still spoken
<elderK>
Bubblegumdrop: I use defpackage mostly because I like it more.
jonatack has joined #commonlisp
<elderK>
define-package is more powerful but, I like sticking to ANSI as much as possible for now.
<paulapatience>
Rather of still spoken languages, it is the closest to Latin
<elderK>
Granted, I'm only really just starting out :)
<paulapatience>
UIOP is effectively always available, so if it's a dependency issue, fear not
<elderK>
I'd rather learn how to reproduce some of define-package's functionality like re-export.
<paulapatience>
You could macroexpand uiop:define-package to see what it does
<elderK>
Indeed :)
<paulapatience>
And then realize that you could just use it directly ;)
<elderK>
It's probably a bit backwards but I'm trying to learn to do things, from scratch, as much as possible (and within reason.) Not so much because there aren't libraries or things around, but because I want to force myself to learn as much of CL as necessary.
<elderK>
Once I am more familiar, I'll be more lazy.
<aeth>
paulapatience: so what you're saying is that Emacs Lisp is Romanian? The problem with analogies is that they break down
<aeth>
there are alternatives to uiop:define-package
<aeth>
use-reexport can be useful, but not too often unless you use package-inferred-system and there are other libraries that can give you that iirc
<elderK>
aeth: Like what? :D
<elderK>
I've been trying to decide between package-inferred and "traditional."
<elderK>
I like package-inferred but it is a lot more effort.
<aeth>
iirc, defpackage-plus is an alternative to uiop:define-package
<Bubblegumdrop>
elderK what I find myself doing is writing lots of small packages with regular defpackage then a larger "use all these smaller packages" with uiop:define-package
<ixelp>
GitHub - gunnarmorling/1brc: 1️⃣🐝🏎️ The One Billion Row Challenge -- A fun exploration of how quickly 1B rows from a tex [...]
bilegeek has quit [Quit: Leaving]
pillton has joined #commonlisp
Inline has joined #commonlisp
<skin>
that does sound pretty fun
<skin>
has there been any changes in esrap ( the parser Library) lately?
<skin>
I call `parse` and in the latest version It's just returning nil when the parsing was done successfully instead of the parsing result
<skin>
it was the wildest thing I have no idea why it broke in this later version I'm going to confirm that the older version worked tomorrow though just to double check
<Bubblegumdrop>
What CL impl are you using? I'm using sbcl 2.3.7 on debian.
<skin>
hmm mm. maybe it's something to do with my environment. that's helpful though
<skin>
I was able to get that results in m62 but right now I'm just running in vanilla windows latest version of sbcl
<Bubblegumdrop>
skin just from looking at your file, perhaps your (declaim (debug 3)) might be interfering? I can't imagine that would be it but ...
<skin>
maybe some windowsism causing it to be screwy. today was the first day I tried to run it outside of msys2. whacky
<skin>
I really appreciate your help tracking it down
<skin>
that's good Intel
<Bubblegumdrop>
Oh I see. So you normally dev with MSYS2 SBCL? and are running it on native win32 sbcl now?
Lycurgus has quit [Quit: leaving]
<skin>
I think so I think that's how it works.
<Bubblegumdrop>
I have been through these steps myself. I found that compiling sbcl from source using the bootstrap compiler to produce better results.
<Bubblegumdrop>
sec
<skin>
huh. I installed Roswell into msys2, commented out the "install msys2" line it has, then installed sbcl from there
amb007 has quit [Read error: Connection reset by peer]
wacki has joined #commonlisp
amb007 has joined #commonlisp
bilegeek has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
contrapunctus has joined #commonlisp
rainthree has joined #commonlisp
shka has joined #commonlisp
_cymew_ has joined #commonlisp
azimut has quit [Ping timeout: 255 seconds]
msavoritias has joined #commonlisp
_cymew_ has quit [Ping timeout: 255 seconds]
chomwitt has joined #commonlisp
contrapunctus has left #commonlisp [#commonlisp]
oneeyedalien has joined #commonlisp
oneeyedalien has quit [Max SendQ exceeded]
amb007 has quit [Ping timeout: 240 seconds]
contrapunctus has joined #commonlisp
pve has joined #commonlisp
zaymington has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
glozzom has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
traidare has joined #commonlisp
glozzom has joined #commonlisp
amb007 has joined #commonlisp
Josh_2 has joined #commonlisp
<Josh_2>
Hi hi
<Josh_2>
beach: you here?
wacki has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
<beach>
Yes.
rgherdt has joined #commonlisp
<Josh_2>
beach: What is the origin of 'protocol oriented programming'
ymir has quit [Ping timeout: 256 seconds]
<Josh_2>
the term
<beach>
Where did you see the term used?
<Josh_2>
hmm
<beach>
I don't think I have used it.
<Josh_2>
hmmmm
<Josh_2>
one minuteeee
chomwitt has quit [Ping timeout: 246 seconds]
<Josh_2>
Hmm
<Josh_2>
perhaps I just came up with it :thinking:
<Josh_2>
I dont know why I thought you wrote it in the SICL Specification
<Josh_2>
32.14 Extensible Libraries
<Josh_2>
Using *client* as an extension of a library written in a 'protocol oriented' way is very cool
<beach>
I don't see it.
<Josh_2>
You didn't write it
<Josh_2>
I was mistaken but its okay :thumbsup:
<beach>
Oh, I see.
<Josh_2>
I wrote an OpenTelemetry library 6 months ago that uses a similar technique to the one described in 32.14
<aeth>
is CLIM protocol-oriented programming?
<Josh_2>
I would say so
<beach>
There is nothing new or particularly special about protocols. They are just generalizations of interfaces that Common Lisp allows, like multiple dispatch and such.
<beach>
And interfaces have been around for half a century or more.
<Josh_2>
Yes
<Josh_2>
:thinking:
<beach>
So just like an interface, a protocol is merely a way to specify what part of a module is visible externally.
ymir has joined #commonlisp
<Josh_2>
Was it a 'thing' before AMOP?
<Josh_2>
or MOP at least
<beach>
As such, it contains types (usually classes) and operations (usually generic functions).
<beach>
I don't know. The concept of a protocol doesn't require CLOS. It could have ordinary functions and types, but it would be a bit limited then.
<Josh_2>
The term 'protocol oriented programming' seems fitting to me
<Josh_2>
I dont know what I'm thinking but I'm thinking something :thinking:
<beach>
As I recall, one of the examples in my chapter on protocols is a protocol with the operations CONS, CAR, CDR, and the type CONS. Nothing CLOS-y here.
ymir has quit [Ping timeout: 264 seconds]
<beach>
In fact, since an interface is a restricted version of a protocol, every interface is a protocol, so protocols have been around for as long as interfaces, but perhaps not with that name
<Josh_2>
Perpaps but much of the examples of 'Protocol' in the SICL spec do in fact use GF's
<beach>
Sure.
<Josh_2>
hmmmm
<beach>
But I think the dependency is the other way around. Since it used generic functions, classes, and multiple dispatch, it can't be an interface, so we have to call it a protocol.
<Josh_2>
Perhaps I mistakenly assumed the terminology was taken from Meta Object Protocol rather than something else
<beach>
Oh, I don't think so. Meta Object Protocol is just a protocol that works on metaobjects.
<Josh_2>
Right
<beach>
So the "types" are classes of metaobjects.
<Josh_2>
The essence being a set of GF's that a client can specialize in order to customize the behaviour. If a designer of a different system sat down and wrote their system in a way that utilizes GF's so that a user of their system can customize the behaviour through specialization of GF's, I would call this 'protocol oriented programming'
<Josh_2>
although they may be the client of their own system :thinking:
<beach>
Customization is not a required part of a protocol though.
<Josh_2>
Okay perhaps I should rephrase
<beach>
It just so happens that CLOS allows for such customization by subclassing and auxiliary methods.
amb007 has quit [Ping timeout: 260 seconds]
<Josh_2>
Okay :thinking:
danza has joined #commonlisp
<beach>
Maybe you need a new term for a protocol that allows customization.
amb007 has joined #commonlisp
<ebrasca>
Good morning!
<Josh_2>
As far as I can tell if you are writing a protocol using GF's then customization is implied
<beach>
Hello ebrasca.
<Josh_2>
it might not be desired but it is implied.
<ebrasca>
beach: Hi
<Josh_2>
I think that is besides the point though.
<beach>
Josh_2: Not quite. If the protocol uses only "primitive" types like INTEGER, CONS, HASH-TABLE, you can't create a subclass. And you can't create auxiliary methods either, because they would be applicable when given only specified types, and that is not allowed.
<Josh_2>
True :thinking:
<Josh_2>
Perhaps the tipping point would be introducing an auxiliary variable like your *client* idea
<Josh_2>
which I have done unintentionally
<beach>
But, of course, if it uses only primitive types, there is no particular reason to use generic functions.
<Josh_2>
But there are times when you want a generic interface even if it accepts primitive types, like #'describe
<pve>
beach: Hi, could you expand on "an interface is a restricted version of a protocol"? When is a protocol not an interface?
<beach>
pve: When it uses multiple dispatch. The usual definition of an interface defines a single type and operations on it. But I am sure there are other definitions of "interface".
<beach>
I am not sure it is complete or entirely correct, but I haven't heard any objections so far.
<Josh_2>
:O
<Josh_2>
Where is that from?
philipp_ has joined #commonlisp
<Josh_2>
its 'chapter 5'
<beach>
From an incomplete book that I wrote.
amb007 has quit [Ping timeout: 246 seconds]
waleee has joined #commonlisp
amb007 has joined #commonlisp
<Josh_2>
What was it about?
<Josh_2>
'generic protocol' is a more specific term that implies the use of generic functions :thinking:
<Josh_2>
what you describe is more general and not what I was thinking
<Josh_2>
'Maybe you need a new term for a protocol that allows customization' Yes I do
<beach>
I think the title is "Programming with Generic Functions"
<Josh_2>
:O
<Josh_2>
How complete is it??
<beach>
It has 116 pages apparently.
<Josh_2>
Can I see it?
<beach>
Nah, not worthwhile. It is quite incomplete.
<beach>
And it very likely will remain incomplete.
<Josh_2>
:(
<Josh_2>
What are the chapter titles?
<beach>
All my book projects are abandoned, or at least suspended. I can't write books by myself, and my favorite coauthor quit being interested in writing books.
<splittist>
give it a few months and you'll be able to generate the whole book with a fully animated video presentation from a set of notes via your favourite LLM (:
<beach>
That might work.
<beach>
Josh_2: I haven't even decided on all the chapter titles. I don't work like that.
<Josh_2>
:(
<Josh_2>
I really want to see it now :(
<splittist>
Josh_2: create the future you want to see!
<Josh_2>
I'm trying!!
<Josh_2>
Maybe beach and I write book on 'Programming with Generic Functions' :)
<Josh_2>
Seems fitting
<Josh_2>
Im already good at LaTeX and I recently formatted a 200+ page book full of speeches :sunglasses: Thats being published now
chomwitt has joined #commonlisp
<Josh_2>
beach: can I see :)
anticomputer has quit [*.net *.split]
triffid has quit [*.net *.split]
gxt_ has quit [*.net *.split]
ec has quit [*.net *.split]
chiselfuse has quit [*.net *.split]
pfdietz has quit [*.net *.split]
dino_tutter has joined #commonlisp
tok has joined #commonlisp
danse-nr3 has joined #commonlisp
bendersteed has joined #commonlisp
jonatack has joined #commonlisp
jon_atack has quit [Ping timeout: 246 seconds]
<Josh_2>
beach: is your idea of a *client* necessary when using a protocol-class?
<splittist>
Josh_2: a modest proposal: study the subject, write up a treatment, ask for comments; incorporate feedback, write a draft, ask for comments; repeat
bilegeek has quit [Quit: Leaving]
<Josh_2>
if you combine a *client* and a protocol-class you can change the standard behaviour
NicknameJohn has quit [Ping timeout: 240 seconds]
<beach>
Josh_2: Sort of. It is what allows the client to specialize when it is not practical or allowed to specialize the other classes involved.
<Josh_2>
can you think of an example where it would not be practical or allowed?
<beach>
The example above where only primitive classes are used otherwise, like INTEGER, FLOAT, HASH-TABLE.
<Josh_2>
I see
chomwitt has quit [Ping timeout: 264 seconds]
<Josh_2>
have you thought about a standard way to trampoline to a client oriented gf?
<Josh_2>
obviously if you are implementing a standard function like #'read then its easy, but if you are writing your own generic-protocol which exposes a function like #'reorient or something, then what would you name the underlying gf?
<Josh_2>
I know in the past I have created gfs with a % as the prefix
<Josh_2>
but I dont like this
amb007 has quit [Ping timeout: 268 seconds]
<beach>
I don't know. We have used <mumble>-with-client occasionally.
mzan has joined #commonlisp
<Josh_2>
hmm
<beach>
... or maybe it was -using-client.
<Josh_2>
so reorient-with/using-client which would be the actual gf that is specialized
<beach>
Right.
<beach>
And you would pass it something like *CLIENT*.
<beach>
Maybe you should study Eclector. It implements the standard reader, and it can be configured in many ways by the client.
<Josh_2>
I've looked at Eclector many times
<beach>
OK.
<Josh_2>
I understand the idea intuitively, I am trying to formalize it. If that makes sense
<Josh_2>
in a few of my libraries I have used this 'client-oriented' pattern, but it was a coincidence. This idea is a natural follow on from writing libraries using generic functions
<Josh_2>
'generic protocol' and 'client-oriented generic protocol
<beach>
It does make sense, yes.
dcb has quit [Quit: Connection closed for inactivity]
<Josh_2>
Why does eclector specialize to T rather than nothing?
<beach>
One reason could be to avoid warnings about unused parameters. Not all implementations consider all method parameters as "used".
<beach>
SBCL does, though, but that's not required by the standard.
waleee has quit [Ping timeout: 264 seconds]
<beach>
In fact, it might not be a good idea to do what SBCL does, because it then hides a potential problem when an unspecialized parameter is in fact, not used.
<beach>
childlikempress: Thanks for the link to the paper about RVSDG. It would be great to create something that uses this intermediate representation, rather than using a traditional control-flow graph. That way, we would have an advantage over LLVM.
<beach>
childlikempress: It will take me a while to read and digest it, of course.
mzan has joined #commonlisp
<Josh_2>
Thanks for your help beach :thumbsup:
ebrasca has quit [Ping timeout: 264 seconds]
<beach>
Sure.
<Josh_2>
Hmm
<Josh_2>
in protocol.pdf you say provide a restriction on the definition of a protocol by stating that X doesn't constitute a protocol simply because it can be divided up. Would it be fair to call the divisions as 'component protocols' because you use the cons and the + protocols as examples?
<Josh_2>
idk if that makes sense, for some reason I cant copy and paste from the pdf
<beach>
My preferred terminology as implied by the text is that the combination is not a protocol, so then the components are just protocols.
<Josh_2>
Gotcha :thumbsup:
<Josh_2>
Thanks
varjag has joined #commonlisp
traidare has quit [Ping timeout: 264 seconds]
oneeyedalien has joined #commonlisp
random-nick has joined #commonlisp
younder has quit [Remote host closed the connection]
vats has joined #commonlisp
jmdaemon has quit [Ping timeout: 260 seconds]
vats has quit [Killed (NickServ (GHOST command used by vats-!~vats@2409:40f0:1019:5315:a6d:41ff:fedc:c038))]
vats has joined #commonlisp
<beach>
childlikempress: Hmm, I don't (yet) see how some arbitrary control flow can be turned into an RVSDG graph.
decweb has joined #commonlisp
<hayley>
Why RVSDG instead of sea-of-nodes? I haven't found any comparisons of the two.
<beach>
I haven't seen any comparison either. And I am still reading about RVSDG.
<hayley>
I am going to use sea-of-nodes regardless, as I am trying to imitate HotSpot and V8 with my compiler, but I'm sure there's a good reason for RVSDG.
traidare has joined #commonlisp
<beach>
I see. But I was not thinking about your compiler (which I assume is the one for a language other than Common Lisp, right), but about some backend library for Common Lisp.
<hayley>
Sure (and right). I am thinking to generalise the compiler a bit, as I think a frontend for a lower level language would help me demonstrate how buggy machine code/IR is handled.
<beach>
I see.
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
younder has joined #commonlisp
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
<hayley>
The working title for the project is "Reinvestigating typed assembly language and the garbage collection interface". I'd like to be able to show that I can detect code which does allocation and write barriers incorrectly. But my compiler shouldn't generate buggy code, so I need a workaround.
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
<hayley>
Maybe the title should have "for" instead of "and", I was in a hurry while filling out the form.
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
vats has quit [Killed (NickServ (GHOST command used by vats-))]
vats has joined #commonlisp
green_ has quit [Ping timeout: 264 seconds]
Oddity has quit [Ping timeout: 246 seconds]
pillton has quit [Remote host closed the connection]
synchromesh has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
Lord_of_Life has joined #commonlisp
tyson2 has joined #commonlisp
danse-nr3 has quit [Read error: Connection reset by peer]
vats has quit [Ping timeout: 256 seconds]
yitzi has joined #commonlisp
synchrom1 has joined #commonlisp
synchromesh has quit [Ping timeout: 256 seconds]
green_ has joined #commonlisp
synchromesh has joined #commonlisp
synchrom1 has quit [Ping timeout: 240 seconds]
awlygj has joined #commonlisp
<beach>
childlikempress: Do you have evidence that any initial control structure can be turned into an RVSDG graph?
synchrom1 has joined #commonlisp
synchromesh has quit [Read error: Connection reset by peer]
<hayley>
One paper I read on RVSDG specifically mentioned structured control flow, but I've heard elsewhere that one wants structured control flow for other reasons.
danse-nr3 has joined #commonlisp
synchromesh has joined #commonlisp
<beach>
If by structured control flow, you mean what Muchnick calls "reducible" control flow, then that is certainly desirable. But that's not the question here, since TAGBODY can create arbitrary control flow, and the intermediate representation must obviously be able to handle that.
<beach>
Oh, but maybe you are again talking about your own language?
<hayley>
Ben Titzer said structured control flow implies that all loops are reducible (which sounds right, I haven't thought about it), which is useful for other optimisations. But he then said that something cannot handle JVM bytecodes with irreducible loops, which I talked to Cliff Click about...
synchrom1 has quit [Ping timeout: 264 seconds]
<hayley>
and Cliff said that C2 does lots of restructuring and duplication of loops to make them reducible. (Java itself cannot express irreducible loops, but the compiler can produce irreducible loops by inlining exception handlers.)
<hayley>
I'm not talking about any language in particular. But it sounds like one wants structured (or at least reducible?) control flow, so if RVSDG didn't support unstructured control flow, it mightn't be a big loss. But then what is your IR before you restructure and produce RVSDG?
<hayley>
I am probably talking crap; I don't know what optimisations really need reducible control flow.
<beach>
I guess you are right in that irreducible control flow can be turned into reducible control flow with code duplication.
<beach>
I don't know what the IR before RVSDG would look like. Maybe something like SSA is needed.
<beach>
I found something called "Controlled Node Splitting" that does that.
synchrom1 has joined #commonlisp
synchromesh has quit [Ping timeout: 264 seconds]
chomwitt has joined #commonlisp
<beach>
Oh, dear. That paper uses the passive form a lot.
tibfulv has quit [Remote host closed the connection]
tibfulv has joined #commonlisp
<beach>
Anyway, since irreducible control flow can be turned into reducible control flow, I am not going to read this particular paper any further, and I will continue reading about RVSDG, and then about sea-of-nodes to compare.
Inline has quit [Quit: Leaving]
green_ has quit [Ping timeout: 268 seconds]
green_ has joined #commonlisp
saturn2 has quit [Ping timeout: 268 seconds]
<younder>
Beach: Still working my way through 'A Simple Graph-Based Intermediate Representation' I have also started a draft for how I envision the compiler design.
synchrom1 has quit [Ping timeout: 252 seconds]
synchromesh has joined #commonlisp
<younder>
That said I need to finish my 'table-grinder' app, before I can really sink my teeth info it. Should be finished this week. SITREP ends..
josrr has joined #commonlisp
<younder>
Mind you a SSA form (single static assignment) mentioned in the above paper should be replaced for a CPS form (continuation passing style) for CL
oneeyedalien has quit [Quit: Leaving]
tyson2 has quit [Remote host closed the connection]
josrr has quit [Remote host closed the connection]
zaymington has quit [Remote host closed the connection]
k_hachig has joined #commonlisp
notzmv has quit [Ping timeout: 246 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 27.1)]
<younder>
The petri net model for the control flow subgraph sound good.
traidare has quit [Ping timeout: 264 seconds]
ym has quit [Ping timeout: 264 seconds]
<younder>
For the record there are 3 actual compilers in common lisp. The REPL compiler. The one most like the JIT. The FILE compiler allows for more features for optimization that a function by function compiler. Finally a program compiler, optional, with tree walker and link optimizer.
saturn2 has joined #commonlisp
josrr has joined #commonlisp
notzmv has joined #commonlisp
azimut has joined #commonlisp
anticomputer has joined #commonlisp
chiselfuse has joined #commonlisp
prokhor has joined #commonlisp
<younder>
As for the above mentioned irreducible loops - don't avoid loops at all cost - the branch predictor is pretty good at avoiding misses for those. Instead avoid the non-locality that comes from over aggressive in-lining and unrolling. The limit is architecture and model dependent, but get it wrong and the performance goes off the deep end and it is very difficult to see why.
ec has joined #commonlisp
gxt_ has joined #commonlisp
ec has quit [Remote host closed the connection]
ec has joined #commonlisp
danse-nr3 has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
gxt_ has quit [Remote host closed the connection]
gxt_ has joined #commonlisp
chomwitt has quit [Ping timeout: 264 seconds]
<beach>
There are occasional claims that CPS is equivalent to SSA. That is not true.
<beach>
What is true, though, is that if you start your CPS conversion by doing assignment conversion, then your result is automatically SSA. But then you have lost all the advantages of SSA conversion, because all your assignments are then memory operations.
triffid has joined #commonlisp
saturn2 has quit [Ping timeout: 268 seconds]
triffid has quit [Remote host closed the connection]
ec has quit [Remote host closed the connection]
X-Scale has joined #commonlisp
triffid has joined #commonlisp
traidare has joined #commonlisp
ec has joined #commonlisp
<younder>
What does seem clear to me is that if the representation differs significantly from Click's and I think it will.. Then the choice of algorithms is likely to be different too.
bendersteed has quit [Quit: bendersteed]
philipp_ has quit [Ping timeout: 246 seconds]
<younder>
I did notice that Click mentions in his work on Scala that the level of indirection in the data make it impossible to get below factor of 2 in performance from Java. That is likely true from Lisp as well.
saturn2 has joined #commonlisp
<younder>
Flat math is relatively easy to optimize it is the data-structures like trees and graphs the modern processors don't like much. They prefer arrays. Arrays with values not pointers.
rainthree has quit [Read error: Connection reset by peer]
rainthree has joined #commonlisp
danse-nr3 has quit [Ping timeout: 264 seconds]
saturn2 has quit [Ping timeout: 252 seconds]
<scymtym>
skin: do you have a self-contained test case for the esrap problem
rgherdt has quit [Ping timeout: 264 seconds]
tyson2 has joined #commonlisp
saturn2 has joined #commonlisp
Lycurgus has joined #commonlisp
rainthree has quit [Ping timeout: 256 seconds]
<younder>
beach: there is a implementation of arena's in SBCL sbcl/doc/internals-notes/arena-allocation.txt
<beach>
I don't think that would be of any use to me.
<younder>
In the virtual register allocation algorithm it can speed things up.
<beach>
I don't think it is high priority to speed up compilation time.
<skin>
scymtym: I can get you that information tonight after work.
<skin>
thanks for your help
X-Scale has quit [Quit: Client closed]
<younder>
beach . register allocation is one of the areas most likely to slow the compiler down. Unlike peephole optimizations that are local graph substitutions this involves graph walking which is expensive. Finding the right algorithm here is key. Graph coloring might be a option.
szkl has joined #commonlisp
<scymtym>
skin: thanks
Josh_2 has quit [Ping timeout: 255 seconds]
unl0ckd has joined #commonlisp
kevingal has joined #commonlisp
waleee has joined #commonlisp
chrcav has quit [Quit: Lost terminal]
chrcav has joined #commonlisp
thuna` has joined #commonlisp
<beach>
younder: I don't think it is worth complicating the memory manager in order to speed up the compiler.
<beach>
Besides, it probably depends on the technique for register allocation.
<beach>
Bubblegumdrop: Binding a dynamic variable in the LET makes it bound dynamically until the LET exits.
<Bubblegumdrop>
Okay so I am incorrect. Thanks.
<beach>
Bubblegumdrop: But it is not bound only in the body of the LET. It is bound for the duration of the LET including in functions called from inside the LET.
<Bubblegumdrop>
For some reason I was under the impression it worked like setf if I used it like that.
<Bubblegumdrop>
make-pattern-predicate would have the value bound like you describe
<beach>
Correct.
igemnace has quit [Quit: WeeChat 4.2.1]
Tristan_ has joined #commonlisp
Inline has joined #commonlisp
amb007 has joined #commonlisp
chomwitt has quit [Ping timeout: 260 seconds]
amb007 has quit [Ping timeout: 264 seconds]
amb007 has joined #commonlisp
waleee has quit [Ping timeout: 264 seconds]
wacki has joined #commonlisp
jmdaemon has quit [Ping timeout: 260 seconds]
yitzi has quit [Remote host closed the connection]
unl0ckd has joined #commonlisp
_cymew_ has joined #commonlisp
jmdaemon has joined #commonlisp
rgherdt has joined #commonlisp
jmdaemon has quit [Ping timeout: 264 seconds]
Equill has quit [Quit: Gone offline]
Oddity has joined #commonlisp
attila_lendvai has joined #commonlisp
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #commonlisp
tane has joined #commonlisp
pfdietz has joined #commonlisp
<pfdietz>
A fast compiler is important to me when I do testing.
<pfdietz>
I saw a paper that did random generation of Haskell programs, doing about 250 tests per hour. When I test COMPILE in sbcl I can do 250 tests per second.
<pfdietz>
(depending on the size of the generated programs)
ymir has quit [Ping timeout: 268 seconds]
<Bubblegumdrop>
Generated programs? Where can I read more about this.
<Kingsy>
can someone tell me, what is the easiest way of debugging the contens of variables? I have this line (cdr (assoc 'EMAIL '((name . chris) (email . hello@hello.com)))) which works perfect. but as soon as i try to use it in my code with symbols and variables it returns NIL. so something is going wrong. I have tried to just format t the vars out, but that prints as if it should work. I need a better way of
<Kingsy>
viewing variable content.
<Bubblegumdrop>
Kingsy (with-output-to-string (s) (describe some-obj s)) <- I use this a lot.
<Bubblegumdrop>
If you're in the repl just DESCRIBE is fine.
<Bubblegumdrop>
You could do PRINT style debugging.
<Bubblegumdrop>
I would like to know if there's a way to step into code.
<_death>
Kingsy: if you're using format, probably you want to use ~S (and not, say, ~A).. you can also use INSPECT or SWANK:INSPECT-IN-EMACS.. or you can BREAK and view the binding in the debugger (good idea to use (debug 3) optimization policy then)
rendar has quit [Quit: Leaving]
<NotThatRPG>
I'm also fond of TRACE
<NotThatRPG>
Although I have never quite grokked the trace thing in SLY. It looks awesome, but I have to wrap my head around it
rendar has joined #commonlisp
<_death>
a slimey "trace inspector" would be cool.. I know slime has slime-trace-dialog, and maybe sly has something based on that (it was written by sly author, I believe), but it did catch on for me
<_death>
*didn't
danse-nr3 has joined #commonlisp
chiselfuse has quit [Ping timeout: 260 seconds]
<_death>
I think such an inspector would require deeper trace information support from the implementation, not parse TRACE output or something like that
chiselfuse has joined #commonlisp
<Kingsy>
right I really don't understand this... what is wrong with this code https://bpa.st/JF34G <- I am totaly lost.
<ixelp>
View paste JF34G
<Kingsy>
why am I getting nil? I should be getting an email address, so wierd. I mean its not complex
brokkoli_origin has quit [Ping timeout: 255 seconds]
thuna` has quit [Remote host closed the connection]
<childlikempress>
beach, hayley: doesn't rvsdg have functions and tail calls
pfdietz has joined #commonlisp
<Kingsy>
right so I have a head scratcher, I have a macro and I want to pass some parameters into the macro and use it as the lambda parameter list within the macro, however if I do something like this (defroute some-name '(email) .. when I use this as the lambda params the output is (LAMBDA QUOTE (EMAIL) <- which obviously wont work. is there a trick to this?
<Bubblegumdrop>
Yah...
waaron_ has quit [Ping timeout: 256 seconds]
<Bubblegumdrop>
Oh, you can look at it with (macroexpand-1 '(defroute ...)) too
waaron has joined #commonlisp
<Kingsy>
sorry I am asking how to remove the quote that is added because its the only way I can pass the list of symbols into the macro. unless there is a different way of doing that.
<gilberth>
This sounds odd. Why is the QUOTE there in the first place?
<bike>
just write (defroute some-name (email) ...)
waaron has quit [Ping timeout: 268 seconds]
waaron has joined #commonlisp
<Kingsy>
oh you know what. I thought it was going to try and run (email) in that case, as if a function, I was thinking I needed to supply as data
<Kingsy>
apologies all for the dumb question.
k_hachig has quit [Ping timeout: 240 seconds]
danse-nr3 has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
amb007 has quit [Ping timeout: 255 seconds]
danza has joined #commonlisp
amb007 has joined #commonlisp
<Kingsy>
oh I know why I did it, its because I wanted to add the params to a class slot. and if I don't quote them I get an error undefined variable
<Kingsy>
I'll quote it at that point perhaps
danse-nr3 has quit [Ping timeout: 255 seconds]
rogersm_ has joined #commonlisp
tane has quit [Quit: Leaving]
Devon7 has joined #commonlisp
chomwitt has joined #commonlisp
rendar has quit [Ping timeout: 268 seconds]
rogersm_ has quit [Quit: Leaving...]
danza has quit [Ping timeout: 255 seconds]
tyson2 has joined #commonlisp
traidare has quit [Ping timeout: 260 seconds]
manwithluck has quit [Remote host closed the connection]
manwithluck has joined #commonlisp
_cymew_ has quit [Ping timeout: 260 seconds]
ymir has joined #commonlisp
k_hachig has joined #commonlisp
k_hachig has quit [Client Quit]
cage has quit [Quit: rcirc on GNU Emacs 29.1]
akoana has joined #commonlisp
akoana has quit [Client Quit]
akoana has joined #commonlisp
jmdaemon has joined #commonlisp
NicknameJohn has joined #commonlisp
josrr has quit [Remote host closed the connection]
josrr has joined #commonlisp
wacki_ has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
zetef has joined #commonlisp
elderK has joined #commonlisp
pfdietz has quit [Quit: Client closed]
tyson2 has quit [Read error: Connection reset by peer]
tok has quit [Remote host closed the connection]
chomwitt has quit [Ping timeout: 240 seconds]
akoana has quit [Quit: leaving]
akoana has joined #commonlisp
ronald_ has joined #commonlisp
rgherdt has quit [Quit: Leaving]
ronald has quit [Ping timeout: 264 seconds]
zetef has quit [Remote host closed the connection]
shka has quit [Ping timeout: 264 seconds]
pve has quit [Quit: leaving]
josrr has quit [Remote host closed the connection]
josrr has joined #commonlisp
thuna` has joined #commonlisp
amb007 has quit [Ping timeout: 255 seconds]
mzan has quit [Remote host closed the connection]
mzan has joined #commonlisp
dra has joined #commonlisp
dra has quit [Changing host]
dra has joined #commonlisp
lispmacs[work] has quit [Remote host closed the connection]
dino_tutter has quit [Ping timeout: 260 seconds]
jmdaemon has quit [Ping timeout: 268 seconds]
ebrasca has joined #commonlisp
Pixel_Outlaw has joined #commonlisp
markb1 has quit [Read error: Connection reset by peer]