<pillton>
whoman: Like I said, the fundamentals are very simple. You are talking about something higher level.
wxie has joined #lisp
<whoman>
where what? i was commenting on your words though
<pillton>
whoman: "IDL interface files". You don't need IDL interface files to understand the fundamentals of COM.
<whoman>
alright...
<pfdietz>
Technical churn like that is a way to get age discrimination without breaking the law.
<pjb>
In that case, it's not done on purpose. And it will end eventually.
<pjb>
The problem is the doubling of number of programmers every 5 years.
<pjb>
But as any exponential, this will end turning into a sigmoid and then it'll stabilize.
<pjb>
Of course, there's always the hope for singularity, to break any prediction.
haruka has joined #lisp
<pjb>
In the mean-time it means that in practice, you always have half the programmers with less than 5 years experience, ie. half the programmers are always newbies.
attila_lendvai has joined #lisp
<comborico1611>
I'm a newbie.
<pjb>
This is why you have so much new dumb technology, stuff like perl, python, ruby, node.js, etc.
<comborico1611>
I like Perl.
<pjb>
And cycles of course, since nothing really new has been invented in CS since the 60s.
<comborico1611>
Sigils?
<pjb>
basic.
<comborico1611>
Oh yeah? Hmm.
<pjb>
So the seasonned professional can avoid churn by realizing the spiral, and either follow the movement, or wait for the next cycle. :-)
Tobbi has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
attila_lendvai has quit [Read error: Connection reset by peer]
<pjb>
And of course, shell $foo ${foo[@]}, etc.
markong has quit [Ping timeout: 256 seconds]
<comborico1611>
Very knowledgeable.
fittestbits has quit [Ping timeout: 276 seconds]
ludston_ has joined #lisp
attila_lendvai has joined #lisp
<fouric>
mfiano: sly is awesome so far and i love the layer
attila_lendvai has quit [Read error: Connection reset by peer]
<fouric>
anything specific you wanted me to play around with?
<_death>
pjb: I found that many people assume you're either a web developer ("frontend or backend?") or a mobile developer ("android or ios?").. funny stuff
ludston has quit [Ping timeout: 256 seconds]
<pjb>
:-)
<mfiano>
fouric: Nothing in general. Thanks for testing it out.
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
attila_lendvai has joined #lisp
<fouric>
I'll poke you if I find issues or anything - I think that I'm just going to switch back to SLIME.
<mfiano>
What is it missing that SLIME has for you?
<fouric>
Nothing, but that's more a product of me not ever having sat down and read through the slime documentation.
<fouric>
I mostly use C-c C-c and C-c C-z lol
LiamH has quit [Quit: Leaving.]
<_death>
slime has documentation? :D .. well, I know it does.. and likely have read it when I started using it.. but the real documentation there is the source code
<fouric>
It *is*, yes
attila_lendvai has quit [Read error: Connection reset by peer]
<fouric>
but source code requires a lot of mental effort to read
<_death>
pratice
<mfiano>
fouric: You can do the same with Sly.
<fouric>
the energy required to set up a mental representation of a non-trivial codebase is significant
<_death>
*practice
<fouric>
at least for me
* fouric
will practice eventually but won't have time for the next 5 months
<_death>
also, it's lisp.. so you can just evaluate things in the repl to get an intuitive feel
<fouric>
mfiano: I saw - your list of keybindings on your README.md is really nice :)
<fouric>
the official Sly docs list the keybindings for a default (un-evilified) setup
Kaisyu has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<fouric>
_death: The SLIME client? Isn't that written in elisp?
<_death>
fouric: elisp is also lisp.. M-x ielm
<mfiano>
fouric: They are the same as the SLIME layer for the most part. You can also use Emacs style C-c C-c (not mentioned)
Amplituhedron has quit [Ping timeout: 268 seconds]
juan-reynoso has quit [Ping timeout: 264 seconds]
comborico1611 has quit [Quit: Konversation terminated!]
Guest53399 has quit [Read error: Connection reset by peer]
<fouric>
wat
nowhere_man has joined #lisp
<fouric>
ok, i don't know what i'm so surprised by the emacs lisp repl
<fouric>
mfiano: ty ty
<fouric>
ty _death, that'll be helpful when i'm trying to fix my emacs configs in the future
<_death>
fouric: ;)
ludston_ has quit [Read error: Connection reset by peer]
attila_lendvai has quit [Read error: Connection reset by peer]
z3t0 has quit [Remote host closed the connection]
smurfrobot has joined #lisp
z3t0 has joined #lisp
ludston has joined #lisp
SuperJen has joined #lisp
JenElizabeth has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
z3t0 has quit [Ping timeout: 256 seconds]
python476 has quit [Ping timeout: 264 seconds]
<mfiano>
fouric: What I mean to say is you aren't losing anything from the slime layer, only gaining
attila_lendvai has quit [Read error: Connection reset by peer]
<mfiano>
Except for the things you said you don't use, like the slime sbprof contrib
pagnol has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 264 seconds]
<jasom>
Shinmera: plump doesn't appear to support namespaces, so it can't even be wrong
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
Jesin has quit [Quit: Leaving]
<jasom>
Shinmera: it looks like plump is for xml-ish documents rather than being a true xml parser
smurfrobot has quit [Remote host closed the connection]
asarch has joined #lisp
<fouric>
mfiano: :D
<MetaYan>
beach: trivial-garbage mystery solved. lispbuilder includes an old version of trivial-garbage. Having lisp-builder in local-projects caused that version to be used.
stacksmith has quit [Ping timeout: 240 seconds]
haruka has quit [Ping timeout: 248 seconds]
damke_ has joined #lisp
<MetaYan>
beach: sorry, that was for phoe...
haruka has joined #lisp
<MetaYan>
phoe: trivial-garbage mystery solved. lispbuilder includes an old version of trivial-garbage. Having lisp-builder in local-projects caused that version to be used.
capitaomorte has joined #lisp
damke has quit [Ping timeout: 264 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
SuperJen has quit [Read error: Connection reset by peer]
SuperJen has joined #lisp
``Erik has quit [Ping timeout: 240 seconds]
EvW has quit [Ping timeout: 260 seconds]
``Erik has joined #lisp
fikka has joined #lisp
omilu has quit [Ping timeout: 248 seconds]
whyNOP has quit [Ping timeout: 268 seconds]
arescorpio has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
smurfrobot has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
jtroseme has quit [Quit: Leaving]
comborico1611_ has joined #lisp
<Xach>
dang. i meant to suggest ql:where-is-system earlier.
smurfrobot has quit [Ping timeout: 240 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
<MetaYan>
Xach: would have helped. Took a while to find the culprit.
<learning>
test
attila_lendvai has joined #lisp
beach` has joined #lisp
uuplusu has joined #lisp
uuplusu has quit [Remote host closed the connection]
himmAllRight17 has quit [Remote host closed the connection]
uuplusu has joined #lisp
himmAllRight has joined #lisp
Kaisyu7 has joined #lisp
<comborico1611_>
I'm just now finding about about NixOS.
beach has quit [Ping timeout: 256 seconds]
<MetaYan>
Xach: Thanks for the ql:where-is-system tip anyway. Here's what it shows in this case: http://termbin.com/gwnr
<learning>
ah so when i want to use lisp's if statement in other languages i just gotta google ternary
attila_lendvai has quit [Read error: Connection reset by peer]
<k-hos>
Is NixOS a Richard Nixon themed OS
<learning>
lol
attila_lendvai has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 248 seconds]
shifty has joined #lisp
smurfrobot has joined #lisp
fikka has joined #lisp
comborico1611_ has quit [Quit: Konversation terminated!]
comborico has quit [Quit: comborico]
smurfrobot has quit [Ping timeout: 264 seconds]
slyrus has joined #lisp
khisanth_ has quit [Ping timeout: 256 seconds]
capitaomorte has quit [Ping timeout: 248 seconds]
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
Arcaelyx has joined #lisp
khisanth_ has joined #lisp
<aeth>
learning: no
<aeth>
Follow the idioms of the language you use.
<aeth>
In CL, return values and expressions make the most sense, like having if return a value and use the result
<aeth>
Using ternary in other languages is rarely as clear as using if in Lisp ime if you directly translate between Lisp and some other language.
<aeth>
Lisp is just really good at working with expressions where many other languages look like a mess when you can try to write what seems like the exact same thing.
learning has quit [Remote host closed the connection]
fittestbits has joined #lisp
d4ryus1 has joined #lisp
<aeth>
(Of course, if multi-line expressions are painful in other languages, maybe the problem is with the syntax of the other languages.)
smurfrobot has joined #lisp
d4ryus has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Ping timeout: 268 seconds]
makomo_ has quit [Ping timeout: 264 seconds]
zmt01 has quit [Quit: Leaving]
zmt00 has joined #lisp
<k-hos>
I keep trying to call lisp functions like this; (f(x))
<k-hos>
its like I am forgetting I am using lisp half way through
<aeth>
The main reason I wrote define-shader to translate from s-expressions to GLSL is because I kept slipping up in the syntax by switching back and forth between GLSL and CL and it was getting annoying.
<aeth>
Apparently, I can't handle mixing two syntaxes in the same program.
<attila_lendvai>
is there a simple way to muffle compiler notes when loading with asdf?
<attila_lendvai>
this seems to do the trick: (setf uiop:*uninteresting-conditions* uiop:*usual-uninteresting-conditions*)
ludston has quit [Quit: -a- IRC for Android 2.1.38]
<aeth>
you could look at how Quicklisp does it
<aeth>
Quicklisp hides it by default, unless you turn verbose on
zaquest has joined #lisp
<aeth>
oh, wait, that's a separate thing
kajo has quit [Remote host closed the connection]
kajo has joined #lisp
learning has joined #lisp
deng_cn has quit [Ping timeout: 268 seconds]
damke has joined #lisp
deng_cn has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
learning has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 264 seconds]
attila_lendvai has joined #lisp
deng_cn1 has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
haruka has quit [Ping timeout: 268 seconds]
deng_cn has quit [Ping timeout: 240 seconds]
deng_cn1 is now known as deng_cn
beach` is now known as beach
haruka has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
arescorpio has quit [Excess Flood]
Jen has joined #lisp
SuperJen has quit [Read error: Connection reset by peer]
attila_lendvai has quit [Read error: Connection reset by peer]
<beach>
Good morning everyone!
<beach>
MetaYan: That does not look like a CLIM listener problem.
attila_lendvai has joined #lisp
<beach>
flip214: I think I'll pass on the Alexandria issue. I have too many other things to do at the moment.
wxie has quit [Quit: AtomicIRC: The nuclear option.]
mareskeg has joined #lisp
mareskeg has quit [Client Quit]
<fouric>
mfiano: would you, or anyone else, happen to know how to override evil-cleverparens' bindings?
lnostdal has quit [Ping timeout: 255 seconds]
learning has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
attila_lendvai has quit [Read error: Connection reset by peer]
ben3 has left #lisp ["WeeChat 1.9.1"]
Jen has quit [Read error: Connection reset by peer]
Jen has joined #lisp
Jen has quit [Read error: Connection reset by peer]
Jen has joined #lisp
Jen has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
ninegrid has quit [Quit: leaving]
Jen has joined #lisp
Jen has quit [Read error: Connection reset by peer]
nika has joined #lisp
gabiruh has quit [Read error: Connection reset by peer]
groovy2shoes has quit [Quit: moritura te salutat]
attila_lendvai has quit [Read error: Connection reset by peer]
gabiruh has joined #lisp
attila_lendvai has joined #lisp
deng_cn has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
deng_cn has joined #lisp
shifty has quit [Ping timeout: 255 seconds]
Achylles has quit [Remote host closed the connection]
shifty has joined #lisp
pjb has quit [Remote host closed the connection]
dessm has joined #lisp
pjb has joined #lisp
Meow-J_ has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
gabiruh has quit [Read error: Connection reset by peer]
Meow-J_ has joined #lisp
gabiruh has joined #lisp
sysfault_ has joined #lisp
sysfault_ has quit [Client Quit]
Cymew has quit [Ping timeout: 260 seconds]
sysfault_ has joined #lisp
sysfault has quit [Read error: Connection reset by peer]
sysfault_ is now known as sysfault
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
learning has quit [Remote host closed the connection]
pjb has quit [Remote host closed the connection]
smokeink has joined #lisp
schoppenhauer has quit [Ping timeout: 256 seconds]
marusich has quit [Ping timeout: 264 seconds]
schoppenhauer has joined #lisp
marusich has joined #lisp
krwq has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
<krwq>
got question, how do you convert string to utf-8 bytes? I've tried this but flexi-streams seem to be ignoring format: https://pastebin.com/DGkUCLnB
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<beach>
If there is no library to do it, you would just have to apply the rules of UTF-8. They are not that complicated.
<Bike>
there are libraries to do it, though
<Bike>
i think babel rather than flexi streams. not sure.
* beach
now fully expects a complaint that the Common Lisp standard is deficient, since it doesn't define such a function.
smurfrobot has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
dieggsy has quit [Ping timeout: 276 seconds]
smurfrobot has quit [Ping timeout: 255 seconds]
marusich has quit [Ping timeout: 263 seconds]
marusich has joined #lisp
<Bike>
if i understand the flexi streams manual correctly, in memory streams are binary, and don't have external formats so you can't use characters
<krwq>
beach: Bike: do you know any library providing a way to convert string to utf-8 without allocating new buffer (= using preallocated buffer)
<beach>
Not me. Sorry.
<krwq>
np
<pierpa>
you can write it yourself in very few lines
<beach>
Seriously, it is probably at most 15 lines of code.
<pierpa>
pillton: that allocates a new buffer, I think
<Bike>
oh, preallocated
<Bike>
well that's probs in babel too
<krwq>
thanks, I'll see if there is a way to hack babel a little not to allocate
<nydel>
i'm curious why MOD and FLOOR both exist in any implementation i can think of. MOD in my mind being (CDR (FLOOR X)) ... is MOD actually quite a different program than that? documentation in sbcl or clisp offers little on how they are related.
Kevslinger has quit [Quit: Connection closed for inactivity]
<krwq>
nydel: try (mod 1.3 0.7)
<beach>
nydel: You can't take the CDR of what FLOOR returns.
<beach>
It is not a CONS cell.
<krwq>
he probably meant nth-value
ja-barr has quit [Ping timeout: 248 seconds]
gabiruh has quit [Ping timeout: 256 seconds]
Elite-Epochs has quit [Ping timeout: 240 seconds]
<krwq>
hmm, I didn't realize floor works with non-integer divisors
<beach>
nydel: There are several possible explanations. One (very likely) is that MOD exists for reasons of backward compatibility with other Lisp implementations.
<Bike>
the clhs entry on mod says: "mod performs the operation floor on number and divisor and returns the remainder of the floor operation."
<Bike>
that's a pretty explicit relation
<nydel>
beach: thank you (CADR i meant to write
<beach>
nydel: Sorry, won't work either.
<beach>
nydel: Like I said, FLOOR doesn't return a CONS cell.
ja-barr has joined #lisp
<beach>
nydel: Another one is that it is more costly in terms of performance to manipulate multiple values, so MOD is probably faster than to use FLOOR and then take the second value.
gabiruh has joined #lisp
<beach>
nydel: And if you were right that FLOOR returns a list, then MOD would be WAY faster, because memory allocation is expensive as well.
<nydel>
beach: it doesn't return a list at all, that's right, thank you & my mistake
<nydel>
i somehow have taken clhs out of my things-i-can-immediately-reach circle, i need to remedy that, thanks Bike
<beach>
But yeah, there are two common competing discussion here in #lisp. 1. Why is this very special function that I need not in the standard. I mean, almost everybody needs it right. 2. Why is this general function in the standard when the effect can easily be obtained form combining other functions in the standard.
<beach>
I am guessing that neither of these two discussions exist for languages that don't even have a standard, which seems to be what many people use these days. Somehow, having a solid, well tested, reliable, fixed standard, seems to be a disadvantage to a language.
<beach>
<nydel>
but beach in a brighter pov my meaning was to find out "what's the thing i usually look at for a question like this?" and the answer was CLHS ... i have no opinion one way or the other on whether one/both exist, the question was about where i was failing to keep my documentation complete
nowhere_man has quit [Ping timeout: 255 seconds]
Elite-Epochs has joined #lisp
<nydel>
i never feel that commonlisp is lacking in documentation, and that is largely i would believe because of it having a standard.
<beach>
nydel: Sure. I just took this opportunity to complain about common complaints.
<beach>
So you weren't the selected target.
<pillton>
We should burn the standard.
<beach>
:)
<pillton>
Our lives it would become easier!
<nydel>
i definitely see the two points discussed in circles all over the place and never directly
<pillton>
s/it//
<nydel>
enter pillton to directly address it right as i claim it's never directly addressed :)
<beach>
Both types of complaints, by the way, are typically aired by people who know nothing about language design, nothing about language implementation, and nothing about the history of Lisp.
<pillton>
Who needs these things to promote interoperability? #+(me) #+(and) #-(others) all the way down.
Arcaelyx has quit [Ping timeout: 240 seconds]
<krwq>
nydel: btw if you use emacs you can move your cursor on the symbol in slime and C-c C-d h
Arcaelyx_ has joined #lisp
<nydel>
krwq: thank you - i haven't had a question like this in a while (i rarely use #'MOD but it came up in a japanese lisp book - a predict the day of the week function, you get it) so i forgot it exists(CLHS) .. good to have the keystrokes, thank you!
damke has quit [Read error: Connection reset by peer]
damke has joined #lisp
<nydel>
ok so pillton are you going to fork sbcl to sbcl-unstandardized-b'tches! or is beach gonna handle that
<krwq>
beach is creating his own compiler
<pillton>
nydel: It took 10 years for me to find things in CL that I annoy me enough to transition from apathetic to emotional.
<nydel>
oh! that's on my reverse bucket list i think
<whoman>
there is also 3. implementation-specific topics
<whoman>
on the flip side of having a standard, it also leads to nonstandardness
<whoman>
such is the way of things one would guess
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<Zhivago>
The flip side of standards is that they eat their chldren.
<Zhivago>
The only hope is that the standard evolves in the process.
<whoman>
evolving standard? big small, dumb smart fast slow ?
terpri has quit [Ping timeout: 276 seconds]
<whoman>
ES6 et al. ?
<beach>
pillton: No problem, be my guest.
<beach>
krwq: The Cleavir compiler framework is meant to be just that. In fact, it is already used by Clasp for its main compiler.
<beach>
nydel: SICL is not finished so I recommend against trying to build it.
gabiruh has quit [Ping timeout: 248 seconds]
attila_lendvai has quit [Ping timeout: 260 seconds]
gabiruh has joined #lisp
marusich has quit [Ping timeout: 264 seconds]
marusich has joined #lisp
Oladon has quit [Quit: Leaving.]
whatsupdoc has joined #lisp
djinni` has quit [Quit: Leaving]
djinni` has joined #lisp
marusich has quit [Ping timeout: 256 seconds]
marusich has joined #lisp
whatsupdoc has left #lisp ["Closing Window"]
damke_ has joined #lisp
smasta has quit [Quit: WeeChat 2.0.1]
damke has quit [Ping timeout: 264 seconds]
smasta has joined #lisp
<krwq>
beach: any ideas why is this (let ((.foo))`(,.foo)) saying that `foo` is unbound? (I know I can add space between comma and dot and that this is a bad idea to name vars like that)
<beach>
Yes.
<beach>
,. means something in the backquote macro.
<beach>
Try (let ((.foo))`(, .foo)) instead.
<krwq>
beach: I see - this is to signalize that this is destructive
<krwq>
thanks
<beach>
It's a variant of ,@ that can be used to when it is safe to modify the list.
<beach>
Nobody uses it in practice.
<krwq>
I've never seen that so thought it might be a bug or something else I might be missing
<beach>
I understand.
smurfrobot has joined #lisp
<fouric>
beach: do you have a minute to elaborate on what "implementation-independent compilation framework" means (context: SICL)?
<beach>
Sure.
marusich has quit [Ping timeout: 260 seconds]
<beach>
It means that the compiler is written so that it can be customized to implementation-specific details.
asarch has quit [Remote host closed the connection]
<beach>
Otherwise, it is common that implementation-specific details are scattered all over the compiler source code.
<fouric>
...such as using a preallocated pool of cons cells, for instance?
<beach>
I hadn't thought about that.
smurfrobot has quit [Ping timeout: 256 seconds]
<fouric>
(I'm just trying to find a few concrete examples of "implementation-specific details")
* fouric
thinks of SBCL as being *all* implementation-specific details
<beach>
But take the situation where the compiler needs to interrogate the environment for information about variables and functions.
* fouric
takes it
<beach>
Normally, that's all implementation-specific stuff.
Arcaelyx_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
The Cleavir compiler defines a CLOS-based protocol for doing that, and it explains what an implementation must do to customize that protocol so that the Cleavir compiler can use it.
marusich has joined #lisp
fikka has joined #lisp
<beach>
Furthermore, the Cleavir compiler uses an intermediate form called HIR (for High-level Intermediate Representation) that is independent of how objects are represented in a particular implementation. On this representation, we can do several transformations such as type inference, escape analysis, etc.
<beach>
Again, your typical Common Lisp compiler will have object-representation details scattered all over it.
<beach>
There are a few instances where HIR (and also the preceding representation: AST) need to be customized for each implementation, but again, there are CLOS protocols put in place to make this customization straightforward, using auxiliary methods on generic functions.
<beach>
But take the SBCL compiler, for instance. It couldn't do something like that as easily, because it was designed not to use generic functions, for reasons of bootstrapping.
<fouric>
Hm. Let me see if I'm getting this right: would the following example be correct: Cleavir providing an implementation of FUNCALL that calls generic functions to get the symbol-function from a symbol, and each compiler implements the generic function that does so?
<beach>
Close.
<beach>
Cleavir defines a generic function called FUNCTION-INFO that it calls when it needs information about a function (whether it's a macro, whether it has a compiler macro on it, its type, etc).
<beach>
One of the arguments to FUNCTION-INFO is a function name, and the other is an object representing a global environment.
fikka has quit [Ping timeout: 256 seconds]
<beach>
Implementations customize this generic function by defining a method on it that will specialize on some implementation-specific environment object, and then call the implementation-specific function to build the information that the Cleavir compiler needs.
<beach>
So, for example, SICL doesn't store the function in the symbol object, but instead in the environment objects, so the methods are very different in SICL and (say) Clasp.
<beach>
Does that make sense to you?
pierpa has quit [Quit: Page closed]
<fouric>
I think that it does!
<fouric>
I don't understand what "environment objects" are, but I think that I can guess at the relevant bits well enough to understand Cleavir's purpose as a whole.
<fouric>
That was a very clear explanation - thank you!
<beach>
SICL has an explicit object that store the environment information, but most implementations scatter this information all over, like the function being stored in the symbol, and the type information in some hash table, etc.
<fouric>
For performance reasons?
<beach>
Which one, SICL or the others?
<fouric>
The others
<beach>
Mainly because nobody thought of a technique that have the same performance but a more modular environment object. Hence the paper. Also, for historical reasons.
<fouric>
...although this paper makes it sound like you implemented SICL's "global environment as first-class object" approach without much of a performance hit
<beach>
When people see SYMBOL-FUNCTION they immediately think the function must be stored in the symbol
<beach>
Correct.
haruka has quit [Ping timeout: 256 seconds]
<beach>
So, an implementation that does not have an explicit object for the environments will customize Cleavir by creating a dummy environment class that is only used for generic-function dispatch, and the method specializing on that class will just call the implementation-specific functions to gather the information.
saki has joined #lisp
* fouric
nods
<beach>
I know of no other Common Lisp compiler that has been specifically designed this way, which is why I call Cleavir an implementation-independent compiler framework.
<whoman>
how it should be =)
<fouric>
Does Cleavir do any (native) code generation, or is that all deferred to the implementation itself?
<whoman>
afaik the GL world calls it a "reference implementation" - like how Mesa is sometimes used
<beach>
At the moment, it is up to the implementation. Mainly because the only client implementation is Clasp, and it already does its own code generation.
<fouric>
OK, I think that I have a rough understanding of Cleavir now.
<beach>
fouric: It gets harder after HIR. The next layer is MIR (Medium-level Intermediate Representation) where object representations are exposed and address calculations are made explicit.
<fouric>
I definitely don't "grok" it, but at least I see how it works, more or less.
<fouric>
o
<fouric>
there's more???
<Bike>
iit's a whole compiler of course there's more
<Bike>
compilers are big
d4ryus1 is now known as d4ryus
* fouric
was jk, compilers are big
<fouric>
well
<fouric>
*fast* compilers are big
<beach>
fouric: The MIR layer requires way more customization than HIR, and it has not all been worked out. But we need it, because we plan to implement optimizations in MIR as well.
<beach>
fouric: Like loop-invariant code motion and such.
<beach>
I think I will first hash out MIR for SICL, and then see what generic function are needed to generalize it to other implementation.
<beach>
Oh, and MIR may also depend (at least somewhat) on the backend, like what kind of instructions the processor is capable of.
LocaMocha has joined #lisp
<aeth>
Is there any advantage to actually creating an object at compile time in a macro and using make-load-form instead of essentially generating code that will at run time create the object?
<Bike>
but no there's not a speed advantage or whatever
<Bike>
maybe something can deal with it as a constant who knows
<aeth>
It would be great
<aeth>
I essentially have an elaborate group of things that's done entirely at compile time, and then is just constant data by the time run time comes
<aeth>
And it'd only get more elaborate, since I'm probably only 10% done this
<aeth>
s/this/with this/
<fouric>
beach: Thanks for the explanation!
<fouric>
I will watch Cleavir with great interest
* fouric
dreams of creating a complete Lisp phone or computer some day
<aeth>
fouric: That's not dreaming big enough
<aeth>
fouric: Describe the hardware itself in Lisp, now that RISC-V exists as an open instruction set.
<fouric>
O.o
<fouric>
Yes!
<fouric>
Well
<fouric>
I was thinking of a HDL with an s-expression syntax
<fouric>
and macros in CL
<aeth>
definitely doable
<fouric>
...I don't think that you would want the HDL itself to be CL
<fouric>
HDLs tend to be very declarative
<fouric>
which CL isn't very much
<fouric>
Hm, I don't suppose that anyone here would know of a LLVM-based CL implementation?
<aeth>
There are multiple efforts to generate JavaScript and multiple efforts to generate GLSL. So generating VHDL and/or Verilog probably wouldn't be too hard.
<Bike>
clasp. that's about it
<fouric>
Wait, that's Clasp.
dessm has quit [Remote host closed the connection]
* fouric
just realize
<fouric>
d
<fouric>
ty Bike
<whoman>
=/ curious why no other llvm efforts? theres several for a lot of langs, i notice today
<aeth>
whoman: The Lisp community doesn't like duplicated efforts.
<Bike>
because most lisp compiler infrastructures are old and nontrivial to modify
<whoman>
lol i think that is a terrible answer aeth
<Bike>
also there's not much reason to modify an old implementation that works
<whoman>
Bike: okay, makes sense, thats what my gut felt
<whoman>
yeah =)
<aeth>
Adding to what Bike says, everything is going to be benchmarked against SBCL
<aeth>
So if you're making a new CL, the bar is fairly high
mishoo has joined #lisp
krwq has quit [Remote host closed the connection]
<aeth>
It's not like making a new Python or Ruby implementation
<aeth>
s/the bar/the performance bar/
<whoman>
i was wondering what bar you are talking about.
Karl_Dscc has joined #lisp
<MetaYan>
beach: Exactly.
Vicfred has joined #lisp
jstypo has quit [Ping timeout: 240 seconds]
<beach>
fouric: Sure. I feel like I had a very productive morning explaining important Cleavir concepts to at least one interested listener.
python476 has joined #lisp
<beach>
whoman: Another reason is that LLVM is mainly a C++ library, so it is non-trivial to interface to, and that LLVM is mainly designed for compiling C++-like languages, so the fit is not perfect for compiling Common Lisp. Case in point, Clasp uses C++ exceptions to implement non-local exists in Common Lisp, and C++ exceptions were not meant to be used that often, so they are very slow.
<whoman>
beach: oh geez, that is terrible =( i did not know that. i thought JVM and CLR were specific enough already
<beach>
whoman: Yet another reason is that LLVM is a moving target, so that if one were to use some essential feature to implement Common Lisp, then that feature may disappear or get modified in future versions of LLVM.
<Bike>
i think that might be due to a choice to use C++ abi functions, rather than llvm itself strictly
<Bike>
not sure though
<beach>
Possibly.
<beach>
But then, LLVM does not suggest an alternative that can be used with Common Lisp or other similar languages.
<Bike>
well it has its own low level mechanism. i actually think it could be a good fit for CL, but i haven't gone into it much
<beach>
I hope you are right.
<Bike>
it's built for C++ which sometimes, but not all the time, needs to execute arbitrary code upon exiting a scope, which is true for C++ with desctructors, and for CL with unwind-protect
<beach>
whoman: More reasons: Apparently, LLVM has problems with code that moves, probably because that doesn't happen in C++ since it doesn't have GC. So Clasp (as I recall) can currently not move code or recover space when a function is redefined.
<beach>
Maybe this has improved lately.
<beach>
The right thing to do here would be to write a system similar to LLVM, but written in Common Lisp and designed for dynamic languages. It is a big project, but not huge. It would be much simpler than LLVM because of the superior abstraction mechanism we have at our disposal.
<whoman>
today i heard that c++ gets nasty-slow when it gets into a thing called 'chain of destructors' or somesuch. sounds scary -- been close to it in my day
<Bike>
writing something like LLVM seems pretty huge
<whoman>
beach: hmm, yes i see, hmm
<beach>
Bike: It probably seems bigger than it really is because 1. It is written in C++ and 2. It is designed to handle all the obscure stuff of C++.
<Bike>
whoman: yeah when you exit a scope you have to run destructors for any automatic-allocation objects, and those destructors can run other destructors, and so on
<Bike>
llvm is a backend, it doesn't even deal with destructors or anything directly
<whoman>
BEAM
<beach>
Though perhaps the MIR and LIR levels of Cleavir can play the role of LLVM some day.
<Bike>
and there's lots of complicated stuff in there for, like, reordering conditions based on... path... I'm tired
<beach>
Oh, wow, late for you.
<Bike>
branch prediction
jstypo has joined #lisp
<jack_rabbit>
I'm surprised. I didn't realize LLVM had such restrictions.
<Bike>
which restrictions?
<beach>
Like being a C++ library?
<whoman>
brunch predeliction
<jack_rabbit>
such as the inability to move code
<Bike>
that's annoying, yes
<Bike>
i think it can move code
<Bike>
LLVM's JIT code thing uses mmap by default, but there's stuff to allow customization
fikka has joined #lisp
<jack_rabbit>
Bike, Yes, I would be very surprised to find out there isn't. But beach has done far more work with it than I.
<Bike>
clasp has to do more conceptual work before it can even worry about that though. making sure we don't gc a function we're in the middle of, and so on
<Bike>
i don't think beach has worked with llvm
<Bike>
he's just observed me and drmeister being frustrated with it
<jack_rabbit>
oh. I thought he had worked on clasp
<Bike>
he works on sicl, including cleavir, which clasp uses
<jack_rabbit>
I see.
<Zhivago>
There's nothing particularly special about chains of destructors -- it's pretty much the same as unwind-protect.
<whoman>
Zhivago: i was reading how it causes worse "performance" issues than GC
<Bike>
that seems like apples and oranges
<whoman>
(in regards to c++)
<Zhivago>
The fundamental problem with destructors is that they don't make sense in systems with GC.
<whoman>
sure they do -- release file handles and such
<whoman>
close windows, flush streams
<Bike>
nah
<Zhivago>
That's not what a destructor does.
<Bike>
C++ uses them more
<whoman>
destruct...ion
<Bike>
since you know when objects are released, you can use them for, basically, unwind protect
<Zhivago>
A destructor is code that runs sometime after the reference count to an object reaches zero.
<Bike>
RAII and stuff
<Bike>
RAII makes no sense if dynamic extent is optional, like it is in lisp
<Zhivago>
Which is problematic for a destructor, since a destructor needs access to the object.
<aeth>
whoman: If CL was like SH, then "destruct" would be a thing with the api (destruct &rest ignored) that destroys your drive. Then you'd never be able to typo "defstruct"
<Zhivago>
Which means that the reference count is really above zero, and then you have the issue if what happens if the destructor generates new references to the object which would bring it above the destruction level?
<Zhivago>
Which is why objects in Java can be resurrected from the dead, and have to remember if they've been destructed or not.
<beach>
jack_rabbit: I have not worked with LLVM. I wouldn't. I am just following the discussions in #clasp.
<Zhivago>
Which is why GC systems that aren't designed by insane people used finalizer semantics instead, which do not involve the object that has been GC'd.
<aeth>
Bike: What changes would have to be made to bring RAII to CL, if that even makes any sense at all?
<Bike>
why would you want that
<Zhivago>
(let ...) plus (unwind-protect ...) give you RAII.
<Bike>
in CL we can just unwind protect to say "execute this when you leave this block" and we don't need to bother with tying it to objects
<Zhivago>
Well, plus (dynamic-extent).
<Zhivago>
These are often tied together using (with-foo ...) macros.
<beach>
whoman: Code that must be run sometime after an object is no longer accessible is problematic in all GC systems that explicitly do not touch dead objects, like copying collectors.
<Zhivago>
It just requires sharing those resources with a suitable finalizer, rather than mediating access to them through the object.
<Zhivago>
A more serious problem is the lack of generalized resource management integration with garbage collection.
<Zhivago>
If your GC is responsible for freeing up file handles, what happens if running out of file handles doesn't invoke GC?
kajo has quit [Ping timeout: 255 seconds]
<Zhivago>
If you have optional resources -- like file handles that could be closed or kept open for performance, who tells you that there's a shortage and would you kindly close the handles you don't really need right now?
vlatkoB has joined #lisp
<Zhivago>
GC allows all of these things to be deferred whereas RAII forces them to be eager -- and that requires a more thorougher design.
kajo has joined #lisp
Bike has quit [Quit: Lost terminal]
terpri has joined #lisp
<Zhivago>
On the other hand GC is kind of a symptom of the problems of undisciplined shared memory, so perhaps it's just enabling the problems that it solves, and we might be better off by replacing it with restricted memory arenas.
<aeth>
How do you do linked lists without GC? Because linked lists without GC look painful.
<aeth>
(I think I know why Lisp invented GC)
<Zhivago>
It depends on how long you expect them to live.
<Zhivago>
If they're contained in an ephemeral process, maybe you just don't care, because you'll send the final non-garbage somewhere else, and then disappear.
<Zhivago>
(Which is a kind of GC, but with radically different requirements, since you can't just scribble on the one true graph of objects, since there isn't one.
Karl_Dscc has quit [Remote host closed the connection]
<whoman>
reference counting
<Zhivago>
Or you could say that GC is a problem of implicit persistent storage, and solve it by not having any.
<Zhivago>
Reference counting is GC, although often too stupid to handle cycles.
<Zhivago>
So that doesn't help much.
mishoo has quit [Ping timeout: 248 seconds]
<flip214>
beach: no worries (about alexandria)!
<Zhivago>
But imagine if every function call happened in its own temporary process, receiving arguments via a message and sending a result via a message (effectively).
<whoman>
linked list of reference counts =P
<Zhivago>
Would such a function require GC?
<whoman>
the process gets GC'd
<whoman>
somewhere along the line, garbage is collected, memory regions are marked
<Zhivago>
The process gets destroyed, but that doesn't involve any garbage collection.
<Zhivago>
If the function is implemented as a procedure which happens to produce garbage, then you might need something if it runs out of resources to recycle that garbage.
<Zhivago>
But if it doesn't, then no recycling is required, and that recycling is what GC algorithms are about.
<whoman>
'temporary process' - what happens ...
<Zhivago>
I don't think that you're following the argument.
Tobbi has joined #lisp
<whoman>
there is no argument. because listen, there is a law of relative space in effect here. objects cut from fabric cannot be larger than the original fabric. and so on, recursively as we cut out of the main fabric
<phoe>
Zhivago: hm.
<whoman>
at some point everything is recycled back to the fabric, all being 'temporary' -- there is always garbage being collected no ?
<Zhivago>
whoman: You appear to be gibbering. I will stop talking to you until you become coherent.
<whoman>
you dont understand, that is fine. it is not fair to make it my fault. back to work.
<aeth>
oh, hey, it might be a speed advantage to use make-load-form on things that are constant
<aeth>
I disassembled the function the macro generated and it's 24 bytes
<aeth>
(in SBCL)
<aeth>
and it runs incredibly quickly, 2000-3000ish cycles
<aeth>
CCL seems to be similarly quick and with a similarly concise disassembly.
<aeth>
This changes everything.
smokeink has quit [*.net *.split]
sysfault has quit [*.net *.split]
oleo has quit [*.net *.split]
rjeli has quit [*.net *.split]
rumbler31 has quit [*.net *.split]
hvxgr_ has quit [*.net *.split]
ioa_ has quit [*.net *.split]
kotrcka has quit [*.net *.split]
z0d has quit [*.net *.split]
mood has quit [*.net *.split]
CEnnis91 has quit [*.net *.split]
mhitchman[m] has quit [*.net *.split]
hiq[m] has quit [*.net *.split]
RichardPaulBck[m has quit [*.net *.split]
dxtr has quit [*.net *.split]
phoe has quit [*.net *.split]
kjeldahl has quit [*.net *.split]
alphor has quit [*.net *.split]
norserob has quit [*.net *.split]
gabiruh has quit [*.net *.split]
schoppenhauer has quit [*.net *.split]
vibs29 has quit [*.net *.split]
raynold has quit [*.net *.split]
foom has quit [*.net *.split]
razzy has quit [*.net *.split]
banjiewen has quit [*.net *.split]
eatonphil has quit [*.net *.split]
salva has quit [*.net *.split]
grumble has quit [*.net *.split]
Tordek has quit [*.net *.split]
vert2 has quit [*.net *.split]
flamebeard has joined #lisp
flamebeard has quit [Remote host closed the connection]
flamebeard has joined #lisp
raynold has joined #lisp
dmiles has quit [Ping timeout: 252 seconds]
scymtym has quit [Remote host closed the connection]
mishoo has joined #lisp
quazimodo has quit [Ping timeout: 248 seconds]
zmt00 has quit [Ping timeout: 256 seconds]
dmiles has joined #lisp
parjanya has joined #lisp
smurfrobot has joined #lisp
gabiruh has joined #lisp
schoppenhauer has joined #lisp
vibs29 has joined #lisp
razzy has joined #lisp
foom has joined #lisp
grumble has joined #lisp
salva has joined #lisp
eatonphil has joined #lisp
vert2 has joined #lisp
banjiewen has joined #lisp
Tordek has joined #lisp
razzy has quit [Max SendQ exceeded]
smurfrobot has quit [Ping timeout: 264 seconds]
razzy has joined #lisp
smurfrobot has joined #lisp
luis` has quit [Ping timeout: 260 seconds]
smokeink has joined #lisp
sysfault has joined #lisp
oleo has joined #lisp
rjeli has joined #lisp
hvxgr_ has joined #lisp
rumbler31 has joined #lisp
z0d has joined #lisp
kotrcka has joined #lisp
CEnnis91 has joined #lisp
ioa_ has joined #lisp
mood has joined #lisp
phoe has joined #lisp
dxtr has joined #lisp
mhitchman[m] has joined #lisp
RichardPaulBck[m has joined #lisp
hiq[m] has joined #lisp
kjeldahl has joined #lisp
norserob has joined #lisp
alphor has joined #lisp
luis has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
hiq[m] has quit [Ping timeout: 240 seconds]
RichardPaulBck[m has quit [Ping timeout: 240 seconds]
eatonphil has quit [Ping timeout: 255 seconds]
kumori[m] has quit [Ping timeout: 255 seconds]
katco[m] has quit [Ping timeout: 255 seconds]
plll[m] has quit [Ping timeout: 255 seconds]
hdurer[m] has quit [Ping timeout: 255 seconds]
equalunique[m] has quit [Ping timeout: 255 seconds]
CharlieBrown has quit [Ping timeout: 255 seconds]
kfdenden[m] has quit [Ping timeout: 252 seconds]
smurfrob_ has joined #lisp
cryptomarauder has quit [Ping timeout: 260 seconds]
kammd[m] has quit [Ping timeout: 260 seconds]
dirb has quit [Ping timeout: 256 seconds]
Jach[m] has quit [Ping timeout: 256 seconds]
ArthurAGleckler[ has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Remote host closed the connection]
mhitchman[m] has quit [Ping timeout: 269 seconds]
Ven`` has joined #lisp
dmiles has quit [Ping timeout: 256 seconds]
schweers has joined #lisp
schweers has quit [*.net *.split]
Ven`` has quit [*.net *.split]
smokeink has quit [*.net *.split]
sysfault has quit [*.net *.split]
oleo has quit [*.net *.split]
rjeli has quit [*.net *.split]
rumbler31 has quit [*.net *.split]
hvxgr_ has quit [*.net *.split]
z0d has quit [*.net *.split]
ioa_ has quit [*.net *.split]
kotrcka has quit [*.net *.split]
mood has quit [*.net *.split]
CEnnis91 has quit [*.net *.split]
dxtr has quit [*.net *.split]
phoe has quit [*.net *.split]
kjeldahl has quit [*.net *.split]
alphor has quit [*.net *.split]
norserob has quit [*.net *.split]
gabiruh has quit [*.net *.split]
schoppenhauer has quit [*.net *.split]
vibs29 has quit [*.net *.split]
foom has quit [*.net *.split]
banjiewen has quit [*.net *.split]
salva has quit [*.net *.split]
grumble has quit [*.net *.split]
vert2 has quit [*.net *.split]
Tordek has quit [*.net *.split]
fikka has joined #lisp
dmiles has joined #lisp
Ven`` has joined #lisp
Cymew has joined #lisp
Tordek has joined #lisp
banjiewen has joined #lisp
foom has joined #lisp
vibs29 has joined #lisp
salva has joined #lisp
grumble has joined #lisp
vert2 has joined #lisp
gabiruh has joined #lisp
damke has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
python476 has quit [Ping timeout: 240 seconds]
schoppenhauer has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
smurfrob_ has quit [Remote host closed the connection]
rjeli has joined #lisp
mood has joined #lisp
hvxgr has joined #lisp
phoe has joined #lisp
schweers has joined #lisp
norserob has joined #lisp
z0d has joined #lisp
dxtr has joined #lisp
ioa has joined #lisp
smokeink has joined #lisp
sysfault has joined #lisp
kjeldahl has joined #lisp
alphor has joined #lisp
fikka has joined #lisp
oleo has joined #lisp
rumbler31 has joined #lisp
CEnnis91 has joined #lisp
norserob has quit [Client Quit]
norserob has joined #lisp
norserob has quit [Client Quit]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
scymtym has joined #lisp
smurfrobot has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
Amplituhedron has joined #lisp
deng_cn has quit [Ping timeout: 256 seconds]
deng_cn1 has joined #lisp
<hjudt_>
i have a problem with dexador: if i use (dex:head "https://my-host/url" :verbose t :headers '(("Accept" . "application/json"))) then i can see in the server response it would send me json. but when i use (dex:get "https://my-host/url" :verbose t :headers '(("Accept" . "application/json"))), the server sends me back "application/xml". however, when i use wget -O - --header "Accept: application/json", the
<hjudt_>
server sends me json as expected. any idea what's wrong?
smurfrobot has joined #lisp
<hjudt_>
(perhaps i should add that the server can respond with json or xml depending on the accept header i send it)
deng_cn1 is now known as deng_cn
kotrcka has joined #lisp
kammd[m] has joined #lisp
damke has quit [Ping timeout: 264 seconds]
<hjudt_>
strange thing is that dexador verbose output tells me it does set "Accept: application/json". so what's the difference between dexador and wget here?
Ven`` has quit [Read error: Connection reset by peer]
vaporatorius has joined #lisp
vap1 has joined #lisp
milanj has joined #lisp
uuplusu has quit [Remote host closed the connection]
makomo_ has joined #lisp
pjb has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
renard_ has quit [Ping timeout: 240 seconds]
MrMc has joined #lisp
Murii has joined #lisp
groovy2shoes has joined #lisp
renard_ has joined #lisp
glv has joined #lisp
Amplituhedron has quit [Read error: Connection reset by peer]
vaporatorius has quit [Quit: Leaving]
papachan has joined #lisp
<shrdlu68>
hjudt_: Easiest thing to do is probably to inspect the traffic with something like wireshark
smurfrobot has joined #lisp
eudoxia has joined #lisp
Kevslinger has joined #lisp
EvW has joined #lisp
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
damke has quit [Ping timeout: 264 seconds]
smurfrobot has quit [Remote host closed the connection]
Cymew_ has joined #lisp
damke has joined #lisp
jtroseme has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew_ has quit [Ping timeout: 248 seconds]
eudoxia has quit [Quit: Leaving]
nika has quit []
Ven` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
pagnol has joined #lisp
willmichael has quit [Ping timeout: 240 seconds]
grumble has quit [Quit: and I keep telling myself it's all in my head]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
willmichael has joined #lisp
grumble has joined #lisp
rstandy has joined #lisp
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
smurfrobot has joined #lisp
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
osifjosdfji has joined #lisp
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
osifjosdfji has quit [Client Quit]
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
shoogz has joined #lisp
shoogz has quit [Max SendQ exceeded]
shoogz has joined #lisp
nowolfer_ has quit [Ping timeout: 256 seconds]
python476 has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
omilu has joined #lisp
smurfrobot has quit [Remote host closed the connection]
jmercouris has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
learning has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
jtroseme has quit [Remote host closed the connection]
angavrilov has joined #lisp
dddddd has joined #lisp
uuplusu has joined #lisp
smurfrobot has quit [Remote host closed the connection]
attila_lendvai has quit [Read error: Connection reset by peer]
fikka has joined #lisp
rstandy has quit [Remote host closed the connection]
rstandy has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
fikka has quit [Ping timeout: 268 seconds]
jtroseme has joined #lisp
Ven`` has joined #lisp
terpri has quit [Ping timeout: 268 seconds]
milanj has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
shrdlu68 has quit [Ping timeout: 264 seconds]
random-nick has joined #lisp
fikka has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
damke_ has joined #lisp
BitPuffin has joined #lisp
sysfault has quit [Quit: Leaving]
damke has quit [Ping timeout: 264 seconds]
fikka has quit [Ping timeout: 248 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
raynold has quit [Quit: Connection closed for inactivity]
pythosnek has joined #lisp
pythosnek has quit [Remote host closed the connection]
saki has quit [Remote host closed the connection]
attila_lendvai has quit [Read error: Connection reset by peer]
python476 has quit [Ping timeout: 260 seconds]
attila_lendvai has joined #lisp
nao1 has joined #lisp
uuplusu has quit [Remote host closed the connection]
aeth has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
aeth has joined #lisp
smurfrobot has joined #lisp
asarch has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
fikka has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
dieggsy has joined #lisp
<flip214>
Shinmera: any ETA for ELS registration? No need to hurry, just curious. (And HR wants to know ;)
<Shinmera>
It's done and out of my hands. Ask Didier.
fikka has quit [Ping timeout: 264 seconds]
rstandy has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
dieggsy has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
fikka has joined #lisp
python476 has joined #lisp
nullman has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Remote host closed the connection]
attila_lendvai has quit [Read error: Connection reset by peer]
parjanya has quit [Ping timeout: 256 seconds]
nullman has joined #lisp
<AeroNotix>
Zhivago: your thing about temporary processes and making per-function calls in those slightly reminds me of Erlang.
attila_lendvai has joined #lisp
<AeroNotix>
in Erlang each function is executed in its own "process" which is not a unix process but an actor within the beam vm. Each process has its own GC and GC happens in isolation from every other process.
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
glv has quit [Quit: Leaving]
smokeink has quit [Ping timeout: 276 seconds]
quazimodo has quit [Ping timeout: 248 seconds]
<White_Flame>
erlang functions are normal synchronous functions
<White_Flame>
but yeah, it's all about cheap easy processes & message passing
dtornabene has joined #lisp
papachan has quit [Quit: WeeChat 2.0.1]
comborico has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
mishoo has quit [Ping timeout: 260 seconds]
<fe[nl]ix>
Shinmera: can we already register for ELS ? the announcement doesn't mention that
<Shinmera>
No
<fe[nl]ix>
when will it open ?
<Shinmera>
I don't know. Ask Didier.
<Shinmera>
I only write website code. I'm not actually involved with the organisation.
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
Pixel_Outlaw has joined #lisp
Pixel_Outlaw has quit [Client Quit]
galdor1 is now known as galdor
Bike has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
fikka has joined #lisp
MrMc has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 248 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
terpri has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
<AeroNotix>
White_Flame: not sure what I said needed clarification
<AeroNotix>
about them being "normal synchronous functions"
<White_Flame>
"in Erlang each function is executed in its own "process"" isn't correct
<AeroNotix>
Yes it is
<AeroNotix>
White_Flame: in what context is an Erlang function not executed in a process
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<AeroNotix>
each invocation doesn't create a new process.
attila_lendvai has quit [Read error: Connection reset by peer]
<AeroNotix>
but each function is always executed within a process and all processes are executing concurrently
<White_Flame>
right, that's an ambiguous implication that to me read as a function gets its own unique process
<White_Flame>
not its "own" shared process
<AeroNotix>
since a function cannot be executed outside of a process, there's not much difference unless you understood that each invocation creates a new process for the function to execute in
<AeroNotix>
any way
<AeroNotix>
the point was about the erlang GC
<AeroNotix>
which is interesting
<White_Flame>
right, per-process GC
DonVlad has joined #lisp
<AeroNotix>
Yes
<White_Flame>
in classical Lisp, were what we now call threads called "processes"?
<AeroNotix>
No idea about classical lisp
<White_Flame>
I think that was the case
<AeroNotix>
really do think a good Lisp needs to come to the beam
<AeroNotix>
there's clojerl
<AeroNotix>
and LFE, but LFE is a garbage tyre fire of a language
<White_Flame>
however, in some of the lisp machines, you could allocate fixed-size regions to work with, and then throw away the region after you were done
<AeroNotix>
if you squint hard enough erlang processes could be used like that
__rumbler31 has joined #lisp
<AeroNotix>
spawn_opts could be used to allocate a heap of your choosing and the process could die when you're done
<AeroNotix>
I forget if you can disable gc for an individual process but with the right spawn_opts perhaps it's possible
<White_Flame>
one thing (of quite a few) that I hated about Erlang is that you couldn't sic multiple processes to scan through a single large immutable shared data structure
<White_Flame>
unless you did hacky things with binaries, as those were shared
<AeroNotix>
not quite like you're saying though
<AeroNotix>
there's no good way to query if you have a refc binary
<AeroNotix>
you just sort of assume it is given it's size
<AeroNotix>
ETS is what you're after kind of
<AeroNotix>
or pre-chunking a datastructure but it still requires copying
<White_Flame>
yeah, ETS wuldn't work. Parallelizing multiple processes to scan a single data structure would be done for optimization; shifting all that into an ETS database form would kill speed & serialize it
<AeroNotix>
I was meaning that you would start off with your data in ETS
<AeroNotix>
instead of temporarily moving it there
<White_Flame>
right, and taht would be terrible for a fine-grained tree data structure, where you can very quickly traverse it in RAM normally
<fe[nl]ix>
on recent CPUs it tends to be a severe speed disadvantage to access large(ish) data structures from multiple threads
<White_Flame>
but in any case, I spent 2-3 years deep in Erlang. It's a great language to learn from, but I certainly don't use it anymore by intent :)
<fe[nl]ix>
especially if those threads are running on different cores on different NUMA nodes
<AeroNotix>
fe[nl]ix: you can lock schedulers to cores in Erlang but it still would present the issues you're talking about
<White_Flame>
fe[nl]ix: yeah, nowadays you really have to manage affinity & such if you're doing that level of optmization
<AeroNotix>
White_Flame: why don't you use it any more?
<AeroNotix>
Erlang, I mean
<AeroNotix>
It's a garbage language itself, imho but nothing comes close for very simple concurrency and structuring concurrent applications
<AeroNotix>
plus the beam is p fkn cool
<White_Flame>
bad syntax, SSA got in the way of editing, very static model of the supervisor configuration which is at odds with dynamic application servers & runtime services, no parallelization of shared structures as mentioned above, etc
<White_Flame>
however, it has been quite a few years in the meantime, so I don't know how erlang has progressed
smurfrobot has joined #lisp
<White_Flame>
and we also desparately missed lisp macros
Kristof_HT has joined #lisp
<AeroNotix>
Where would you need a dynamic supervisor configuration?
<fe[nl]ix>
White_Flame: in many cases it's significantly faster to pin the pages of the data structure on a NUMA node, assign it to a worker thread pinned on the same node and have the other threads enqueue work requests
<AeroNotix>
plus you can hot load new supervision trees in
damke has joined #lisp
<AeroNotix>
There are definitely ways to do what you're talking about
<AeroNotix>
mostly solved with relups
<fe[nl]ix>
so the data structure is only accessed from a single thread and the shared access is on the work queue
<White_Flame>
yes, but at least at the time it always ended up in throwing away everything OTP provided and trying to do it yourself with the provided lower level mechanisms
<AeroNotix>
I don't believe so
<AeroNotix>
relups are tied with OTP pretty hardcore
<AeroNotix>
even a simple hot code reload could reconfigure supervisors/gen_servers
<White_Flame>
erlang was also part of a heterogeneous system, so our stuff wasn't purely defined in erlang assumptions
kristof__ has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
<White_Flame>
it's been too long to recall the exact specifics with the supervisor definitions, but each time we had to figure out what number or setting to put into those defintiions, we always wanted them to be calculated predicates, not fixed values
<AeroNotix>
you mean the restart specifications?
smurfrobot has quit [Ping timeout: 256 seconds]
<AeroNotix>
supervisor restart strategies
<AeroNotix>
those are definitely static still, but a relup/code reload can reconfigure them but probably not the way you want to do it
kristof__ has quit [Client Quit]
Kristof_HT has quit [Client Quit]
<White_Flame>
but in any case, our conclusion was that erlang woudl work great for statically defined systems (like telecom platforms, incidentally), but for dynamically defined systems just didn't play well enough
Kristof_HT has joined #lisp
<White_Flame>
the underlying systems coudl do all that, but OTP was built around too many assumptions of static definition
<AeroNotix>
it'd be interesting if the restart strats could take a function atom which would recalculate the restart strategy when a child pid restarted
Kristof_HT has quit [Client Quit]
<AeroNotix>
but it comes down to whether you could recalculate it quick enough on demand (latency of calculating impeding restart) the lack of shared data would hinder that too. Since if you had shared data you could recalculate it elsewhere and update a variable it could access
Kristof_HT has joined #lisp
<AeroNotix>
there are hacks for that. Recompiling a module at runtime, for example
CrazyEddy has quit [Read error: Connection reset by peer]
kristof__ has joined #lisp
kristof__ has quit [Remote host closed the connection]
sz0 has joined #lisp
Kristof_HT has quit [Client Quit]
Kristof_HT has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
kristof__ has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
kristof__ has quit [Remote host closed the connection]
mnoonan has joined #lisp
Kristof_HT has quit [Client Quit]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
dieggsy has joined #lisp
uuplusu has joined #lisp
uuplusu has quit [Remote host closed the connection]
attila_lendvai has quit [Read error: Connection reset by peer]
EvW has joined #lisp
Cymew has quit [Remote host closed the connection]
<dtornabene>
curious if anyone has done any audio processing in CL, specifically eating an mp3 and doing analysis on the stream??
LiamH has joined #lisp
<dtornabene>
although I'm open to hearing any audio processing stories, not just mp3 stuff
aijony has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
scymtym has quit [Ping timeout: 252 seconds]
attila_lendvai has joined #lisp
<Shinmera>
there's cl-mpg123 to read mp3 files
<Shinmera>
I don't know what analysis you want to do on audio data, but you just get a buffer of floats in any case. From there on out you can do whatever with it.
nao1 has quit [Ping timeout: 248 seconds]
sjl has joined #lisp
<dtornabene>
cool! thanks for the reply I acutally just found some of your own stuff from googling
juan-reynoso has joined #lisp
<dtornabene>
i think I'll give cl-mpg123 a shot and go from there
<Shinmera>
I'm mostly concerned with real-time processing, which may or may not be in your area.
attila_lendvai has quit [Read error: Connection reset by peer]
mishoo has joined #lisp
<dtornabene>
not so much, no. I'd like to do some similarity of sound analysis, similar in some ways to what echonest does with beat and melody comparisons
<Shinmera>
I see.
<dtornabene>
i have a ton of mp3s, like to filter out some sounds and compare others, and go from there
attila_lendvai has joined #lisp
<dtornabene>
thanks again for the pointers, it seems like in terms of libraries its a "there be dragons" kind of situation as use cases can get specialized really quickly
<Shinmera>
Yeah.
saki has joined #lisp
smurfrobot has joined #lisp
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 264 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
csaurus has joined #lisp
al-damiri has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
fikka has joined #lisp
makomo_ has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
damke has quit [Ping timeout: 264 seconds]
elts has quit [Ping timeout: 256 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
elts has joined #lisp
fikka has joined #lisp
<pjb>
dtornabene: beach has a fast FFT in CL!
<dtornabene>
ha, I'm currently sifting through DFT implementations on github right now
<dtornabene>
could you link me? I'd love to take a look, and I'm not sure who beach is ....
<dtornabene>
thank you very much, this is very much "journey of a thousand miles begins with a single step" territory for me...
<pjb>
I don't know I believed beach was the author…
fikka has quit [Ping timeout: 248 seconds]
<Bike>
because "bordeaux"?
Arcaelyx has joined #lisp
comborico has quit [Quit: Konversation terminated!]
<dtornabene>
thanks again
ninegrid has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
smurfrobot has quit [Ping timeout: 240 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
Ven`` has quit [Read error: No route to host]
CrazyEddy has joined #lisp
Ven`` has joined #lisp
angelo has joined #lisp
<angelo>
hi
<dTal>
hi
Karl_Dscc has joined #lisp
<angelo>
please help, I wrote a project with 4 nested loop, quickload cannot load eventually dropped in the debugger for stack overflow! Thanks
<pjb>
angelo: no problem; let me start up my telepathic powers.
<Bike>
what he means it that's not enough information for us to help
EvW has quit [Ping timeout: 265 seconds]
shrdlu68 has joined #lisp
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has joined #lisp
<Guest16495>
when doing curses development with cl-charms i want my application to handle ctrl-c as an input, but the sbcl repl intercepts it and interrupts the program. is there a way to avoid this?
attila_lendvai has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 248 seconds]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
yaewa has joined #lisp
jtroseme has quit [Remote host closed the connection]
moei has quit [Ping timeout: 248 seconds]
<Shinmera>
That's not SBCL doing it, that's your terminal.
<Shinmera>
Your terminal is converting C-c into SIGINT.
<pjb>
Guest16495: stty intr undef # or of course, the equivalent termios.
flamebeard has quit [Quit: Leaving]
FreeBirdLjj has quit []
<sjl>
Guest16495: `(charms:enable-raw-input)`
nowhereman_ has joined #lisp
<sjl>
note that if you're running SBCL with something like rlwrap, this may cause problems. When using cl-charms I run SBCL directly without rlwrap or anything else around it.
attila_lendvai has quit [Read error: Connection reset by peer]
Ven`` has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<dtornabene>
sjl: do you use rlwrap with sbcl?
<sjl>
dtornabene: usually, yes
nowhere_man has quit [Ping timeout: 256 seconds]
<dtornabene>
sjl: have you found a way to get it to autocomplete on symbol/function names?
AxelAlex has joined #lisp
<attila_lendvai>
dtornabene: that goal is not reachable with reasonable effort
<dtornabene>
lol
smasta has quit [Ping timeout: 255 seconds]
<dtornabene>
attila_lendvai: fair enough
<sjl>
for built-in stuff in the cl package, you can probably just dump all the symbols into a big file for rlwrap to look at
<dtornabene>
yeah, that was what I meant
<sjl>
but if you want (defun foo () 1) and then be able to tab-complete foo, that's gonna be a lot more involved
<dtornabene>
the snippet of code I'm using in conjunction with rlwrap is supposed to do that already but doesn't and I've been too lazy to debug it
<pfdietz_>
Loading all of quicklisp: aren't there package name conflicts?
<phoe>
pfdietz_: of course they are
<phoe>
binary-types and bordeaux-threads both have nickname "BT"
<phoe>
to quote one of the famous examples
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<pfdietz_>
I am tempted to hack PLNs into clisp and ccl.
<phoe>
PLNs?
<Shinmera>
package local nicknames
<phoe>
oooh.
<phoe>
God sped you.
<Shinmera>
pfdietz_: I don't care about clisp, but ccl would be very much appreciated.
<Shinmera>
Could even start deploying it in libraries at that point. Exciting!
<pfdietz_>
Allegro would the next roadblock.
<pfdietz_>
Don't know if Lisp works supports it.
<phoe>
I don't care about Allegro
Cymew has joined #lisp
<Shinmera>
Well, the more the merrier of course
FreeBirdLjj has joined #lisp
<Shinmera>
And once libraries start using it, convincing LW/Franz to add them would probably be easier.
<whoman>
hm, for quicklisp? that would be quite alright =)
<pfdietz_>
cmucl would also need it but that's low usage. And I think gcl is moribund.
<phoe>
gcl is dead.
<pfdietz_>
ACL2 moved off it?
<pfdietz_>
Or died itself...
Cymew has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
<whoman>
thats too bad. GNU <something> is such an offical trusty naming style
<whoman>
like what the heck is Steel Bank
<Shinmera>
More solid than a Gnu
<jmercouris>
I don't know, and that's one of the reasons I picked SBCL first, not even joking
<White_Flame>
it's definitely not Carnegie Mellon
<AeroNotix>
whoman: "The name "Steel Bank Common Lisp" is a reference to Carnegie Mellon University Common Lisp from which SBCL forked: Andrew Carnegie made his fortune in the steel industry and Andrew Mellon was a successful banker.
<jmercouris>
I mean I picked CCL in place of SBCL
<AeroNotix>
"
<jmercouris>
naming is important, regardless of how much of a brand you build
<TMA>
whoman: Steel ~ Carnegie ; Bank ~ Mellon, for it is a fork of cmucl
<pfdietz_>
ACL2 no longer depends on gcl I see.
<jmercouris>
part of your brand is the name, especially in an acronym
<White_Flame>
SNCM: SNCM's Not Carnegie Mellon
<AeroNotix>
Also, SBCL seems to be the defacto standard for open source stuff nowadays
<AeroNotix>
I know people use other implementations
<jmercouris>
I use CCL!! :)
smurfrobot has joined #lisp
<whoman>
hehe
<White_Flame>
yep, CCL has had better mac & win support, and GUI things. CLISP has been easy to port. ECL is embeddable, etc
<jmercouris>
I've also used ECL, but I prefer CCL
<jmercouris>
for my applications
<whoman>
what about the iphone lisp ? M-something
<random-nick>
mocl?
<phoe>
mocl
<AeroNotix>
CLISP seems crap
<phoe>
CLISP is decent, but starts getting dated.
<jmercouris>
AeroNotix: yet I hear the name brought up all the time
<phoe>
it is still maintained, but hasn't had a release for a long time
<jmercouris>
what's up with CLASP, is it complete?
<AeroNotix>
jmercouris: it's just one that exists
<random-nick>
don't forget Mezzano
<pfdietz_>
The SBCL fork was a bit daring because build time was an issue back then and SBCL had to compile things twice. Now the build time is almost negligible.
<phoe>
also CLISP has a very (un)fortunate name because it shares its first name with C(ommon )Lisp
<AeroNotix>
I believe clasp is complete. I remember the author making a big deal about it being complete in here a few months/years ago
<jmercouris>
Mezzano is a lisp implementation and an OS?
<phoe>
jmercouris: yes.
<AeroNotix>
when I first started I thought CLISP was the only implementation exactly because it was called CLISP
<phoe>
it's crazy, but it works and runs on bare metal now.
<jmercouris>
drmeister is the author AFIAK
<phoe>
yes
<phoe>
go to #clasp for most fresh information
<jmercouris>
phoe: mezzano?
fikka has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 256 seconds]
<jmercouris>
so what's the big draw of clasp, interop with c++?
<random-nick>
yes
<shka>
and with C
<phoe>
jmercouris: yes, mezzano is crazy and runs on bare metal.
<pfdietz_>
Clasp is not quite fully gelled but much work is being done. I plan to abuse it horribly when given the go ahead.
<jmercouris>
all implementations support CFFI no?
<phoe>
shka: C interop isn't all that unique right now
<jmercouris>
so why is interop with C important?
<AeroNotix>
I don't understand the reasonsing behind clasp. "Interoperability between cl and c++" can't you achieve that with FFI?
mlf has joined #lisp
<White_Flame>
right, the impetus for clasp was C++
<jmercouris>
phoe: It's too bad there's no ecosystem of apps such that one could actually run mezzano as their main OS
<White_Flame>
FFI is normally just C
<phoe>
well, clasp has its own kind of C interoperability - it doesn't "just" interface with already compiled C libraries, it compiles C code with LLVM into something that already has Lisp interoperability.
<random-nick>
interop with C is more of ECL's speciality
<TMA>
AeroNotix: c++ is tough via FFI
Cymew has joined #lisp
<phoe>
White_Flame: C++ is a pain to interoperate with.
<phoe>
Compiler name mangling, for once.
<AeroNotix>
fair enough, never tried it with C++
<jmercouris>
AeroNotix: I don't think someone would embark on such a large project if they didn't examine the obvious :D
<AeroNotix>
jmercouris: for sure
<AeroNotix>
I'm just saying I don't personally understand
<jmercouris>
right yeah
<phoe>
In c, void main(int argc, char** argv) has a symbol named "main"
<jmercouris>
also, it's not to say that that's never happened
<pfdietz_>
Clasp could enable exploitation of fancy compiler optimizations for loops and such. Good for numerical work.
<phoe>
in C++ it can be "Vmain2IargcCPPargvUNICORNSandSTUFF"
<Bike>
clasp also lets you manipulate C++ objects in lisp, have lisp classes that are subclasses of C++ ones, stuff like that
<jmercouris>
I wish there were implementation independent extensions to other languages like CFFI
<jmercouris>
there were more of them
<TMA>
phoe: main shall return int
<Bike>
to languages other than C, you mean?
<AeroNotix>
Bike: I feel like I've done that in CL but I might be imagining it
<jmercouris>
Bike: yeah
orivej has quit [Ping timeout: 240 seconds]
<AeroNotix>
as a toy with ffi
<phoe>
TMA: oh yes, sorry
<Bike>
AeroNotix: cffi doesn't know about C++ classes
<phoe>
but I wasn't doing it to write proper c or c++, I was doing this to illustrate C++ name mangling
<phoe>
and each compiler does it differently
<TMA>
phoe: declaring it otherwise is undefined behavior in hosted enviroment (hosted == libc available)
<Bike>
jmercouris: C is practically the only language with an actual linking api
<phoe>
they are actually *encouraged* to do it differently
<White_Flame>
yeah, everything else is generally sockets for interop
<Bike>
python compiled code, lisp compiled code, it's all opaque
<random-nick>
is there a (common) lisp on top of .NET?
<AeroNotix>
how about rust?
<Bike>
i haven't looked at rust much but i imagine you can link with it, yes
<phoe>
random-nick: not really.
<jmercouris>
Bike: I wouldn't know, I'm not a language expert or anything, but I think simplified bridges could be written with IPC and a child instance
<phoe>
you could try running ABCL via some kind of java-on-CLR bridge.
<AeroNotix>
yeah I've linked rust to emacs before
<AeroNotix>
as a toy
<Bike>
well that's completely different from CFFI, jmercouris
<jmercouris>
Bike: like I can envision how to make a VERY naieve lisp to python bridge with IPC
<TMA>
Bike: for a time pascal had its linking ABI well known, but then it fell out of use
<Bike>
TMA: yeah, i bet. maybe fortran also. i'm too young for such things
* TMA
is too young for fortran
<AeroNotix>
jmercouris: remember about the wankery? You'd invoke their wrath doing it that way
<random-nick>
afaik there used to be a project that provides lisp and python interoperability by interpreting python
<AeroNotix>
omg SLOW
fikka has joined #lisp
* phoe
is too young for Lisp
<jmercouris>
AeroNotix: lol yeah
<Bike>
clasp also sorta interoperates with fortran :v
smurfrobot has quit [Remote host closed the connection]
<phoe>
Bike: is that because LLVM can compile Fortran code?
<random-nick>
but I can't recall what's it called and I'm pretty sure it's abandoned
<Bike>
yeah. well, the more general cause is that a lot of science code is written in fortran
<shka>
Bike: that's interesting
<pfdietz_>
First lisp I ever used was on an IBM 7094. Lisp on punch cards.
Cymew has quit [Ping timeout: 248 seconds]
<jmercouris>
how is lisp on punch cards even possible?
<phoe>
jmercouris: just like any other language would be
<Bike>
why wouldn't it be possible
<phoe>
treat punch cards as terminal input
<jmercouris>
I thought it was reserved for assembler languages with a simple line by line format
<phoe>
jmercouris: d'oh of course not
<Bike>
a punch card is just a binary input format
shka has quit [Quit: Konversation terminated!]
<phoe>
COBOL on punch cards was a thing
<phoe>
so why wouldn't Lisp be
<jmercouris>
so you are writing in binary then, not in lisp
<pfdietz_>
As was FORTRAN.
<phoe>
jmercouris: no
<AeroNotix>
jmercouris: it could be pure lisp
<phoe>
you are writing letters
<phoe>
encode them in ASCII or ANSI or anything
<phoe>
you get bytes, you punch those on the cards, you send them as input
<AeroNotix>
but the machine would "compile" from the card
<jmercouris>
how did they look? one letter per row?
<jmercouris>
and each rwo had all the atoms?
<pfdietz_>
The letters are printed on the card as you punch it.
<jmercouris>
I'm getting lost here
<edgar-rft>
Just simply punch cards until they lose their teeth and speak with a Lisp - voila
<jmercouris>
all possible letters are printed on the card?
<TMA>
jmercouris: one row (80 characters) per card
<jmercouris>
ok
<pfdietz_>
One letter per column. A card is a line.
<jmercouris>
how do you specify the letter
<jmercouris>
that's what I am getting at
<jmercouris>
you literally write it down and the system can somehow read it???
<pfdietz_>
The card punch had a keyboard.
<whoman>
cuneiform binary
<jmercouris>
ok that's what I've been missing
<Bike>
You type a letter and that punches the binary encoding of it. Right?
<whoman>
mini ascii charts! ?
<pfdietz_>
Punch 'A' and it prints A on the column and punches the code for A below it in holes.
<jmercouris>
you just said the letter was on there no?
<jmercouris>
I meant the letters must have been spaced far apart
<Bike>
in the fortran one you can see it written on top in the original letters, as pfdietz said.
<jmercouris>
or were the letters printed on a separate sheet?
<Bike>
Z(1) = Y + W(1)
<pfdietz_>
You could actually compute with cards. This was before actual computers.
<whoman>
different machines, too
warweasle has joined #lisp
<Bike>
i assume the printed letters are so that you can read it back without a code table.
<Bike>
you = a human.
<whoman>
pfdietz_: heh, i wonder if they matched up in certain ways. optimizations !
<pfdietz_>
Yes
<whoman>
like holding up two cards for bit ops
<Bike>
i have an old punch card i found in a library at home, but i've never used a reader or anything.
<pfdietz_>
Sorting, merging
<whoman>
unification =P
<Bike>
Wait until you hear about slide rules
<whoman>
(using them like as stencils)
<AeroNotix>
so clasp is more of a cl=>llvm compiler then?
<Bike>
Yes.
<AeroNotix>
so why is C++ mentioned so much?
<Bike>
cos that's what we're using it for.
<phoe>
AeroNotix: it is more of an everything=>llvm compiler.
mareskeg has joined #lisp
<Bike>
phoe: no we're pretty much only compiling cl
<phoe>
where everything is {c, c++, fortran, CL}
<phoe>
oh
<Bike>
c and c++ are done perfectly well by clang
<AeroNotix>
are there any limitations with it?
<phoe>
yep, but you take the LLVM IR and do crazy Lisp things with it
fikka has joined #lisp
<phoe>
AFAIK
orivej has joined #lisp
<Bike>
you can load llvm ir and call it like a foreign function, and such
<AeroNotix>
e.g. redefining classes at runtime?
<AeroNotix>
it all Just Works?
<Bike>
you can't redefine C++ classes
<pfdietz_>
llvm for interop but also to exploit optimization passes written by others for llvm.
<jmercouris>
so basically clasp can read punch cards?
<AeroNotix>
no but you can redefine CL classes
<phoe>
jmercouris: xD
<Bike>
Oh, yes, it's full CL
<AeroNotix>
jmercouris: clasp IS a punchcard
<AeroNotix>
when you install it he mails you one
<Bike>
It uses LLVM's "JIT" features to compile things for a running image
serviteur has joined #lisp
<Bike>
jit in scare quotes because we're not using it as a just-in-time compiler
<jmercouris>
Bike: but how does it repunch the holes?
<whoman>
heh i dont have enough memory to compile clasp . waiting on bnaries
<AeroNotix>
whoman: how much memory do you have?
<whoman>
2gb
<AeroNotix>
omg peasant
<AeroNotix>
get away from me
<jmercouris>
I think the average is about 7 items at a time
<whoman>
compiling Cabal from haskell yesterday ate my swap fully, had to hard-reset twice
<whoman>
heheh
<AeroNotix>
whoman: do you need us to send help? How do you survive?
<Bike>
the main problem with clasp right now is that it takes a lot of resources to build, and the compiler is slow.
<Bike>
we're still not very stable.
<jmercouris>
I have a thinkpad x series with 2gb of ram and 20gb of hard disk, I can do literally all of my work on there
<whoman>
AeroNotix: by avoiding anything that uses ram. (eg. i've installed 32bit firefox on 64bit os)
<jmercouris>
I can ever power an external 28 inch display
<whoman>
i could have installed 32bit debian, but, idk
<jmercouris>
If you want to go REAL slim, start with freebs
<jmercouris>
s/freebs/freebsd, though it might as well be freebs with all of the manuals you'll spend reading :D
nowhere_man has joined #lisp
nowhereman_ has quit [Quit: Konversation terminated!]
FreeBirdLjj has quit [Remote host closed the connection]
smasta has quit [Ping timeout: 268 seconds]
FreeBirdLjj has joined #lisp
giraffe has quit [Remote host closed the connection]
itruslove has quit [Remote host closed the connection]
<antoszka>
Guys, registration for this year's ELS in Marbella hasn't opened yet, has it?
<antoszka>
I don't want to miss the early-bird pricing there usually was.
<phoe>
antoszka: according to Shinmera it is ready, but not yet public.
hhdave has quit [Ping timeout: 252 seconds]
<antoszka>
ok
<Shinmera>
early bird is open for long enough
<Shinmera>
usually anyway
<antoszka>
Usually, yeah.
<AeroNotix>
y'all should come to Poland instead
<AeroNotix>
just saying
<Shinmera>
and do what there
<antoszka>
Well, Poland had ELS last year :)
<AeroNotix>
ELS, obviously
fikka has quit [Ping timeout: 265 seconds]
<antoszka>
It's not Poland's turn anymore ;)
<AeroNotix>
but I missed the last one
<AeroNotix>
so like... come
<antoszka>
Well, come to Poland anyway, it's nice.
<antoszka>
At least when the smog goes away.
<antoszka>
Don't come now.
<whoman>
aagghh! one of my besties went to poland. never got a chance to meet her when she lived 2hrs away and known her for years. take me with you so i can find a monastery and a place to get ram
<antoszka>
please do
<phoe>
antoszka: two years ago
<phoe>
last year was brussels
<antoszka>
maybe
<antoszka>
true
<antoszka>
brussels was nice
<phoe>
two years ago was Krakow
<AeroNotix>
yeah that's the one I missed
<Shinmera>
I enjoyed the krakow els better than the brussels one
<AeroNotix>
I found out about it days afterwards
<pfdietz_>
$700 round trip. A bit too much.
<AeroNotix>
It's only 0PLN for me pfdietz_
<whoman>
hmmm.
<White_Flame>
host ELS in the salt mines. I'd come for that
<AeroNotix>
went to a wedding in the salt mines the other month, was pretty rad
<pfdietz_>
Granted, south Spain in April sounds really nice.
<phoe>
salt mines are actually right next to Krakow
<Bike>
this is just about the only context i can imagine "mines" referring to a pleasant locale
<AeroNotix>
There's a uranium mine that's not too too far from krakow too if you want it there
<AeroNotix>
might make more sense for lisp somehow
<phoe>
Uranium Common Lisp
jmercouris has quit [Ping timeout: 264 seconds]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
jmercouris has joined #lisp
<whoman>
Ukranium
_cosmonaut_ has quit [Ping timeout: 256 seconds]
AxelAlex has quit [Quit: AxelAlex]
<pfdietz_>
Kyiv for ELS?
<White_Flame>
ELS on Mars: Sponsored by Tesla
AxelAlex has joined #lisp
<White_Flame>
(beware falling roadsters)
<whoman>
tESLa
<serviteur>
Tesla should start to be profitable, before using all the US money in doing fake pic of a tesla car in space
<whoman>
wait teres no roads out there is there ?
<phoe>
#lispcafe
heurist`_ has joined #lisp
<whoman>
saturn oval track
<whoman>
lol phoe. when its convenient eh
<phoe>
(;
heurist` has quit [Ping timeout: 248 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
sz0 has quit [Quit: Connection closed for inactivity]
attila_lendvai has joined #lisp
FreeBirdLjj has joined #lisp
sukaeto has quit [Ping timeout: 248 seconds]
cyberlard has quit [Ping timeout: 268 seconds]
koisoke has quit [Ping timeout: 240 seconds]
raynold has joined #lisp
brandonz has quit [Ping timeout: 256 seconds]
AxelAlex has quit [Quit: AxelAlex]
GreaseMonkey has quit [Ping timeout: 276 seconds]
pfdietz_ has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
mareskeg has quit [Quit: mareskeg]
paule32 has joined #lisp
<paule32>
hello lispers
FreeBirdLjj has quit [Ping timeout: 264 seconds]
thodg has quit [Ping timeout: 268 seconds]
thodg has joined #lisp
<whoman>
lispidoo, helloer
<paule32>
:-)
FreeBirdLjj has joined #lisp
drewc_ has joined #lisp
jtroseme has joined #lisp
drewc has quit [Ping timeout: 256 seconds]
dieggsy has quit [Remote host closed the connection]
jtroseme has quit [Max SendQ exceeded]
jtroseme has joined #lisp
koisoke has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
Sveaker has joined #lisp
live__ has joined #lisp
schweers` has joined #lisp
tfb_ has joined #lisp
stacksmith has joined #lisp
d4gg4d__ has joined #lisp
zmt00 has joined #lisp
l1x_ has joined #lisp
dieggsy has joined #lisp
earl-ducaine_ has joined #lisp
hvxgr_ has joined #lisp
Mandus_ has joined #lisp
nefercheprure has joined #lisp
EvW has joined #lisp
zotan_ has joined #lisp
arbv_ has joined #lisp
rjeli_ has joined #lisp
stnutt_ has joined #lisp
FreeBirdLjj has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
gko_ has joined #lisp
tripty^ has joined #lisp
dirb has quit [*.net *.split]
oleo has quit [*.net *.split]
schweers has quit [*.net *.split]
arbv has quit [*.net *.split]
l1x has quit [*.net *.split]
Mandus has quit [*.net *.split]
rjeli has quit [*.net *.split]
fittestbits has quit [*.net *.split]
hvxgr has quit [*.net *.split]
earl-ducaine has quit [*.net *.split]
paule32 has quit [*.net *.split]
TMA has quit [*.net *.split]
gko has quit [*.net *.split]
vyzo has quit [*.net *.split]
stnutt has quit [*.net *.split]
tfb has quit [*.net *.split]
tripty has quit [*.net *.split]
zotan has quit [*.net *.split]
antismap has quit [*.net *.split]
d4gg4d_ has quit [*.net *.split]
d4gg4d__ is now known as d4gg4d_
tfb_ is now known as tfb
l1x_ is now known as l1x
arbv_ is now known as arbv
comborico1611 has joined #lisp
AntiSpamMeta has quit [Remote host closed the connection]
AntiSpamMeta has joined #lisp
jmercouris has quit [Ping timeout: 248 seconds]
elts has quit [Ping timeout: 240 seconds]
zotan_ has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
zotan has joined #lisp
dmiles has quit [Ping timeout: 260 seconds]
elts has joined #lisp
vyzo has joined #lisp
dirb has joined #lisp
paule32 has joined #lisp
fittestbits has joined #lisp
antismap has joined #lisp
FreeBirdLjj has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
AxelAlex has joined #lisp
mareskeg has joined #lisp
greaser|q has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
pagnol has quit [Ping timeout: 240 seconds]
damke_ has joined #lisp
stacksmith has left #lisp [#lisp]
stacksmith has joined #lisp
damke has quit [Ping timeout: 264 seconds]
damke has joined #lisp
damke__ has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
edgar-rft has quit [Quit: Don't Cry for Me, Argentina...]
damke has quit [Ping timeout: 264 seconds]
Patternmaster has quit [Ping timeout: 256 seconds]
mareskeg has quit [Quit: mareskeg]
FreeBirdLjj has joined #lisp
mareskeg has joined #lisp
<comborico1611>
Would (format t "~{~{~a:~10t~a~}~%~%~}" *db*) VERSUS (format t "~{~{~a:~10t~a~%~}~%~}" *db*) produce the same output?
sbryant has quit [Ping timeout: 256 seconds]
<comborico1611>
Oops. Wrong sample. Let me try again.
<comborico1611>
(format t "~{~a:~10t~a~%~}~%" cd)
jtroseme has quit [Ping timeout: 264 seconds]
<comborico1611>
VERSUS
<comborico1611>
(format t "~{~a:~10t~a~}~%~%" cd)
sshirokov has quit [Ping timeout: 256 seconds]
<phoe>
comborico1611: no
<aeth>
doesn't look like it
<phoe>
in the first case, you have a newline after each element of CD
<phoe>
in the second case, you do not make newlines while iterating
<phoe>
so instead of having "1\n2\n3\n\n" you'd have "123\n\n"
<phoe>
plus minus tabs
<aeth>
comborico1611: you might be looking for ~^
FreeBirdLjj has quit [Ping timeout: 248 seconds]
<comborico1611>
phoe: ahh, the 1-2-3 example helped me understand.
<aeth>
What are you trying to do?
<phoe>
comborico1611: the stuff between ~{ and ~} gets repeated for each element in the iteration.
fourier has joined #lisp
<phoe>
unless you put a ~^ somewhere in there. this will short-circuit if the list you are iterating on has no more elements.
<phoe>
so (format t "~{~A~^ ~}" '(1 2 3 4 5)) will print "1 2 3 4 5"
<comborico1611>
aeth: trying working through Practical CL
<phoe>
*without* a space after the last element.
<phoe>
(format t "~{~A ~}" '(1 2 3 4 5)) will print "1 2 3 4 5 "
LocaMocha has quit [Ping timeout: 264 seconds]
<comborico1611>
Do you guys code in your dreams, too?
<stacksmith>
comborico1611: I've solved many problems in my dreams. On occasions the problems existed only in my dreams. This is more of a #lispcafe discussion.
drewc_ is now known as drewc
attila_lendvai has quit [Read error: Connection reset by peer]
<fourier>
fe[nl]ix: looking at travis it fails in master branch as well, am i missing something?
<jack_rabbit>
It's a flag to signal shutdown. I don't need the (setf ...) but it would be nice to check if the acceptor is shut down or not.
<jack_rabbit>
And I don't see another method to check.
damke__ has quit [Ping timeout: 264 seconds]
<phoe>
jack_rabbit: you seem to be right. I say, open an issue stating this, or a PR right away that exports the symbol.
<phoe>
Or, rather...
<phoe>
It might not be a good idea to export the symbol because this makes it possible to use SETF on it.
<phoe>
And setting that value outside of Hunchentoot seems pointless.
<jack_rabbit>
even dangerous.
<jack_rabbit>
setf is implicitly exported then?
<phoe>
Better make a new function, ACCEPTOR-ALIVE-P, that calls that accessor and returns it value.
<phoe>
jack_rabbit: if you export FOO:BAR, you can call #'(SETF FOO:BAR).
<jack_rabbit>
I see. Did not know that.
<phoe>
It's a property of SETF.
<phoe>
Therefore make a new function and export its symbol.
<jack_rabbit>
Sort of makes sense. Although the ability to export readers but not writers would be useful.
<jack_rabbit>
Yes, I agree then. I'll add a function ACCEPTOR-ALIVE-P.
<phoe>
jack_rabbit: you export symbols, not readers/writers.
<phoe>
if you want to make a private writer, then it must have a different name.
<jack_rabbit>
I understand.
<jack_rabbit>
Ahh, yes. That makes sense.
<phoe>
Which then makes no sense because suddenly you have (foo bar) but (setf (foo2 bar) 42)
<phoe>
So the workaround is to explicitly define new functions that call the reader. (Or the writer.)
<phoe>
(But you'll most likely want to call only readers.)
<jack_rabbit>
Yes, I understand. I just meant it would be useful to be able to export a symbol without allowing the setf, but I understand that that doesn't really make sense with the semantics of export.
<phoe>
Yes, this is where the mechanics of EXPORT and mechanics of SETF interact.
pfdietz_ has quit [Ping timeout: 276 seconds]
<phoe>
You could *theoretically* define your own custom SETF expander that, unless the value of *PACKAGE* is something predefined, signals an error instead of being called. This way it would only execute inside your packages, and for everyone else it'll throw them into debuggers.
FreeBirdLjj has quit [Ping timeout: 256 seconds]
<phoe>
But that isn't merely a hack. It's already being a turd. {:
<_death>
or just say it's internal..
drewc has quit [Read error: Connection reset by peer]
<flip214>
phoe: the runtime value of *package* has nothing to do with the compile-time package...
<phoe>
flip214: I mean, the SETF would expand into a runtime package check
smcnamara has quit [Ping timeout: 276 seconds]
<flip214>
oh, right. sorry, didn't understand you then.
<phoe>
_death: kind of, but I like to think of exported symbols as the interface of a package. It's pointless for me to export a symbol that the programmer is not allowed to use.
<flip214>
but even now I'm not sure.
<phoe>
flip214: this is a totally crazy and not serious idea and anyone implementing it should be thrown into the bowels of ##c.
<phoe>
I absolutely wasn't serious while I was typing this.
<flip214>
the SETF _expansion_ is at compile time, the value _setting_ happens at runtime.
<flip214>
which one would check *package*?
<flip214>
okay, forget it, then
AxelAlex has quit [Ping timeout: 240 seconds]
<flip214>
I thought I could learn something new
<jack_rabbit>
The other question, then, is whether I need to obtain the lock. Some accesses to that slot are surrounded by '(with-lock-held ((acceptor-shutdown-lock acceptor))'
<phoe>
yes, I was writing this very very very quickly.
<jack_rabbit>
Is there danger to reading a value without the lock? I'm not sure about CL semantics for read/write races. I'm ok if the value isn't totally up-to-date, but don't want to raise an error.
<phoe>
_death: yep, but I like to think of symbols as being usable either-or. the moment you have ambiguity, you're going to have false bug reports.
warweasle has quit [Quit: up up and away.]
<phoe>
jack_rabbit: that's already hunchentoot internal question. or is it?...
attila_lendvai has quit [Read error: Connection reset by peer]
<phoe>
I have no idea if slot reads are atomic.
<phoe>
they most likely are not because SLOT-VALUE-USING-CLASS needs to be called, or something.
<jack_rabbit>
phoe, That's all I'm wondering. Will I ever get an error on a read if there's a simultaneous write?
<_death>
(defun phoe:bug () (nonphoe:feature)) ;; symbols can be used in ways that we might disapprove of, but not everybody bothers with package locks and weird runtime checks and such.. erik naggum once had a nice post..
<phoe>
jack_rabbit: as far as I understand that Hunchentoot code, you are free to hold (acceptor-shutdown-lock acceptor) inside your custom reader.
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<phoe>
_death: I laughed at this defun
<phoe>
jack_rabbit: as far as I understand this, if you are able to call STOP at any moment, which captures that lock for a moment, then you should be able to call a reader at any moment, which does the same thing.
<jack_rabbit>
phoe, Yes, I think so, from my reading. I was just wondering if it was necessary. It seems to only obtain the lock if it's modifying accessor-requests-in-progress
<phoe>
jack_rabbit: unless you are sure reading is atomic, you should use that lock. And I can bet $5 that it is not atomic.
<aeth>
Bike: In case you're wondering, about "maybe something can deal with it as a constant who knows", it looks like both SBCL and CCL deal with classes/structs with a make-load-form that calls make-load-form-saving-slots as constants. i.e. compile time initialization, trivially small disassembly, almost instant runtime when calling the function, saved in the FASL, etc.
<aeth>
as constant as if you had generated a built-in type like a string with a macro
<jack_rabbit>
phoe, In that case, I'll just take the safe route and obtain the lock. There's no real harm if it's unnecessary.
<Bike>
uh... are you really sure? the object is stored in the fasl?
<Bike>
almost instant runtime when calling the function is obvious, it's load time, not run time
<Bike>
well insofar as anything about loading a fasl is obvious
<aeth>
Bike: at the very least, large parts of the object are stored in the FASL in SBCL. I see NUL-padded strings (utf-32?)
<Bike>
strings in sbcl are nul padded
<Bike>
are ou like, looking at it in a hexdump
<phoe>
jack_rabbit: hmm.
<aeth>
e.g. ^@^@^@f^@^@^@o^@^@^@o
<Bike>
all the values in the slots are stored in the fasl, of course
<Bike>
that doesn't mean the object itself is
<aeth>
Bike: in SBCL, the initialize-instance :after isn't called except at compile time, I put a print statement in it
<jack_rabbit>
phoe, oh, dummy me. There *IS* already a method. HUNCHENTOOT:STARTED-P
<phoe>
wait
<phoe>
really
<phoe>
d'oh
<phoe>
no doubt we didn't find it
<phoe>
it's not in the docs
<jack_rabbit>
Looks like I can file an issue anyway. :)
fikka has joined #lisp
<whoman>
slime is the docs
<aeth>
Bike: If I put (format t "~A~%" "Hello") in the initialize-instance, it will show up in the verbose quickload as each function is compiled, but not when I launch the application, i.e. not when the functions are called at run time. e.g. ; compiling (DEFINE-SHADER (SIMPLE-2D-VERT :VERTEX-SHADER) ...)Hello
milanj has joined #lisp
AxelAlex has joined #lisp
<aeth>
This actually is cool because I do type-checking from the initialize-instance, so it type checks at compile time, but not when calling the function at runtime, at least in SBCL.
dddddd has joined #lisp
Sveaker has quit [Quit: Leaving]
<aeth>
CCL behaves the same way, except provides less information to verbose. I get a bunch of "Hello"s when compiling, and not at runtime.
<aeth>
This is actually cool, though, because assuming that it's safe, it does compile time type checking
attila_lendvai has quit [Read error: Connection reset by peer]
<Bike>
er, i don't follow.
<Bike>
if make-load-form is being invoked, there's an actual object you're passing to the compiler.
<Bike>
so, at one point you initialized that, and of course it did your initialize-instance method that does type checks or whatever.
<aeth>
Right, that object, generated in a macro at compile time, already had its initailize-instance called and its types checked, just at compile time
<aeth>
No performance cost for safety!
<aeth>
(assuming that that macro can generate that object at compile time)
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<Bike>
this is kind of an odd ontological question. the object has already been initialized in the building image, but not necessarily in the loading image
<Bike>
sbcl doesn't seem to ever actually use initialize-instance at load time
<Bike>
oh, wait, i might have misunderstood how make-load-form-saving-slots works...
fikka has quit [Ping timeout: 240 seconds]
<whoman>
i think this having a standards thing, is making things a bit more rough than they have to be
<Bike>
the way it's described it can definitely not call initialize-instance, and in fact it probably shouldn't.
<Bike>
Huh.
<whoman>
a lot of bandwidth spent on dealing with different implementations, may as well write in anything else that isnt portable
attila_lendvai has quit [Read error: Connection reset by peer]
<Bike>
and the implementation i work on is the same, i just didn't notice because argleblargle
<aeth>
Bike: I am confused about it as well, but I'm impressed if it works.
<whoman>
i dont understand, most lisp chat here on irc is about sbcl internals, how this implementation is etc.. only "CL" when it comes to other languages. hmmm, feels like my footing is suddenly in mud
<phoe>
whoman: you've never been on #sbcl
<aeth>
If I can generate a CLOS object or struct at compile time (or even more elaborate combinations! the CLOS object I'm talking about is filled with simple structs!) using this trick, then maybe I should.
<Bike>
we're talking about how this behavior is actually universal across implementations, whoman, leave your musery for another day
fikka has joined #lisp
<Bike>
aeth: make-load-form-saving-slots is defined more vaguely than i thought, is the deal- "Returns forms that, when evaluated, will construct an object equivalent to object, without executing initialization forms. The slots in the new object that correspond to initialized slots in object are initialized using the values from object. Uninitialized slots in object are not initialized in the new object."
<Bike>
nothing about calling allocate-instance or initialize-instance
<Bike>
it makes sense, i spose
<whoman>
phoe: thats where i have been for the last few months, until i guess this week when i switched irc clients.
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
fourier has quit [Ping timeout: 248 seconds]
<whoman>
wait, was that a nerve ... ?
<whoman>
sorry.
<aeth>
whoman: I often ask in here to see just how universal some behavior I observed in SBCL, or SBCL and CCL, is.
<whoman>
if that wasnt a weakness i would expect confidence where there is insecurity
<whoman>
aeth: i know =)
<aeth>
"Hey, here's a neat optimization. Can I actually use it?"
<Bike>
passing objects to the compiler has to be supported
<Bike>
it's an obscure bit of the standard, but it makes perfect sense within the fasl model, so i'd expect it to work everywhere fine
live__ has quit [Quit: Leaving]
fikka has quit [Ping timeout: 240 seconds]
<aeth>
awesome
Karl_Dscc has quit [Remote host closed the connection]
fikka has joined #lisp
francogrex has joined #lisp
<aeth>
What's the best way to make sure that the object stays valid? I verify it in a function that I call from initialize-instance (it's in a separate function so I can verify it at any time outside of that, too, and it's a function instead of a method because I want check-foo to tell me it's a valid foo, not a valid object)
<aeth>
But, clearly, there are ways to make it invalid after it's initialized.
<aeth>
Not every implementation respects :type (and not everything can be encoded in a type, anyway) and it can even vary depending on debug level.
<Bike>
assuming "validity" means some invariant among the slot values, depends on what you wanna let users do
<Bike>
for normal purposes, your after method and maybe some checks in the accessors seems fine
<Bike>
disallow slot-value and standard-instance-access and reinitialize-instance (or you could put your method in shared-initialize :after instead)
<aeth>
Is there a way to add checks to auto-generated accessors?
<Bike>
define methods on them
<aeth>
:before methods?
<phoe>
yep
<Bike>
whichever
<aeth>
(defmethod (setf foo) :before ...) or something? Or are the setters called something different?
sbryant has joined #lisp
<Bike>
for my "traitlets" thing i ended up writing this whole crappy validator pattern but it basically amounts to :around methods
<Bike>
nope, that's it
<Bike>
Super Easy
angavrilov has quit [Remote host closed the connection]
<aeth>
This is the most elaborate CLOS thing I've ever written
<Bike>
you'll be writing custom compute-effective-method methods soon enough
damke_ has joined #lisp
brandonz has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
damke has quit [Ping timeout: 264 seconds]
<aeth>
hmm
<aeth>
I wonder if I should make a typed linked list
fikka has quit [Ping timeout: 268 seconds]
dmiles has joined #lisp
francogrex has quit [Quit: ERC Version 5.3 (IRC client for Emacs)]
mareskeg has quit [Ping timeout: 248 seconds]
cyberlard has joined #lisp
pmc_ has joined #lisp
damke has joined #lisp
dieggsy has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
mareskeg has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
serviteur has quit [Remote host closed the connection]
markong has quit [Read error: Connection reset by peer]
vibs29 has joined #lisp
damke has quit [Ping timeout: 264 seconds]
<jack_rabbit>
How many projects (if any) use generated documentation? I would imagine it wouldn't be too difficult to write a decent doc generator for CL.
<jack_rabbit>
How common is it, rather. 'How many' is not a good question.
<Shinmera>
There's at least a brazillion if by "generated" you mean things that gather docstrings and put them in one place.
<sjl>
Writing your own docstring -> HTML renderer is pretty common these days.
<hjudt_>
i solved my issue with dexador using wireshark to inspect packets: the solution is to add another header "Accept-Encoding: gzip" in addition to "Accept: application/json".
<sjl>
There's also several sites that do it automatically for all projects in quicklisp, which annoys those of us that write more documentation and now have to compete with them in search results.
<aeth>
hah, yeah
attila_lendvai has quit [Read error: Connection reset by peer]
<aeth>
Sounds like a nightmare if you're one of the rare people to actually do things the right way with documentation.
<jack_rabbit>
I imagine a solution to that may be to include a link to the actual documentation it a place those sites will render.
<Shinmera>
It would help, but currently they don't do that.
<sjl>
They render the README, so at least there's a chance the user will see the actual docs if you link it there. Still not ideal.
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
<Shinmera>
I render the readme too, don't want to have a link to myself in my own docs :/
comborico1611 has quit [Quit: Konversation terminated!]
<Shinmera>
Staple also has a server component. (ql:quickload :staple-server) (staple-server:start)
<Shinmera>
But nobody runs that publicly (I hope)
FreeBirdLjj has joined #lisp
<sjl>
I render to plain HTML and host it with bitbucket's pages thingy. But yeah, there are a bunch of people who generate docs based on some prose + docstrings.
stacksmith has joined #lisp
kajo has quit [Ping timeout: 256 seconds]
les has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
kajo has joined #lisp
les has joined #lisp
willmichael has quit [Quit: Quit]
willmichael has joined #lisp
<_death>
Shinmera: hmmm, has issues with package-inferred-systems
* Shinmera
adds that to the list of bugs to fix soon
FreeBirdLjj has quit [Ping timeout: 248 seconds]
vlatkoB has quit [Remote host closed the connection]
karswell has joined #lisp
FreeBirdLjj has joined #lisp
EvW has quit [Ping timeout: 265 seconds]
mareskeg has quit [Ping timeout: 240 seconds]
karswell has quit [Ping timeout: 240 seconds]
klltkr has joined #lisp
Patzy has quit [Quit: leaving]
Patzy has joined #lisp
dtornabene has quit [Read error: Connection reset by peer]
dtornabene has joined #lisp
svillemot has quit [Quit: Reboot]
EvW has joined #lisp
FreeBirdLjj has quit [Ping timeout: 240 seconds]
dyelar has quit [Quit: Leaving.]
sebastien has joined #lisp
sebastien is now known as Guest5723
Guest5723 has left #lisp [#lisp]
damke has joined #lisp
svillemot has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
FreeBirdLjj has joined #lisp
phaul has joined #lisp
damke_ has joined #lisp
Achylles has joined #lisp
<phaul>
few years back I watched a write yourself a scheme ( I think ) on youtube, which was very entertaining, all I remember that it was very pink, and lots of hello kitty etc and maybe it was done in c-lisp. I tried to google it but couldn;t find it. Does anybody have a link?
damke has quit [Ping timeout: 264 seconds]
emaczen has joined #lisp
<emaczen>
how do you get the docstrings for a method, function and class?
<phaul>
maybe it was in emacs lisp. can't tell now. But definately lots of pink and rainbow
<aeth>
Well, that was strange. I had a type error in a macro. I changed the code. It worked, but wasn't what I wanted. I then changed it back to the original, and it worked. I guess C-c C-c doesn't always work if something in the same file is recompiled because the of compilation unit optimization stuff.
damke_ has quit [Ping timeout: 264 seconds]
random-nick has quit [Read error: Connection reset by peer]
<Nouv>
How does `eval` work at a low level? Where is the parsed function placed in memory? In the stack?
shifty has joined #lisp
mishoo has quit [Ping timeout: 264 seconds]
<Bike>
"parsed function"?
<Bike>
well, just try writing it
<Bike>
(defun eval (form) (typecase form (symbol (symbol-value form)) (cons (apply (first form) (mapcar #'eval (rest form)))) (t form))) handles function calls, self evaluating object,s and special variables
<|3b|>
however it wants... could be anywhere from looking at each form and directly calling a function to do whatever that form says, to compiling it to native code and running the result, to writing out a file, calling a C compiler on it, loading result as a shared object, and calling a function from that
mareskeg has joined #lisp
klltkr has quit [Ping timeout: 240 seconds]
<Nouv>
hm
<|3b|>
usually somewhere in between the first 2 options though
<Nouv>
The first would be interpreted right?
<|3b|>
sbcl for example usually compiles to native code, but directly evaluates some simple forms
<Nouv>
I suppose my question should be about the second
<Nouv>
Does sbcl also come with an assembler and linker or does it use as/ld?
<|3b|>
for direct native compilation, it is just normal data until you try to run it
<|3b|>
it is common to include something resembling "an assembler" in the compiler of implementations that generate native code
<Nouv>
hm
FreeBirdLjj has quit [Ping timeout: 256 seconds]
<|3b|>
(usually just as a bunch of functions in the image, same as the compiler though, not a separate program)
<|3b|>
and no "linker" needed, since it is all working in memory
<Nouv>
ah of course
<Nouv>
Possibly dumb question but
mareskeg has quit [Client Quit]
<pjb>
Nouv: there's the VOP assembler.
willmichael has quit [Ping timeout: 256 seconds]
<|3b|>
at the point where you want to go from "a piece of data on the heap" (the output of the compiler/assembler) to "running function", there might need to be some interaction with the processor/OS, for example changing page permissions or flushing caches
pillton has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
<Nouv>
Once it's assembled to native code is that just directly put into memory?
<Nouv>
hm
<|3b|>
it is just data at that point, it lives in memory like any other data :)
csaurus has quit [Ping timeout: 264 seconds]
<|3b|>
assuming you are compiling something too large to fit in a register, which is generally pretty much anything :)
<|3b|>
parts of it might be on the stack during processing, like any other data, but generally the end result and most of the larger parts during processing will live in the heap
<Nouv>
My questions are because I want to understand how to write (and eventually actually write) a lisp compiler, just as a learning experience
LiamH has quit [Quit: Leaving.]
<pmc_>
Nouv you might want to consider reading Chapters 4 and 5 of Structure and Interpretation of Computer Programs.
__rumbler31 has quit [Ping timeout: 248 seconds]
zooey has quit [Ping timeout: 255 seconds]
<Nouv>
I'm a CS student but can't take programming theory modules until next semester and I'm slightly impatient
<Nouv>
pmc_: I've seen SICP referred to quite a bit, I'll have to look at that too
<pjb>
Nouv: There's a library, there's the Internet. Read books! ;-)
zooey has joined #lisp
<Nouv>
:)
Achylles has quit [Read error: Connection reset by peer]
<pjb>
Nouv: and really the books you will study beyond your courses will be the ones you remember the best! Take your time to study as many as you want of them!
<pmc_>
Nouv, fyi, you don't need to read all of Chapter 4 of SICP just section 4.1.
Bike has quit [Ping timeout: 260 seconds]
<Nouv>
pmc_: Looks promising from the headers, thanks :)
<phaul>
ok, I think I've found what i was looking for. all I can say is that never take off those beer googles. :D
phaul has left #lisp ["WeeChat 2.0.1"]
<pmc_>
Nouv: sure thing. If you don't know Scheme read Chapter 1 too. :)
Achylles has joined #lisp
<Nouv>
I find this so interesting
<Nouv>
thanks for humoring my naive questions
Achylles has quit [Read error: Connection reset by peer]
damke_ has joined #lisp
willmichael has joined #lisp
EvW has quit [Remote host closed the connection]
Tobbi has quit [Quit: Leaving]
<Nouv>
Does that mean every compiled lisp program (at least from sbcl and other lisps that support eval) has a mini compiler in it?
<whoman>
^_^
<whoman>
full
<Nouv>
:o
AxelAlex has quit [Quit: AxelAlex]
<aeth>
Not every
<aeth>
I think commercial Lisps restrict it.
<Nouv>
Why would they do that? Isn't it required for macros, and macros are a fundamental part of lisp?
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
<aeth>
I think that they use a tree-shaker to provide exactly the subset that the program needs, and nothing more. And macro expansion is (usually?) done at compile time, so if the macro isn't *called* at runtime... they can probably tree shake that away in the actual compiled binaries of the program.
rumbler31 has quit [Remote host closed the connection]
giraffe has joined #lisp
Achylles has joined #lisp
<|3b|>
some people object to the extra size of carrying around a compiler when you don't need one, so some lisps let you remove it
Tobbi has joined #lisp
itruslove has joined #lisp
nefercheprure is now known as TMA
cgore` has joined #lisp
cgore has quit [Ping timeout: 248 seconds]
<Nouv>
Are there any compilers written in lisp that turn lisp into assembly? Any as in available somewhere like github?
cgore` has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
EvW has joined #lisp
<pillton>
Nouv: SBCL, CCL, CMUCL, LispWorks and AllegroCL all do. ECL outputs C code which is compiled and loaded in to the run time environment.
<Bike>
are you talking about the runtime? i think for runtime compilation ecl uses bytecode
<Colleen>
Bike: drmeister said 12 minutes, 14 seconds ago: - we figured out the problem frgo is experiencing - calling foreign clbind methods with more than three arguments (and probably functions with more than four arguments) has a problem.
<Nouv>
pillton: I'll check those out, thank you :)
Achylles has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
<Bike>
nope, i spoke before checking the logs like a fucking fool
<pillton>
Bike: What?
<Bike>
nothing
<pillton>
Bike: Last I checked, an invocation of compile would generate C code.
rumbler31 has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]