grnman_ has quit [Remote host closed the connection]
surabax has quit [Quit: Leaving]
mindCrime_ has quit [Excess Flood]
mindCrime_ has joined #lisp
Sheilong has quit [Quit: Connection closed for inactivity]
CrazyPython has quit [Remote host closed the connection]
grnman_ has joined #lisp
torbo has quit [Remote host closed the connection]
luckless_ has joined #lisp
luckless has quit [Ping timeout: 240 seconds]
<nij>
Is there any shell script that compiles common lisp into shell?
<no-defun-allowed>
I hope not.
<nij>
Hmm.. why not?
<Bike>
well, you'd need a lisp runtime in shell script
<nij>
Is it possible?
<Nilby>
There are Common Lisp shells and mini-Lisps written in shell.
jnewton has joined #lisp
<no-defun-allowed>
Hopefully I never have to use either.
renzhi has joined #lisp
<nij>
no-defun-allowed: I'm thinking of an apocalypstic scenario xD
<no-defun-allowed>
This dictionary says an apocalypse is "something viewed as a prophetic revelation". Since people know that shells are pretty janky, I would say you are in a post-apocalyptic scenario already.
CrazyPython has joined #lisp
lotuseat` has joined #lisp
lotuseater has quit [Ping timeout: 250 seconds]
srhm has quit [Quit: Konversation terminated!]
jnewton has quit [Ping timeout: 245 seconds]
<Xach>
etimmons: adopt-subcommands got me to add support for looking up release info from gitlab
psilotorp has joined #lisp
<Xach>
it turned out to be pretty easy - i can mostly pretend it's github, the protocol of GFs meant I only had to implement a single method in a key place...
<copec>
nij bash is actually a bit faster than python in many cases, and it's directly interpreting the text stream, I've thought it would be funny to have a lisp on top of bash
<copec>
I should say, doing script things ie running a script from a shell
<pjb>
nij: be sure to update it if you find something.
<beach>
Good morning everyone!
<beach>
loli: Can you give me more context to your question? I am not sure what you are referring to.
<beach>
loli: We extracted the code for first-class global environments into the Clostrum library which has more documentation. There is also a presentation in the context of the online Lisp meeting that I made.
mindCrime_ has quit [Ping timeout: 252 seconds]
<loli>
I believe that was in response to your comment about it being more costly for CL to have a notion of either first class environments or modules.
<loli>
beach: if you don't mind, could you link me the presentaiton, that would be interesting to review
<beach>
OK, one thing at a time. :) I haven't finished my morning coffee yet.
phantomics has joined #lisp
<beach>
loli: "costly" in terms of performance or in terms of human effort?
<loli>
I believe it was in a discussion about performance, you mentioned nested hash table calls
<loli>
usually I see this as being inlined away during symbol resolution
<beach>
OK, I see.
<beach>
I don't think I said "nested", but OK, let me see...
<loli>
well I assume CL already deals with a flat version of this, as it has to lookup things in it's image which we can view as a flat table?
<beach>
Usually, a typical Common Lisp implementation uses the symbol as an indirection to the function, so that SYMBOL-FUNCTION merely accesses a slot in the symbol.
<beach>
But that won't do when you have first-class global environments, because it name must resolve differently in different environments.
<loli>
ahh, so when you use libraries, it dumps the names into the namespace so it's a O(1) lookup call?
<beach>
Yes, the late binding costs O(1) and a very small O(1) in a typical Common Lisp implementation.
<beach>
So what most previous work does is to replace that indirection by a hash-table lookup.
<beach>
Each environment then has a hash table mapping names to functions.
<jasom>
beach: do you forgo the late-binding when inlining would be permitted by the spec?
<beach>
But if you do a hash-table lookup for each function call, you will slow down that important operation by an order of magnitude.
<beach>
jasom: Correct.
mindCrime_ has joined #lisp
<beach>
jasom: I mean, yes, you are allowed to.
<loli>
yes, in the absence of symbol resolution step, that would cost you performance wise
<beach>
What do you mean by a "symbol resolution step"?
<loli>
thinking on it, I don't think it's relevant here, but it resolves the name to the proper one
<jasom>
A hash-table lookup is a larger (but still potentially O(1)) cost than reading a slot from a symbol
<beach>
It is still way too slow.
<loli>
have the schemes guys done first class environments, I heard the MIT guys have with their reflective tower?
<beach>
So what I did for the SICL work was that I use an indirection through a de-materialized "function cell" (just a CONS cell really), so that when code is loaded into some environment, the name resolves to an environment-specific cell.
<beach>
loli: Scheme has traditionally not been that concerned with performance, so they seem to accept the hash-table lookup for each function call. At least that's what Queinnec's work does.
<jasom>
like doing the hash-table lookup at compile time
<beach>
jasom: Then you no longer have late binding.
<loli>
I think factor does that, but keeps the illusion of late binding
<loli>
through some means
freshmaker666 has joined #lisp
freshmaker666 has joined #lisp
freshmaker666 has quit [Changing host]
<beach>
The factor does what? (Still working on my coffee).
absurdum has joined #lisp
<loli>
doing the hash-table lookup at compile time
DHARMAKAYA has joined #lisp
<beach>
Well the "some means" is the function cell I just mentioned.
<beach>
But I found no previous work that had done this.
<beach>
So it is easy to have first-class global environments or modules if you either don't need late binding (as static languages do) or if you don't care about performance of function calls.
<Nilby>
Another confusing language name: "I used this scheme to go factor scheme factor."
<beach>
So my work on first-class global environments solves the problem by resolving names to function cells at load time, but that works only when the name is known statically. If you call (SYMBOL-FUNCTION <non-constant-form>), then you still need a hash-table lookup, but the performance of such a call is less critical than that of a function call.
<beach>
Oh, and my ELS paper this year is another solution to the problem of late binding, and it is potentially even faster than the function-cell technique.
<loli>
Factor as a language is early binding, but with a few tricks, they make it seem like they have late binding which works in a lot of scenarios
<beach>
I see.
renzhi has quit [Ping timeout: 245 seconds]
<saturn2>
why can't each global environment have its own symbols?
drl has quit [Quit: Leaving]
<beach>
But on that page they talk about "interpreter", so they obviously don't position themselves in the "performance" camp.
<loli>
well they also talk about a compiler
<loli>
he mentions in the post replacing the interpreter with a compiler
<saturn2>
with a copy-on-write mechanism
<beach>
saturn2: They could. That's another possible solution. It would be very confusing, and you would need a way to refer to "the symbol which has the same name and package as this one, but in a different environment".
<loli>
beach: is your ELS paper released?
<beach>
loli: Yes. It's in the proceedings for this year's ELS.
<beach>
saturn2: Plus, because the reader creates symbols, you would have to decide on the module/environment at read time.
<saturn2>
beach: it would just be going from package->symbol to environment->package->symbol, so it doesn't seem much more confusing than packages are
<beach>
But it would have to be done at read time.
amb007 has quit [Read error: Connection reset by peer]
<loli>
ahh perfect I was just about to ask you if it was "Call-site optimization for Common Lisp" in the Preceedings
amb007 has joined #lisp
<beach>
Yes.
<beach>
That work is able to remove even the indirection through the cell most of the time.
<saturn2>
what is the use-case for first-class global environments?
<beach>
Several...
<beach>
I invented them so that I could isolate the host Common Lisp system from the SICL code during bootstrapping.
<beach>
SICL bootstrapping uses 5 different first-class global environments for different phases.
<beach>
But also as modules.
<loli>
beach: how limiting is having to do it at read time?
<beach>
You may want to isolate (say) the compiler internals from the API. Then if you put the internals in a first-class global environment by itself, you can "export" only the API to other first-class global environments.
<beach>
loli: I haven't investigated that.
aartaka_d has joined #lisp
<beach>
saturn2: So you can then also have different versions of the same system as long as each version is in a different first-class global environment. That solves the problem of two systems, needed simultaneously, require different versions of some library.
<beach>
saturn2: But my plan is also to use first-class global environments to isolate different users from one another, and to isolate users from the system, in a multi-user Common Lisp system.
<loli>
beach: with this new call-site optimization you found, is there still much more overhead versus the traditional model CL has? I'm curious from a new compiler perspective, and where the state of this research is at
<loli>
I'll read the paper in full later
<saturn2>
wow, that sounds very useful
aartaka has quit [Ping timeout: 252 seconds]
<loli>
saturn2: you can do a lot of fun things, I've thought of having some way of sharing my nyxt browser state between my machines, then switching to different environments for a different machines state, and manipulating that, and through some protocol send the changes back (this is a bit silly, but would be fun to try to setup)
<beach>
loli: No, it's the other way around. The work on first-class global environments is already as fast as the traditional indirection through a symbol, and the work on call-site optimization suggests that we will be able to do function calls as fast as a static language like C++ can.
<loli>
beach: perfect, I can use this to my own means, and hopefully give something back to this field at some point in the future.
<beach>
Great! What means are those?
Oladon has quit [Quit: Leaving.]
<loli>
Well I've been writing a compiler, and if things go well the language shall blossom quite nicely in enough time
<loli>
exploration of ideas is quite important
<beach>
I see. A new language?
<loli>
yes
<beach>
Good luck!
<loli>
thank you
akoana has left #lisp ["Leaving"]
jnewton has quit [Ping timeout: 240 seconds]
isBEKaml has joined #lisp
vsync has quit [Ping timeout: 252 seconds]
Oladon has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<terpri>
beach, any thoughts on object-capability security models? a la johnathan reeves's w7 or chris lemmer webber's spritely goblins
<terpri>
jonathan rees*
<beach>
The plan is to make CLOSOS mainly capability based.
<beach>
But not as extremely as (say) EROS.
<terpri>
cool
<beach>
More like Multics.
<terpri>
a number people thought that common lisp was basically impossible to secure, but i think they were overly pessimistic and perhaps stuck in an actor-model rut
Bourne has joined #lisp
<beach>
We haven't proven them wrong quite yet. A lot of work remains.
<terpri>
(granted, CL has a fair amount of global state and likely a number of funky edge cases)
<terpri>
beach, fair enough
nij has quit [Remote host closed the connection]
<terpri>
beach, any recommended reading for multics security? i'm totally unfamiliar with it (but willing to trawl through multicians.org if nothing comes to mind, it's be good to know multics better in any case)
<terpri>
it'd*
<beach>
I don't have anything specific in mind for the security aspect. But the basic idea is that you have an "object store" (i.e. the segment hierarchy in Multics) with ACLs (access control lists), and when you access an object in the store (done by the dynamic linker in Multics) the ACL determines the capability you get. After that, everything is capability based.
<beach>
EROS removed the ACLs, I think completely, and did everything with capabilities, but I find it hard to think in those terms.
<terpri>
beach, also...random question...would SICL potentially be useful for adding CL as a supported language to guile (a multilanguage scheme system that already fully supports "core" elisp and other langs)? e.g. for the later/higher-level parts of the spec? or is it its own thing like sbcl and other traditonal implementations?
CrashTestDummy3 has joined #lisp
vsync has joined #lisp
<beach>
Good question...
<terpri>
beach, i'll try it out when the time comes (i'm barely past number parsing!) and let you know if i discover anything interesting. really cool project either way
<beach>
I am afraid that the SICL system code is going to require its own bootstrapping technique. I used to believe that I could write "modules" of system code to be added to a partial Common Lisp system, but it turned out to be too hard for a person with limited brain capacity like myself to write modules in a subset of the language.
TK__ has quit [Ping timeout: 250 seconds]
<beach>
Thanks.
CrashTestDummy2 has quit [Ping timeout: 252 seconds]
<beach>
... so I decided to write the modules using the full Common Lisp language. But that means that you either need to have an existing Common Lisp implementation (which could be a slow interpreter) to load those modules. And then Guile would not qualify I guess.
<beach>
For SICL, I have a solution of course. I bootstrap using an existing conforming Common Lisp implementation, plus the CLOSER-MOP library.
<beach>
But Guile isn't built like that. Nor is any existing Common Lisp implementation as far as I know.
<moon-child>
beach: what are the access categories for ACLs?
<beach>
In Multic?
<beach>
s
<moon-child>
by which I mean, to what kind of entity is access to some object by its ACL?
<moon-child>
in closos
<beach>
I imagine the same as in Multics, i.e., user and group.
<beach>
Like beach.user or beach.admin.
<terpri>
yes, and "layering" CL in a nontrivial way would be difficult (or at least the proposals for it were rejected as too complicated or unnecessary iirc)
<beach>
Then the ACLs can contain wildcards like *.admin (read/write) and beach.* (read only).
<moon-child>
cool
<moon-child>
terpri: I expect an easier approach would be compiling a given language to cl
<beach>
terpri: Yes, the entire language is very tightly coupled. You can do evaluation at read time, etc.
<beach>
terpri: It is still possible to layer the implementation. For example, the SBCL compiler doesn't use classes or generic functions (or so I have been told). But I am not able to work like that.
slyrus has quit [Quit: Leaving]
<beach>
And I was told by stassats that there was no reason for the SBCL compiler to use generic functions and classes, because doing so would only have the effect of making it slower.
<beach>
Now, the way I see that issue is that, because generic dispatch is not very fast in SBCL, they then avoid the use of a great tool to write a major component of the system. I would much rather make generic dispatch faster and use the tool.
<terpri>
beach, btw, you *do* know of TUNES.org, right? conceptually, vaguely like CLOSOS, but much more of a pie-in-the-sky research project that fizzled out years ago; we were more often engaged in reflection-related wool-gathering instead of setting concrete goals and writing functioning programs (imho)
nij has joined #lisp
hypercube has quit [Ping timeout: 245 seconds]
CrashTestDummy2 has joined #lisp
<beach>
terpri: Yes, I know about Tunes. I know Fare fairly well.
orivej has joined #lisp
CrashTestDummy3 has quit [Ping timeout: 240 seconds]
<terpri>
beach, i thought i detected a hint of the TUNES-nature in the CLOSOS paper :)
<beach>
I wouldn't be surprised.
<beach>
Fare has a lot of good ideas.
<beach>
I mean, this stuff is not rocket science. Anybody thinking about what we have and what we are doing wrong would come to similar conclusions.
<beach>
The details may vary of course.
<terpri>
true
hypercube has joined #lisp
Oladon has quit [Quit: Leaving.]
shka_ has joined #lisp
sjl has quit [Ping timeout: 268 seconds]
<terpri>
a bit off-topic, but i'm personally interested in new approaches and optimizations for multiple dispatch, as adding prototypes with multiple dispatch to JS would allow me to (in a roundabout way) correct some serious design flaws in JS BigInt's design that i still feel guilty about (i was the main spidermonkey implementer and worked on other aspects of it)
<terpri>
(tl;dr google enabled a draft implementation early and changes to mathematical edge cases were rejected because "google says no", despite independent objections from me and fabrice bellard)
<terpri>
but for now there are more interesting and pleasant projects to work on in lisp-land
<terpri>
Nilby, oh, neat, i have in fact not seen them (despite being interested enough in dylan to have a dead-tree copy of the language reference). even some of the older papers look potentially relevant to modern JS, ty for the link!
Sauvin has joined #lisp
<terpri>
beach, you can indeed :) i think stumbling across that is how i actually heard about SICL
<Nilby>
terpri: You're welcome. I still harbor some nostalgia for Dylan.
<beach>
OK, good.
<Nilby>
beach: I was assuming they knew about your excellent papers too :)
<beach>
Heh *blush*.
Bike has quit [Quit: sleep]
sjl has quit [Ping timeout: 252 seconds]
contrapunctus has joined #lisp
hypercube has quit [Quit: WeeChat 3.1]
sjl has joined #lisp
amk has quit [Ping timeout: 240 seconds]
amk has joined #lisp
jnewton has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
narimiran has joined #lisp
hypercube has joined #lisp
isBEKaml has quit [Quit: leaving]
rumbler31 has quit [Ping timeout: 240 seconds]
jnewton has quit [Ping timeout: 245 seconds]
<splittist>
Kids, don't skip your trig classes. One day you're going to want to use the two-argument form of ATAN to draw Pacman...
<phoe>
there's also a shameless plug from me, https://github.com/phoe/binding-arrows - they have some semantic differences to the clojurelike implementation
<engblom>
phoe: Thanks! As they are separate libaries, I guess there is nothing that replaces them directly in the common lisp specification?
jeosol has joined #lisp
<phoe>
engblom: you are correct
<phoe>
the CL specification hasn't changed since 1994 and I don't know if anyone thought of arrow macros or something similar back in the way
<engblom>
Is there any work in progress to update the specification?
<phoe>
what do you mean by "update"?
psilotorp has joined #lisp
<engblom>
Like adding stuff like these arrows, and maybe stuff that makes it easier to do threaded programming in a safe way.
<phoe>
I guess not - there's no money on the table
<phoe>
and updating a huge language specification like ANSI CL requires tons of it.
<phoe>
the broader CL ecosystem has worked around this issue by means of libraries that can be implemented portably for stuff like arrows, and portability libraries that expose uniform API for stuff that requires implementation support
narimiran has joined #lisp
<engblom>
Not necessary, as many ideas could be brought directly from Clojure. It is not like the whole specification would need to be rewritten, just a few things added.
<phoe>
there was a panel about this specific issue during the European Lisp Symposium
<phoe>
in short: yes, it could be added, but the adoption rate is likely going to be minimal
psilotorp has quit [Ping timeout: 245 seconds]
<phoe>
there's the tiny cost of editing the specification, big cost of convincing the implementers that it is worth for them to add this into their implementations, and the impossible cost of getting everyone to agree that this it the changeset to ANSI CL that is The Correct One that should be The New One™
<phoe>
and then there's the obvious collective cost of writing the code, testing it, aligning it with other implementations, and maintaining it
<phoe>
I don't want to say that it can't be done, but I want to say that there's been an attempt to do so every few years since 1994, and the topic is brought up here every two weeks or so
<phoe>
and *nobody* has achieved much success in this area
<phoe>
so I guess that historical data speaks for itself
amb007 has quit [Read error: Connection reset by peer]
<engblom>
Ok. There is another thing that I wonder how to do best: threadsafe global variables. Clojure got such ones to read and set without any other thread interfering.
<nij>
(ps. anyone uses shcl as your main shell ;)? )
amb007 has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
amb007 has joined #lisp
CL-ASHOK has left #lisp [#lisp]
aartaka_d has quit [Ping timeout: 252 seconds]
whosit has quit [Remote host closed the connection]
CL-ASHOK has joined #lisp
bgardner has joined #lisp
bgardner has quit [Changing host]
bgardner has joined #lisp
<CL-ASHOK>
Anybody know how to disable all the system messages on Freenode (connecting via Emacs ERC)
bgardner has left #lisp [#lisp]
<splittist>
nij: because it has its own spawn (in C), that it says is more flexible than the POSIX spawn.
rixard has quit []
jnewton has joined #lisp
karlosz has quit [Quit: karlosz]
silasfox` has joined #lisp
silasfox has quit [Ping timeout: 250 seconds]
<p_l>
CL-ASHOK: ask on #emacs ? also beware, ERC is known to cause flooding by mistaken copy paste :)
orivej has joined #lisp
lotuseater has joined #lisp
<CL-ASHOK>
p_l: Oh, I better be careful about that :)
nullman has quit [Ping timeout: 252 seconds]
narimiran has quit [Quit: leaving]
nullman has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
CL-ASHOK` has joined #lisp
frost-lab has quit [Quit: Connection closed]
tumdum has quit [Remote host closed the connection]
niflce has joined #lisp
CL-ASHOK has quit [Ping timeout: 246 seconds]
amb007 has joined #lisp
nullman has quit [Ping timeout: 245 seconds]
<beach>
Another week, another request for updating the "specification".
<beach>
s/request for/desire to/
<beach>
And this time comparing it to Clojure that does not even have an independent specification. Oh well.
<nij>
splittist: how can it be even more flexible than uiop:run-program? I cannot think of a shell thing that you cannot do with uiop:run-program..
jnewton has quit [Ping timeout: 260 seconds]
<beach>
We should create a web page about "updating the Common Lisp specification" and teach minion to ask people to go read it.
mindCrime_ has quit [Ping timeout: 268 seconds]
silasfox` has quit [Ping timeout: 245 seconds]
whosit has joined #lisp
pbaille_ has joined #lisp
AreTaro has joined #lisp
pbaille has quit [Ping timeout: 240 seconds]
long4mud has quit [Ping timeout: 260 seconds]
Lord_of_Life_ has joined #lisp
rdd has quit [Ping timeout: 240 seconds]
Lord_of_Life has quit [Ping timeout: 245 seconds]
Lord_of_Life_ is now known as Lord_of_Life
AreTaro has quit [Quit: Connection closed]
undvrainbowvita8 has quit [Quit: EXIT]
bgardner1 has joined #lisp
bgardner1 has left #lisp ["User left"]
actuallybatman has quit [Ping timeout: 240 seconds]
CL-ASHOK` has quit [Ping timeout: 265 seconds]
renzhi has joined #lisp
undvrainbowvita8 has joined #lisp
heisig has joined #lisp
psilotorp has joined #lisp
psilotorp has quit [Ping timeout: 245 seconds]
<loke[m]>
beach where did you see that?
<beach>
loke[m]: <engblom> Is there any work in progress to update the specification?
<beach>
A little more than 3 hours ago.
<dieggsy>
I use SBCL at home, but Allegro at work - are there people that prefer non-commercial allegro over other lisps for personal use? Are there compelling reasons to do this?
<loke[m]>
Oh I see.
<loke[m]>
dieggsy: last time I looked at the commercial versions, the free editions were way too limited to be useful.
<dieggsy>
loke: ah, limited how? Limitations aren't readily apparent just from their web pages lol
<loke[m]>
I'm a lös somewhat active in the APL community, which had a similar problem. The main implementation was commercial and quite limited. The community didn't really take off until GNU APL came out and the commercial vendor had made the their full version available for nine commercial use for free.
<dieggsy>
loke: lös?
<beach>
Looks like a word from loke[m]'s native language. :)
niflce has quit [Ping timeout: 240 seconds]
CL-ASHOK` has joined #lisp
<loke[m]>
beach indeed. I'm on the phone now and sometimes I accidentally press the wrong suggested word (I've configured it for both Swedish and English at the same time)
rixard has joined #lisp
<beach>
Heh, I see.
CrazyPython has joined #lisp
maxwilliamson has quit [Remote host closed the connection]
Sheilong has joined #lisp
maxwilliamson has joined #lisp
<splittist>
nij: forgive me if I don't exercise your imagination for you when there is commented source code to read
Oddity has quit []
silasfox has joined #lisp
CL-ASHOK` has quit [Ping timeout: 245 seconds]
jnewton has joined #lisp
kenran has joined #lisp
Oddity has joined #lisp
<MrtnDk[m]>
loke So, what does "lös" mean in this context?
<loke[m]>
Mrtn Dk: It has no meaning in this context. It's just what the autocomplete thought was a good word. It means "loose".
<MrtnDk[m]>
loke I guess my question should have been; what were you trying to say?
<loke[m]>
Just remove "a lös". :-)
<MrtnDk[m]>
loke Ahh! Now it makes sense! Thank thee.
silasfox has quit [Quit: ERC (IRC client for Emacs 27.2)]
nullman has joined #lisp
silasfox has joined #lisp
CL-ASHOK` has joined #lisp
xkapastel has joined #lisp
<beach>
minion: Please tell engblom about updating the Common Lisp standard.
<minion>
engblom: please look at updating the Common Lisp standard: See http://metamodular.com/Common-Lisp/updating-the-standard.html for an explanation why it is not likely that there will be a revised Common Lisp standard, why a revised standard is most often not needed, and sometimes not even desirable.
<CL-ASHOK`>
minion: is the standard being updated?
<minion>
is the standard being updated: I can't be expected to work when CLiki doesn't respond to me, can I?
<beach>
minion: Thanks!
<minion>
you're welcome
<beach>
If someone would like to give me remarks on that document, that would be great. I wrote it in haste (and frustration), so I probably made mistakes. And I probably omitted important stuff.
<beach>
But I might not incorporate (even valid) remarks right away. I have more important things to do actually.
<CL-ASHOK`>
minion: what happened to CLiki?
<minion>
CLiki: a banana
jnewton has quit [Ping timeout: 268 seconds]
<CL-ASHOK`>
Would be great to have that wiki back and active
<CL-ASHOK`>
beach: do you have a link? I'll have a read
<beach>
Er, minion gave it to you.
<beach>
I even tried it myself.
<CL-ASHOK`>
Oh thanks, sorry I didn't fully follow the thread
<dieggsy>
beach: i think there's a typo in the first line - "has not been update" should be "has not been updated"
<beach>
Thanks.
<beach>
Fixed. Thanks again.
<jeosol>
beach: thanks for the write up. I am reading it currently and will provide any feedback if necessary.
<beach>
Great, thank you!
<beach>
No rush of course.
<jeosol>
The "update" comments come up every now and then and it's definitely good to have somewhere to point people
<beach>
That's why I finally wrote this stuff, yes.
<jeosol>
I definitely, love the part of "they are not really programming languages" but "programming systems" .. That's bound to drive people crazy.
<beach>
I get tired of explaining each time. And I get frustrated when I am not there to explain when the question is asked. :)
<beach>
Heh, thanks!
<jeosol>
beach: definitely a good thing and the document can be updated over time with more facts like you alluded to earlier
<beach>
I gave some careful thought to that phrase.
<jeosol>
but facts are facts
<beach>
jeosol: yes, I hope to add information to it. But it is already a bit long. I didn't see a way to make it shorter.
<jeosol>
I have definitely gotten more grey hair working with python to make things work (not my choice).
<beach>
We'll just strongly encourage the question askers to read it first.
<jeosol>
beach: Perhaps adding some sections later if necessary. I haven't finished reading it but it's definitely good to get a place to point people to
<beach>
Yeah.
<jeosol>
A lot of this also has to do with rigour of defining what constitutes a programming language, OOP, etc. People throw around terms, and those here, like yourself with CS and compiler backgrounds correct things, and I can get why it gets frustrating over time.
jnewton has joined #lisp
<beach>
I agree. And it is normal that #lisp has a mixture of people with different backgrounds and different knowledge. But I think one ambition of #lisp should be to lift the level of knowledge of those who could use it.
<beach>
... but maybe that's just the "teacher" half of me speaking and it may be harder than it sounds.
Bike has joined #lisp
<CL-ASHOK`>
nice article
<CL-ASHOK`>
esp this line: For something to be called a programming language, we think the minimum requirement is that it has a specification that is independent if its implementations, i.e., the programming systems that claim to be software that behaves according to the independent specification.
<Bike>
i should sketch up an explanation for eval and environments, since it's an interesting question and people get confused by it a lot
<Bike>
though i'm sure there are explanations already
<CL-ASHOK`>
Only question I had was why should a standards organization necessarily mean a meaningful cost: The first step would be to find an existing standards organization that would be willing to publish a revised standard. For an organization to be interested, they would at least be convinced that they would not lose any money doing so (recall that standards organizations are not charities or government agencies). If none can be found, one
<CL-ASHOK`>
would have to be created, which has its own cost associated with it.
<Bike>
as for the article, looks good. i'd maybe mention that for some thing like threads we have portability libraries, which aren't as good as a standard, but still provide many of the advantages a standard would have
<Bike>
for some things*
<CL-ASHOK`>
But its a moot point, no-one is going to update CL Standards (I don't even see the need), but for other standards, self publishing should be much cheaper than what it was before?
<beach>
CL-ASHOK`: Thanks.
<beach>
Bike: Oh, that would be great!
<beach>
And I should probably add some paragraphs explaining why, thanks to the macros system, new syntax can be provided in Common Lisp libraries, whereas other languages require a revised specification to accomplish that.
<beach>
Bike: yes, good idea about the portability libraries.
<beach>
They are just as good as, or even better than, unspecified features of languages without a standard.
<beach>
CL-ASHOK`: Thanks.
<beach>
Yes, self publication would be an option, but a document won't be taken seriously unless it has the name of a reputable standards organization on it, like ANSI, ISO, IEEE, etc.
<CL-ASHOK`>
I guess that's true for the foreseeable future
<CL-ASHOK`>
Can't believe it cost $1m for the standard, quite lucky to have it funded by the US govt
<beach>
Just the time taken from the vendors would add up to that.
yoonkn has joined #lisp
<beach>
Add to that travel cost (no Zoom at the time), renting rooms for meetings, meals, hotel rooms, etc.
<CL-ASHOK`>
Definitely
<beach>
The median annual wage (according to wwww.bls.gov) of a programmer is around 80kUSD. The cost (including benefits, fees, office etc) is probably twice that.
<beach>
But the ANSI committee members are not "median".
<Bike>
to write a really thorough explanation i'd probably feel the need to explain how a compiler works with example code and stuff... that's probably too complicated...
<beach>
So let's say the annual cost of one of those would be 200kUSD.
<CL-ASHOK`>
Goes to show how much undervalued FOSS contributions are
<beach>
Bike: If you have time, go for it!
<beach>
I don't know how many members of the ANSI committee there were, but perhaps 20 or more?
<beach>
If each one invested a few months of work, the cost would quickly add up.
<CL-ASHOK`>
For sure. Grateful for it to have been funded
<beach>
Er, no mistake. The annual cost of a median programmer would be 200kUSD. For a committee member, twice that.
<beach>
So just three person-years would burn up the budget. I am sure the investment was much greater than that.
<CL-ASHOK`>
Although depends if they pay. For example, in my old company, some of the senior members contributed voluntarily to World Economic Forum committee, as they get recognition from being part of the working group
bjorkintosh has quit [Quit: Leaving]
<beach>
Sure.
<CL-ASHOK`>
(defparameter ... can have doc strings?
<contrapunctus>
beach: I tried to shorten it a little, and also tried to rephrase it to be a little easier to read. Hope you don't mind Markdown. http://ix.io/3mTV
<beach>
contrapunctus: Thanks. It shall have to wait until tomorrow. I am working on other stuff right now.
<afasdf>
Why is the :thumbs of every plist in *images* set to "a", instead of just the plist retrieved by (first *images*)? How do I get the latter behaviour? This caused a bug which took half an hour to identify...
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<lotuseater>
loke[m]: do you know this awesome project for compiling APL with CL? :)
cl-newbie has joined #lisp
Bike has quit [Quit: Connection closed]
<cl-newbie>
Is there a way to bring up CLHS as a buffer in emacs (I think in Slime C-c C-d h brings it up as a webpage)
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<lotuseater>
cl-newbie: I've downloaded the html files. maybe one could convert them to .org for viewing directly in emacs?
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<_death>
emacs has browsers like eww and emacs-w3m
<lotuseater>
ah yes ^^
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
cl-newbie-1 has joined #lisp
<cl-newbie-1>
_death: but my guess is that is a bit inconvenient, as it won't be formatted as well as a native solution
<nij>
Ah it's actually a nice tip _death .. I will from now on read CLHS using eww.
<_death>
your guess is wrong, in my experience
<cl-newbie-1>
_death: :D okay let me try
<nij>
It's great as CLHS is almost text?
cl-newbie has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<_death>
yes.. furthermore, you can download the hyperspec and use it offline by setting common-lisp-hyperspec-root
amb007 has joined #lisp
ebrasca has quit [Remote host closed the connection]
cl-newbie-1 has quit [Remote host closed the connection]
aartaka has joined #lisp
<_death>
what's true is that I've been using emacs-w3m for a long time, and for a year or so I switched to eww, but I ended up going back to emacs-w3m with clhs.. I've this code in my .emacs: https://plaster.tymoon.eu/view/2441#2441
absurdum has quit [Quit: Leaving]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
silasfox has quit [Ping timeout: 245 seconds]
silasfox has joined #lisp
trevorb has quit [Ping timeout: 245 seconds]
<MrtnDk[m]>
_death It doesn't mention w3m though, it does contain some out-commented code for eww, but how is that supposed to make it use w3m?
<_death>
I use w3m-emacs by default
anticrisis has joined #lisp
jnewton has quit [Ping timeout: 240 seconds]
chees has joined #lisp
CL-ASHOK has joined #lisp
Michael1234 has joined #lisp
psilotorp has quit [Remote host closed the connection]
<MrtnDk[m]>
_death How? I remember resorting to eww after giving up on getting w3m to work with it. Oh wait ... are you using the online version?