bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
orivej has quit [Ping timeout: 240 seconds]
bhartrihari has joined #lisp
orivej has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
orivej_ has joined #lisp
bsd4me has quit [Quit: Leaving]
cosimone_ is now known as cosimone
countvaj` has quit [Ping timeout: 244 seconds]
EvW has joined #lisp
orivej_ has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
megalography has left #lisp [#lisp]
bsd4me has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
Oladon has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
countvajhula has joined #lisp
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 246 seconds]
ayuce has quit [Remote host closed the connection]
hsaziz has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
bsd4me has quit [Ping timeout: 240 seconds]
hsaziz has quit [Client Quit]
quazimodo has quit [Ping timeout: 258 seconds]
quazimodo has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
orivej_ has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
abhixec has quit [Ping timeout: 260 seconds]
orivej_ has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
EvW has quit [Ping timeout: 244 seconds]
bsd4me has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
vornth has quit [Ping timeout: 260 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
<torbo>
Looking at section 28.4.2 of the FreeBSD handbook, when replacing the default MTA with Postfix, the recommendation is to update /etc/mail/mailer.conf to override the default references to the sendmail binaries with Postfix ones. But, when I install postfix via `pkg install postfix`, the post-installation message recommends overwriting /usr/local/etc/mail/mailer.conf. Which of those two recommendations is correct, or are they both
<torbo>
correct? I notice that FreeBSD doesn't have a /usr/local/etc/mail directory in the default install -- at least not in the generic/freebsd12 Vagrant box -- so I have to first create one if I follow the post-installation message instructions. If I create /usr/local/etc/mail/mailer.conf, does it override /etc/mail/mailer.conf?
FreeBirdLjj has joined #lisp
<torbo>
Apologies, wrong channel.
FreeBirdLjj has quit [Ping timeout: 260 seconds]
Oladon has quit [Quit: Leaving.]
rats has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
orivej_ has joined #lisp
rats has quit [Client Quit]
ahungry has joined #lisp
countvajhula has quit [Ping timeout: 260 seconds]
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
orivej_ has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
Oladon has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej_ has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
orivej_ has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
torbo has quit [Remote host closed the connection]
elflng has quit [Quit: leaving]
elflng has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
Bike has quit [Quit: leaving]
Alfr__ has joined #lisp
Alfr_ has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 264 seconds]
orivej_ has joined #lisp
elderK has quit [Ping timeout: 246 seconds]
elderK has joined #lisp
dominic34 has quit [Ping timeout: 258 seconds]
<beach>
Good morning everyone!
orivej_ has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
<Oladon>
Mornin', beach!
dominic34 has joined #lisp
cosimone has quit [Quit: Quit.]
narimiran has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
space_otter has joined #lisp
Jeanne-Kamikaze has joined #lisp
Misha_B has quit [Quit: ERC (IRC client for Emacs 26.3)]
orivej has quit [Ping timeout: 260 seconds]
orivej_ has joined #lisp
orivej_ has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
<beach>
phoe: Thanks for showing me the link https://blog.nelhage.com/post/reflections-on-performance/ during the online Lisp meeting. It was very interesting reading. But I am curious, what was your reason for showing it to me? You probably have some thoughts about the contents yourself, right?
dominic34 has quit [Ping timeout: 260 seconds]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
shifty has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
bsd4me has quit [Quit: Leaving]
orivej has quit [Read error: Connection reset by peer]
orivej_ has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
froggey has quit [Ping timeout: 240 seconds]
froggey has joined #lisp
orivej_ has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
Jeanne-Kamikaze has quit [Quit: Leaving]
orivej_ has joined #lisp
orivej has quit [Read error: Connection reset by peer]
<beach>
Basically, bindings of special variables are specific to each thread.
<beach>
This is how Common Lisp implementations implement thread-specific storage.
satousan has joined #lisp
<markasoftware>
Ok. I had always assumed that a (let) of a special variable simply stored the variable's value to a temporary location, then reassigned the variable, executed the body, then restored the old value
<beach>
That model works in an implementation without threads.
<beach>
What you are describing is called "shallow binding".
<beach>
With threads, you either need to use "deep binding" or you need to complicate things.
<beach>
With "deep binding", you store the bindings in the dynamic environment, and you need to search for the most recent one.
<markasoftware>
I see. But the spec doesn't preclude the use of shallow binding?
<markasoftware>
it's just implementations?
<beach>
With shallow binding, you can no longer have a single slot for all current values of a variable.
<beach>
So implementations that use shallow binding have storage in the thread object for the current value of variables.
gravicappa has joined #lisp
Posterdati has quit [Read error: Connection reset by peer]
<beach>
The spec has no opinion about the type of binding that is used, as long as semantics are preserved.
<beach>
The thing is that the standard does not include threads.
Posterdati has joined #lisp
<markasoftware>
deep binding is basically storing a stack of values?
<beach>
So we have collectively decided that, with threads, the global value of a variable is shared, and the run-time bindings are per-thread.
<beach>
Yes.
<markasoftware>
ok. And *standard-output* is dynamically bound?
<beach>
They are stored in the dynamic environment, together with condition handlers, block names, catch tags, etc.
<beach>
It has a global value.
FreeBirdLjj has quit [Remote host closed the connection]
<beach>
So if the application does not bind it, then that global value is used by all threads.
<markasoftware>
Is the dynamic environment thread local?
<beach>
But if a thread rebinds it, that binding is for that thread only.
<beach>
Yes.
FreeBirdLjj has joined #lisp
<beach>
You can think of it as a list of entries parallel to the call stack.
<beach>
You should have watched my presentation for the online Lisp meeting yesterday. I explain the dynamic environment there.
<markasoftware>
cool, thanks for the info. I have been playing around with hunchentoot and got tripped up by special variables a bit.
<beach>
I see.
<markasoftware>
I would like to attend one of those meetings, but as an american I have to weigh it against my sleep.
abhixec has joined #lisp
<beach>
They are recorded, so you can watch them when you wake up.
orivej_ has quit [Ping timeout: 258 seconds]
FreeBirdLjj has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
<aeth>
heh, online Lisp meetings
<aeth>
looks like the start of a new Common Lisp standard :-p
bocaneri has joined #lisp
<markasoftware>
when you want to lookup a variable, you scan through the whole call stack for the first mention of it?
<markasoftware>
if it is not special
ahungry has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
satousan has quit [Quit: WeeChat 2.3]
seok has joined #lisp
<seok>
Is there a util function somewhere to simply convert CLOS instance to a hash
<seok>
sounds like a bad idea eh
<flip214>
seok: some hash value depending only on the contents, or the identity? If the contents, how deep?
<seok>
shallow
<seok>
contents are just ints and strings
<seok>
hm, there is c2mop functions
<seok>
I think I can write one with those
abhixec has quit [Quit: leaving]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
<seok>
nice, I've done it
<seok>
thank you phoe I've copied your toolbox : D
Oladon has quit [Quit: Leaving.]
<flip214>
seok: well, do you need EQ on bigints and strings, or just EQUAL, to get identical hash values?
<beach>
markasoftware: If the variable is not special, then it is lexical, and the compiler has translated it into a register or an offset into the stack frame, so the access is very fast.
<beach>
markasoftware: That's another thing I show in part 2 of my presentation for the online Lisp meeting.
<markasoftware>
yeah, i was watching it
<beach>
Great!
orivej has quit [Quit: No Ping reply in 180 seconds.]
space_otter has joined #lisp
<beach>
markasoftware: Thanks for confirming my intimate conviction that software developers must have some knowledge about compiler design.
<beach>
... and computer architecture, and operating systems, and ...
orivej has joined #lisp
<markasoftware>
lol, lisp has forced me to understand a thing or two about the whole compilation process. I'm perpetually halfway through writing a toy lisp interpreter (no bytecode) in C
libertyprime has joined #lisp
<beach>
Oh!
<beach>
Then you need to watch part 1 as well, and part 3, 4, ... when they are ready for presentation.
<beach>
markasoftware: Maybe I have asked you this before, and if so, I apologize, but what is your reason for this project of yours?
<markasoftware>
yep, for sure, I will keep an eye out for them on reddit
<markasoftware>
in hunchentoot or the interpreter?
<beach>
Interpreter.
<markasoftware>
just for fun/to learn. It's going to be very simple, the "call stack" I have so far is implemented as structs with pointers between them, not contiguous memory like any half decent compiler
<markasoftware>
which is similarly simple to how I would like my lisp to be
<beach>
OK.
<markasoftware>
you're working on a full fledged CL implementation, right?
<beach>
Correct.
<beach>
minion: Please tell markasoftware about SICL.
<minion>
markasoftware: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
<beach>
minion: Please tell markasoftware about Cleavir.
<minion>
markasoftware: Cleavir: A project to create an implementation-independent compilation framework for Common Lisp. Currently Cleavir is part of SICL, but that might change in the future
orivej has quit [Ping timeout: 258 seconds]
orivej_ has joined #lisp
thecoffemaker has quit [Ping timeout: 256 seconds]
orivej_ has quit [Read error: Connection reset by peer]
orivej has joined #lisp
rogersm has joined #lisp
PuercoPop has quit [Remote host closed the connection]
jonatack has quit [Ping timeout: 272 seconds]
bsd4me has joined #lisp
teej has quit [Quit: Connection closed for inactivity]
<phoe>
beach: my question was directly related to the context, "does it need to be fast?", since I actually thought "how do people use a slow package manager, and how would people use a fast package manager?"
<phoe>
and it is a pretty random one that just came to me in the context of Guix
orivej has quit [Read error: Connection reset by peer]
<beach>
I see.
orivej has joined #lisp
<beach>
phoe: I basically agree with the blog on the link. In fact, when I design some library or application, I have performance in mind from the start.
<beach>
I don't agree that choosing C++ is one of the factors that will contribute to the performance, as I have often explained.
<beach>
phoe: Are you busy? I have some stuff I would like to bounce on you. It is related to Common Lisp so it's on topic.
<phoe>
beach: I'm waking up and preparing for work, but I'll be able to respond to these things soon.
bsd4me has quit [Ping timeout: 240 seconds]
<beach>
OK.
<phoe>
So, feel free to throw them at me, I just will need to take some time with responses.
<beach>
Will do, thanks.
orivej has quit [Quit: No Ping reply in 180 seconds.]
<beach>
These online Lisp meetings, and also the format of recording some video, have revived my ideas for how an online "lecture series" should be structured. I imagine it as being a replacement for the "lecture" part of a university course. The main idea is to have a big graph of nodes, where each node represents maybe 5 minutes of information, corresponding to the attention span of the new generation.
<beach>
There would be a main path to follow for the majority of the participants, but also shortcuts for people who know the contents of some nodes, and diversions for people who lack the background for some nodes. A node could contain some text, some sample code, some figures, and (this is the reason I thought about it) some video snippet, perhaps with some "animations" similar to what I did with the call stack.
<beach>
This idea is related to Common Lisp because I think it would be great to create such a "lecture series" with the purpose of teaching Common Lisp. Existing courses seem to be mostly crap all over the world, and such a lecture serious could help students, but also inspire teachers to do a better job teaching it.
<beach>
And we could point newbies to it, as a complement to suggesting books, which seem to require more attention span than young people these days seem to have.
orivej has joined #lisp
<phoe>
beach: where can I sign up for this
<phoe>
I like it
<beach>
Thanks.
space_otter has quit [Remote host closed the connection]
testnode has joined #lisp
<beach>
For example, many times I have explained why (defun f (x) (push 234 x)) (f *some-var*) does not have the result that many newbies expect. One of my "animations" would get it across in a few seconds.
<beach>
I would need to develop a better tool for those animations if I were to do it more often, but I think McCLIM would be ideal for that.
<testnode>
In SBCL lisp, trying to declare a local alien variable with 'with-alien' but having problems. code: (let ((magic (with-alien int 10))))
<phoe>
testnode: WITH-* macros usually have dynamic scope, meaning that once you leave the WITH-ALIEN macro, I expect the foreign variable to no longer be available.
even4void has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
<phoe>
if you want to manually allocate and free it, you can use MAKE-ALIEN instead
<testnode>
Ah that make sense, going to try it without using let then
<testnode>
You were right, this worked: (with-alien ((magic int 10)))
shifty has quit [Ping timeout: 264 seconds]
shifty has joined #lisp
even4void has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rogersm has quit [Ping timeout: 244 seconds]
<v3ga>
beach: that sounds like a good idea. Also if you're trying to adopt new and YOUNG users...I'm not sure if anyone has children or nephews/nieces but there's a trend for people up to their mid 20s now where they literally like to sit and watch people play games. To get to the point I'm also noticing people like to watch others code on twitch. Literally just recording the screen and working on their
<v3ga>
projects. Some narrate and discuss/solve problems with their viewers. That's the new shift.
ljavorsk has joined #lisp
<v3ga>
and I think that works well, you get to see that even people with experience have to sit down and break problems off opposed to thinking they just snap their fingers and solve problems MUCH FASTER than you.
ggole has joined #lisp
<v3ga>
Baggers is a common lisp channel I glance at a few times a week as I decide if common lisp is something I want to invest in.
wxie has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
<edgar-rft>
beach (and everyone who's interested): IMO an important aspect is that if you write programs for *other* people you have to learn to see the problems throught the eyes of other people. Thjs makes you learn much more than only learning the language itself. I have no really good idea how to include this aspect in teaching videos.
bhartrihari has joined #lisp
<v3ga>
edgar-rft: I do. start a weekly newsletter sending out problems where people send/discuss their solutions and over time you get a grasp on where people go wrong
<beach>
v3ga: Thanks.
* v3ga
thumbs up
<beach>
edgar-rft: That aspect has permeated my teaching as long as I can remember. But as Steven Pinker reminds us, it is apparently a very hard thing to do.
cjb has joined #lisp
<beach>
Done right, a project to create such a "lecture series" would have to involve several categories of people. Domain experts, of course (in this case expert Common Lisp programmers), but also experts in pedagogical technique (to design the graph, and the node contents), technicians to do the recording, and physical layout of the nodes. But we don't have that luxury.
<phoe>
beach: don't have it *yet*
<beach>
Right.
<phoe>
I think that if one actually starts, they'll arrive as the process continues
<beach>
But I am thinking, between the numerous talented people hanging out on #lisp, I think we could get a reasonable approximation.
<phoe>
I don't think that we need all of the above people to start with the first iteration of the idea - and even then it'll be more like continuous improvement and development rather than numbered iterations
<beach>
Yes, and the project would have to be designed so that the "graph" can be modified.
<edgar-rft>
Trying to include the practical aspects is the most difficult thing ever. One could try to write programs that cover each and everything that *might* go wrong but this would end up in creating the most bloated, unmaintainable, and probaly slowest programs ever. How does one fond the right balance?
<phoe>
beach: that one isn't really hard, is it?
<beach>
phoe: Probably not.
<beach>
edgar-rft: Are you still talking about this idea of mine? If so, are you referring to the code that gets exposed to the "students"?
<edgar-rft>
To everybody who doesn't know: RFT is the german abbreviation for a professional media electrician. I know foe example how to do audio and video recordings and post production. I'm working for several german TV and Radio stations. Let me know if I can help.
<phoe>
edgar-rft: ha!
arbv has quit [Ping timeout: 240 seconds]
wxie1 has joined #lisp
<beach>
edgar-rft: Wow, nice!
<beach>
That's kind of what I meant when I said that there are a lot of talented people hanging out here, and that we would cover most of the expertise required.
<beach>
In a project like this, I myself would volunteer to do explain "uniform reference semantics", "evaluation model", stuff like that. And I would use "animations". But I would not be able to do the web design.
<beach>
s/do//
<phoe>
there's web design people in the Lisp community though, #lispweb exists and such
<beach>
Exactly!
<phoe>
maybe someone would be interested enough to contribute
<beach>
Again, I think this community represents a very broad spectrum of expertise.
wxie has quit [Ping timeout: 256 seconds]
wxie1 is now known as wxie
<edgar-rft>
unfortunately #lispweb is the deadest channel ever :-( and I myself am not good in web stuff either
<beach>
But we have others. Like Shinmera, for instance. Not that he is necessarily available. I just mean that there are people here who know stuff like that.
orivej has quit [Ping timeout: 246 seconds]
<phoe>
and/or people who can learn stuff as it's required
<beach>
That too.
orivej has joined #lisp
<edgar-rft>
It's always good to have *several* people per job. Working on volunteer basis usually means that people have to do paid work first.
rogersm has joined #lisp
<beach>
True. Though I am in a position where teaching is part of my job, so I could justify some work on such a project as part of my job.
<beach>
I am busy with SICL and the associated research of course, so I can't work full time on it.
<edgar-rft>
I'm partially retired, so having enough time is luckily not my biggest problem :-)
<beach>
Brilliant!
<aeth>
I personally left #lispweb because nothing ever happened there
<beach>
We don't have to start such a project at this very moment, but it would be interesting to keep in mind, and to give some thought to what each person would be willing to contribute.
shifty has quit [Ping timeout: 240 seconds]
<aeth>
I guess people just ask their web questions in here
<aeth>
#lispgames thrives because games are... kind of their own thing
<aeth>
(I say that, but it hasn't had recent activity)
<beach>
There is a balance to be had between the number of channels and the "noise" in unrelated channels. Often that balance must be the result of experience.
<beach>
There is a tendency to create a new forum each time some sub-topic is identified, but that's usually a bad idea.
<edgar-rft>
beach: I also thought that it's not imminently urgent, but it would be good to start a survey how many people would be interested to help because producing interesting videos is *much* more work than initially expected by people who never did such things before. :-)
<beach>
Good point. That's partly why I announced what I would be willing to do and how I would do it.
<aeth>
edgar-rft: no, videos are even more work than that
<beach>
aeth: Even more than *much* more?
<aeth>
A lot of the highest quality YouTube channels are lucky to release videos several times in a month.
<edgar-rft>
For example I instantly fall asleep when watching screencast videos with longwinded explanations, or where I am forced to wait 30 seconds until some file in the video gets loaded.
<aeth>
The highest quality channels seem to tend to release things at most weekly, based on my rough skimming through quite a few in different topics.
<aeth>
Daily stuff tends to be unedited live recordings, yeah.
<aeth>
This seems to suggest that editing is either a lot of work or particularly unfun work or both
mankaev has quit [Remote host closed the connection]
mankaev has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
<edgar-rft>
I think it's not super-important to release videos as fast as possible, it would make more sense to build up a collection that's still useful in ten years or so. Luckily the Common Lisp spec is unlikely to change in the near future :-)
mankaev has quit [Remote host closed the connection]
mankaev has joined #lisp
<aeth>
Yeah, but we should've gotten started in 2010
<edgar-rft>
yes, because then the first video might be finished in 2050
orivej has joined #lisp
<aeth>
just in time for the new edition of the CL standard ;-)
<aeth>
Actually, aim for 2094 (for both)
<aeth>
it is... technically possible for me to still be alive in 2094
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
cjb has quit [Quit: ERC (IRC client for Emacs 26.3)]
<lukego>
Youtube videos are a fascinating medium. I'm consuming a lot of information that way lately. I seem to especially enjoy long videos without any dialogue, where you can just look over someone's shoulder, and tutorials that go at breakneck speed so that you can barely keep up (but can slow down playback and rewind when you care about a detail you missed)
<lukego>
but I'm not consuming so much programming content as other stuff that's more naturally visual e.g. soldering, 3D modeling, bushcraft/outdoors skills
pve has joined #lisp
ldb has joined #lisp
<edgar-rft>
Common Lisp outdoor videos sounds like an interesting idea :-) Let's use Common Lisp in the wild!
<v3ga>
lukego: i told them! =P both youtube and twitch. There used to be a guy that was writing a day trading bot in clojure...long 3-8 hour videos. Given, I didn't watch all of it but it was interesting. No dialogue, just music in the background but it was interesting to see him organize and solve his problems
even4void has joined #lisp
testnode has quit [Remote host closed the connection]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
<lukego>
I tried making videos for a while but I made the mistake of trying to talk continuously about what I was doing. Ojojoj. Just a lot of waffling that's boring to listen to and distracting to do. Thankfully with Youtube people can just change the channel rather than discretely use their phone/laptop for 45 minutes until the talk is over :)
even4void has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
orivej has quit [Ping timeout: 265 seconds]
orivej_ has joined #lisp
datajerk has quit [Ping timeout: 260 seconds]
<edgar-rft>
lukego: It's nearly impossible to make videos that are *interesting* to watch with the very first shot. My daily job is to look for the best sentences from the first *few* shots and make it look as it it was filmed in *one* go. But that needs of course much more time than the few minutes you see in the video.
karlosz has quit [Remote host closed the connection]
<TMA>
producing X minutes of something good takes (* N X) minutes of effort for N on the order of tens to hundreds even in the most fortunate and simple cases
<TMA>
I can spend weeks analyzing a thing where the result can be summarized in two paragraphs to be read under two minutes
orivej_ has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
datajerk has joined #lisp
<edgar-rft>
We usually calculate 30 hours work (all people together) for 1 minute in the TV news and 100 hours for a 1 hour radio show.
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
deselby has quit [Quit: Idle for 30+ days]
<beach>
Wow, that's amazing.
<beach>
Harag: Look at https://github.com/robert-strandh/Sandbox which contains 167 lines of code for implementing the sandbox environment using the technique I mentioned, i.e., it translates the form to an AST using Cleavir with respect to a first-class global environment, then translates the AST back to Common Lisp but with functions looked up on the first-class global environment.
<beach>
Harag: It is not perfect. It doesn't handle errors and such. So there is still some work to be done. That work should be a matter of a few hours, unless I overlooked something.
orivej has quit [Quit: No Ping reply in 180 seconds.]
<beach>
Harag: To try it out, load the system, then type (repl). I removed the function CADR from the environment, so if you try say (let ((x 10)) (car (list x 234))) it works fine, but if you try (let ((x 10)) (cadr (list x 234))) you get an error.
orivej has joined #lisp
<beach>
Harag: It is fine with me if you reject this solution based on the need for SICL, but that's the best I can do at the moment. I need to get to work on some other stuff, so I am afraid that's all the time I can afford to spend on this. Good luck.
ldb has quit [Ping timeout: 246 seconds]
ldb has joined #lisp
<ldb>
hellp
<beach>
Harag: Another idea that occurred to me was to use Eclector and to intercept attempts to intern symbols in the CL package, and instead interning them in a sandbox package. But I haven't thought through the consequences of such a solution.
<beach>
ldb: Is that a function to determine whether an object is in fact hell?
markoong has joined #lisp
<ldb>
beach: no, it's a typo made by "o is too close to p"
jonatack has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
<beach>
Ah! Hello then.
heisig has joined #lisp
orivej has joined #lisp
<v3ga>
hmm, is there a style guide or naming convention that CL devs try to follow or is the community more so 'free'?
<phoe>
v3ga: google style guide + norvig slides
<ldb>
beach: I see you mentioned recording to the online meetings in irc log, would you mind show me the link?
<v3ga>
like in clojure generally your main function or entry point would go in 'core.clj' etc
<beach>
v3ga: I am also very attached to the advice given in the LUV slides by Norvig and Pitman. Unfortunately, many of our fellow #lisp participants violate the "rules" in there all the time.
shifty has joined #lisp
<beach>
I frequently point to page 13.
<beach>
v3ga: It is somewhat amusing to me that amateur newbies frequently reject the advice given by professional Common Lisp programmers with decades of experience from projects with many developers.
<v3ga>
beach: ok, i'll take a look at it. This first guide may have answered my question. partcularing the architecture section. To reduce it...they basically say take time to explain your structure. I'm ok with that. =P
<phoe>
v3ga: the issues it that many Lisp programs don't have main functions of their own, since they're meant to be used from the REPL and not from the unix shell
<beach>
v3ga: For software architecture, I recommend you start by designing a bunch of protocols, usually based on generic functions and standard classes.
<phoe>
but, if anything, I guess that a main.lisp won't hurt if your program requires to be run from outside Lisp
<v3ga>
beach: well...arrogance. they may not understand the importance of patterns
<phoe>
patterns is a troublesome word, I'd say "conventions"
<v3ga>
phoe: but I prefer monolith.lisp =) jk
<beach>
v3ga: I think it just has to do with a tendency to underestimate the importance of conventions for others to understand the code fast.
<phoe>
there's already a term of design patterns and some of these are obsoleted by Lisp
<v3ga>
beach: yup. i'm learning that now but i've read a bit on refactoring and settings things up a certain way despite the goal of the app to make pieces swappable,etc
<beach>
v3ga: For some reason, it is often the case that newbies, while never taking the freedom to change word order or punctuation in English, somehow think it's an individual choice to do the analogue thing in their programming.
ldb has joined #lisp
<beach>
v3ga: And that is fine with me. They are free to do that. But then, they have the nerve to submit their code for others to read. And it seems they don't really want remarks or feedback; just a pat on the back. When they don't get that, they get very angry.
<v3ga>
beach: well... yeah i'm not sure. I think even explaining your steps in comments before coding would work well. I suppose it just depends on your exposure. I recall taking a programming class in HS in 2002 and we had an old teacher that made us do most of our homework in UML.
<v3ga>
I wouldn't force or suggest that today but even using VB...we learned UML that spring lol.
markoong has quit [Ping timeout: 240 seconds]
<TMA>
As a newbie, I did not consider programs to be meant for programmers to read, I thought it was just between me and the computer. I became conscious of the error only later. Not a thing I am proud of
orivej has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
<ldb>
it is not meant to be read as an abstract specification
<v3ga>
TMA: I think that can be fine. for me, i'm wordy so i've always wrote a lot as a scratch pad. may as well put it in comments then over time I learned to clean it up
kaftejiman has joined #lisp
<ldb>
rather it is a partiacular solution that requires the reader to follow the text (code)
<TMA>
I still produce write-only throw-away pieces from time to time, trying to shave off some seconds by being sloppy.
markoong has joined #lisp
<v3ga>
especially with lisp where you often can execute code thats commented out. Toy around and leave a few working examples at the bottom
<TMA>
I am not showing those off however, there is no place for being deliberately sloppy when soliciting feedback.
<lukego>
edgar-rft: sounds cool, what do you work on?
<v3ga>
I actually will make a git branch of an initial version with extra junk code so I remember what I was doing then in my regular branches I remove it or clean it up
<lukego>
I have a friend who produces a podcast pretty efficiently. He makes a list of lots of people who could be on it, hands that to an assistant who contacts and schedules them. Then he does the interviews himself or with one or two other people, who all have relevant subject matter experience and don't need much preparation. Finally the recording is sent off for pretty generic editing (cutting out "umms" etc) and away it goes.
<lukego>
(I don't actually listen to those podcasts myself though, not having the attention span and preferring to read transcripts...)
<lukego>
Lisp podcast could be cool though :)
<beach>
TMA: That attitude is fine with me. But then they should really keep the code to themselves. The problem is when they have a bug they need help with. Then it becomes kind of necessary to have others read it, and the assumption that it is between them and the computer is no longer valid.
<lukego>
Sorry maybe it's not the time for spitballing ideas anyway when there's already momentum behind a cool new Lisp video meeting series :) don't mean to distract, that is all kinds of awesome
wxie has quit [Ping timeout: 260 seconds]
<beach>
TMA: And then they demand that the person helping them try to understand the code even though it is badly indented, uses incomprehensible symbols (sometimes in a language other than English), does not follow even the most elementary rules of software engineering.
<edgar-rft>
lukego: right now I'm transferring medieval folk music to be playable on a chromatic sopranino recorder with lilypond (guile scheme) but next week we'll do audio recordings for a psychiatric radio magazine in a local patient's daycare club, what probably will be funny.
ldb has quit [Ping timeout: 264 seconds]
ldb has joined #lisp
arbv has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
arbv has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 256 seconds]
<shka_>
how i can 'cast' -1 to unsigned-byte
<shka_>
?
zge has joined #lisp
<beach>
What do you want the result to be?
orivej has joined #lisp
<beach>
And unsigned-byte what? Bytes have an arbitrary number of bits in Common Lisp.
<shka_>
beach: (unsigned-byte 64) to be precise
<phoe>
shka_: (ldb (byte 64 0) -1)
<shka_>
phoe: thank you kind spirit!
<phoe>
that'll give you #b1111111111111111111111111111111111111111111111111111111111111111
<phoe>
if that is what you are looking for
<shka_>
yes, this is exactly what i want
<shka_>
which i didn't articulate correctly
<shka_>
it is part of a slightly complicated hashing procedure, i really don't want to explain why i need this to be specific
<shka_>
but it works
<shka_>
awesome
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
ldb has quit [Ping timeout: 260 seconds]
random-nick has joined #lisp
cosimone has joined #lisp
akoana has joined #lisp
jonatack has quit [Ping timeout: 240 seconds]
<shka_>
heh, now i have like 10 hours to wait for result
<shka_>
big data is fun! :/
jonatack has joined #lisp
wxie has joined #lisp
shifty has quit [Ping timeout: 264 seconds]
<edgar-rft>
somewhere I read that using Lisp in the 1960s was like "we computed until all the memory was full, then we started the garbage collector and went home because garbage collection would not be finished before the next morning"
shifty has joined #lisp
<ghard>
edgar-rft: I think "Successful Lisp" at least had a mention of that no?
<ghard>
But, well, the first book on Lisp (actually first or second programming book I owned) was the Winston / Horn book. Not the 60s but well before CL
<ghard>
It's all MACLISP methinks
<ghard>
"They don't make garbage collectors like they used to."
orivej has quit [Quit: No Ping reply in 180 seconds.]
<ghard>
I guess mark-and-sweep was still very much state-of-the art then?
orivej has joined #lisp
ayuce has joined #lisp
wxie has quit [Ping timeout: 240 seconds]
wxie has joined #lisp
<shka_>
edgar-rft: not only in the 60s
orivej has quit [Quit: No Ping reply in 180 seconds.]
<ghard>
re. style questions - what seems to be the general consensus on package naming wrt cl-flurbalizer <=> net.zonk.cl-flurbalizer ? I have hard time deciding.
<shka_>
early lisp machines were quicker to restart then to wait of GC to finish
LdBeth has joined #lisp
<shka_>
AND they booted very slowly as well
<shka_>
ghard: there is no general consensus
orivej has joined #lisp
<shka_>
i think that local nicknames made the second style more practical
<ghard>
Oh that's for sure
<shka_>
so maybe go for the second style
<ghard>
It's mostly hu.dwim.* libraries in the wild I've seen using that style.
<shka_>
oh, not only
<LdBeth>
and the first garbage collator memory fulled during the demonstration by John McCarthy
<shka_>
LdBeth: that demo didn't went well, huh?
<LdBeth>
ghard: gigamonkeys.com
vaporatorius__ has joined #lisp
<shka_>
ghard: there is actually quite people using this style, and strictly speaking it is better for being unique
<LdBeth>
due to the book Practical Common Lisp
<ghard>
Yes my instinct tells me the domain name-based convention, though more verbose, would be better.
<LdBeth>
shka_: that became a infamous source for people who feels gc unreliable
<shka_>
but local nicknames were not there and well… this leaves you with either using full package name always, using whole package or importing individual symbols
vaporatorius has quit [Ping timeout: 240 seconds]
<shka_>
all of those options have problems
<ghard>
LdBeth: a bit like why we stopped developing lighter-than-air aviation :)
Lord_of_Life_ has joined #lisp
<shka_>
LdBeth: so, 60 years ago GC failed and I still don't think it is good enough
<shka_>
great logic :D
<ghard>
That's the human condition right there
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
stepnem_ has quit [Read error: Connection reset by peer]
stepnem has joined #lisp
even4void has joined #lisp
wxie has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
bitmapper has quit [Ping timeout: 240 seconds]
<phoe>
(define-condition human-condition () ())
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
heisig has quit [Ping timeout: 240 seconds]
<flip214>
phoe: why not base class WARNING?
markong has joined #lisp
markoong has quit [Ping timeout: 256 seconds]
<phoe>
flip214: right, should be ERROR
vornth has joined #lisp
orivej_ has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
orivej_ has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
<zge>
hi, does anyone know how to get a list of eql specializers for a method?
orivej has joined #lisp
elosant has joined #lisp
Frobozz_ has joined #lisp
beach` has joined #lisp
Frobozz has quit [Ping timeout: 264 seconds]
even4void has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
orivej has quit [Quit: No Ping reply in 180 seconds.]
<phoe>
$insults = Array("Perhaps you need to reread the spec?", "You're no pfdietz, that's for sure!", "I'm not sure why you thought that was a valid symbol, but you're wrong!", "What's your problem?", "Brucio? Is that you?", "But it will be available in IncreduLisp.", "I think you're confused.", "TRY HARDER!", "I'm a free variable! Bind me!");
jonatack has quit [Ping timeout: 240 seconds]
<phoe>
o-oh my
<zge>
phoe: thanks!
<phoe>
zge: to answer a bit more elaborately, all contemporary implementations implement the MOP with only minor quirks, and closer-mop is a portability library that offers a unified interface for these and also fixes some of these implementation-dependent quirks so the behavior are uniform.
<phoe>
s/are/is/
<ioa>
XD
orivej has quit [Ping timeout: 265 seconds]
orivej_ has joined #lisp
msk__ has joined #lisp
ebzzry_ has joined #lisp
ebzzry__ has joined #lisp
msk has quit [Ping timeout: 260 seconds]
ebzzry___ has joined #lisp
ebzzry has quit [Ping timeout: 258 seconds]
ebzzry has joined #lisp
ebzzry_ has quit [Ping timeout: 260 seconds]
<beach>
zge: And to elaborate on phoe's elaboration, the metamodular website about the MOP is an HTML version of the chapters of the AMOP book declared to bee freely usable. There was such an HTML version in the past, but the authors copyrighted and put restrictions on the HTML version (which they have the right to do of course) contrary to the explicit wishes of the authors of the book.
<beach>
So I made a better version than the existing one, and put no restrictions on it.
ebzzry__ has quit [Ping timeout: 256 seconds]
ebzzry_ has joined #lisp
ebzzry___ has quit [Ping timeout: 256 seconds]
ebzzry__ has joined #lisp
<zge>
beach: phoe: I got that part (though I wasn't sure of closer-mop was considered "standard"), what I'm still struggeling to find out is how to create a method metaobject ^^
<zge>
as far as I see, I need that to call method-specializers, on which I can call eql-specializer-object, right?
<phoe>
zge: create? ummm
<phoe>
DEFMETHOD is the best way of doing that
ebzzry has quit [Ping timeout: 240 seconds]
<phoe>
then use generic-function-methods or find-method
shifty has quit [Ping timeout: 264 seconds]
shifty has joined #lisp
<zge>
oops, I have the methods, I want to get the metaobjects.
<zge>
generic-function-methods does the job, thanks!
ebzzry has joined #lisp
<zge>
(again)
technobean has joined #lisp
orivej has joined #lisp
<phoe>
what do you mean though, metaobjects
vaporatorius__ has quit [Quit: Leaving]
<phoe>
you mean specializers?
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
ebzzry_ has quit [Ping timeout: 256 seconds]
wsinatra has joined #lisp
orivej_ has quit [Read error: Connection reset by peer]
<beach>
zge: That just mean that the method *is* a kind of "metaobject".
<beach>
Not that it *has* one.
ebzzry has quit [Ping timeout: 256 seconds]
<beach>
If you look in the object graph on the metamodular page, you will see that METHOD is a subclass of METAOBJECT.
<beach>
zge: Also, I didn't write that paragraph just for you. I though it would be good for other #lisp participants to be reminded.
ebzzry has joined #lisp
ebzzry__ has joined #lisp
<zge>
beach: sorry, I just don't want people to waste too much time with my stupid problems :/
orivej_ has joined #lisp
ebzzry___ has joined #lisp
ebzzry_ has quit [Ping timeout: 258 seconds]
ebzzry_ has joined #lisp
ebzzry has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 246 seconds]
ebzzry__ has quit [Ping timeout: 240 seconds]
EvW1 has joined #lisp
ebzzry has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
ebzzry___ has quit [Ping timeout: 258 seconds]
bhartrihari has joined #lisp
ebzzry__ has joined #lisp
msk__ has quit [Ping timeout: 258 seconds]
ebzzry___ has joined #lisp
ebzzry_ has quit [Ping timeout: 265 seconds]
ebzzry has quit [Ping timeout: 256 seconds]
orivej_ has quit [Read error: Connection reset by peer]
orivej has joined #lisp
ebzzry__ has quit [Ping timeout: 265 seconds]
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` is now known as X-Scale
ebzzry has joined #lisp
ebzzry_ has joined #lisp
ebzzry___ has quit [Ping timeout: 240 seconds]
ebzzry__ has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
<Harag>
beach: thank you very much, much appreciated will go through it
ebzzry___ has joined #lisp
ebzzry has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
<beach>
Pleasure.
ebzzry_ has quit [Ping timeout: 240 seconds]
ebzzry__ has quit [Ping timeout: 265 seconds]
<phoe>
zge: that ain't a stupid problem
jonatack has joined #lisp
ebzzry has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
ebzzry_ has joined #lisp
ebzzry___ has quit [Ping timeout: 246 seconds]
ebzzry__ has joined #lisp
ebzzry has quit [Ping timeout: 240 seconds]
ebzzry___ has joined #lisp
ebzzry has joined #lisp
shifty has quit [Ping timeout: 256 seconds]
ebzzry_ has quit [Ping timeout: 265 seconds]
ebzzry__ has quit [Ping timeout: 240 seconds]
ebzzry___ has quit [Ping timeout: 260 seconds]
jw4 has quit [Read error: Connection reset by peer]
elosant has quit [Quit: WeeChat 2.8]
ebzzry_ has joined #lisp
jw4 has joined #lisp
seok has quit [Remote host closed the connection]
ebzzry__ has joined #lisp
EvW1 has quit [Ping timeout: 244 seconds]
ebzzry has quit [Ping timeout: 256 seconds]
ebzzry has joined #lisp
ebzzry___ has joined #lisp
ebzzry_ has quit [Ping timeout: 264 seconds]
ebzzry__ has quit [Ping timeout: 264 seconds]
ebzzry_ has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
ebzzry__ has joined #lisp
ebzzry has quit [Ping timeout: 264 seconds]
ebzzry has joined #lisp
ebzzry___ has quit [Ping timeout: 240 seconds]
ebzzry___ has joined #lisp
ebzzry_ has quit [Ping timeout: 246 seconds]
Inline has joined #lisp
diamondbond has joined #lisp
ebzzry__ has quit [Ping timeout: 240 seconds]
ahungry has joined #lisp
ebzzry_ has joined #lisp
ebzzry has quit [Ping timeout: 256 seconds]
technobean has quit [Quit: ERC (IRC client for Emacs 26.2)]
ebzzry has joined #lisp
technobean has joined #lisp
ebzzry__ has joined #lisp
ebzzry___ has quit [Ping timeout: 258 seconds]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
ebzzry_ has quit [Ping timeout: 240 seconds]
sjl_ has joined #lisp
ebzzry has quit [Ping timeout: 258 seconds]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
ebzzry has joined #lisp
mankaev has quit [Ping timeout: 272 seconds]
ebzzry_ has joined #lisp
ebzzry__ has quit [Ping timeout: 240 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
ebzzry has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 258 seconds]
diamondbond has quit [Quit: Leaving]
orivej has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
ebzzry_ has quit [Ping timeout: 240 seconds]
<lonjil>
beach: that's a neat idea, the graph-based lecture series.
<lonjil>
phoe and I had a discussion last week where we wrote a short list of things that would be good for the CL ecosystem and community. Better teaching material is one. So if the idea goes somewhere I would like to help.
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
Necktwi has quit [Read error: Connection reset by peer]
markong has quit [Ping timeout: 240 seconds]
CrazyEddy has quit [Remote host closed the connection]
<eta>
have had to write a lot of manual nix expressions though
rogersm has quit [Client Quit]
cosimone has quit [Remote host closed the connection]
<beach>
lonjil: Is that a discussion I totally missed, or did it take place elsewhere?
<lonjil>
beach: elsewhere
<beach>
Whew! :)
dominic34 has joined #lisp
<lonjil>
beach: we had been talking a little all over the place for ages, but the discussion that resulted in that list was a video call.
<beach>
A prerequisite for WSCL is to turn the dpANS into a single LaTeX document, with multiple files of course, so that it can be indexed, cross referenced, etc.
<beach>
lonjil: Great!
<phoe>
beach: that's also a prerequisite for UltraSpec, in a way
<beach>
True.
<beach>
So maybe make that an explicit point.
<lukego>
eta: very interesting, buildlisp in nix! I'm using ql2nix with reasonable success but I'll check it out
<lonjil>
beach: phoe told me about a TeX parser that could be adapted to parse dpANS, which could then be translated into any format.
<eta>
lukego, handy, I hadn't heard of ql2nix! buildLisp.nix completely replaces ASDF, fwiw, so you need to write your own nix expressions for like every package
<lonjil>
Perhaps the WSCL could be some kind of overlay for that, which can then also be translated into any format.
<lukego>
ql2nix is pretty neat but a bit elaborate. it downloads all your dependencies from quicklisp, recursively, and snapshots them with nix expressions.
<beach>
lonjil: "overlay"?
<lukego>
eta: do you need to write those depot declarations manually? that's the bit that ql2nix automates via quicklisp
<beach>
lonjil: Oh, I think I see what you mean.
<lonjil>
beach: Ah, as in a diff or some other construct allowing you to add to or modify something.
<beach>
Yeah, sure.
<eta>
lukego, yeah, you do
<eta>
so ql2nix actually seems pretty interesting from the point of view of having to avoid that
<eta>
lukego, I think the buildLisp.nix dev is planning on implementing a similar thing though
<lukego>
I can recommend it. haven't pushed my derivations anywhere yet but I can quickly gist my main scripts as a peek
<lukego>
here're my bits of nix code for creating "batteries included" distros of sbcl and emacs: https://gist.github.com/
bsd4me has joined #lisp
terpri has quit [Remote host closed the connection]
<phoe>
then you modify one of the places inside that array to instead hold a (list 0 0 0)
<phoe>
then you can modify the nth element of that list by using SETF NTH on it
orivej has quit [Ping timeout: 256 seconds]
orivej_ has joined #lisp
<paule32>
why is qoute unsafe as list ?
<paule32>
in some documentations, they equal
<phoe>
modifying literal data === undefined behavior
<phoe>
and '(0 0 0) is literal data
<paule32>
ah ok
<phoe>
(list 0 0 0) creates a fresh list that is safe to modify, but '(0 0 0) might be shared with some other data structures in the Lisp image
<phoe>
so modifying it might also modify other things.
<paule32>
hmm
v88m has quit [Ping timeout: 246 seconds]
<paule32>
thank you
Lycurgus has joined #lisp
karlosz has joined #lisp
Lycurgus has quit [Remote host closed the connection]
orivej has joined #lisp
Necktwi has joined #lisp
orivej_ has quit [Ping timeout: 256 seconds]
technobean has quit [Ping timeout: 240 seconds]
v88m has joined #lisp
rpg has joined #lisp
<rpg>
Am I right in thinking that the CL IDE world is pretty much still Emacs, CCL, or commercial? No one's managed to get the Eclipse thing to work right? Trying to figure out what to recommend to an intern working with me. Is there a good "getting started with Emacs and CL for the non-emacs user" resource anywhere?
gaqwas has joined #lisp
<dlowe>
emacs is perfectly useable as a normalish text editor as long as you use the menubar first for everything and turn on transient-mark-mode
<dlowe>
which is slow, granted
<dlowe>
(using the menubar for everything)
<dlowe>
it's a much gentler on-ramp for CL newbies than tutorials
<rpg>
dlowe: Yeah, but then on top of that there's spinning up to use SLIME or SLY, which is an additional pull. Is there a "how to get started" resource for them? There were videos, but I fear they may be badly bitrotted.
<rpg>
Wondering if the CCL IDE might be a gentler introduction. The SLIME menubar, IMO, is under-populated, and could be very cryptic for a novice.
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
<dlowe>
LispWorks personal edition might be a good start too
<dlowe>
The slime menubar being underpopulated should be addressed, though
<rpg>
Can't do that, unfortunately, my project blows past the personal edition resource lmits.
<rpg>
... and we don't use LW generally, so I can't justify buying a copy.
<rpg>
Would be great to have a "Help! I want to use Common Lisp, but I don't know Emacs!" web page somewhere. But since i"ve used Emacs for something like three decades now, I'm hardly the person to write it!
<dlowe>
I thought I saw something like that, but it was a while ago
<grewal>
atom has slima, which might be sufficient
ilshad has joined #lisp
<paule32>
what is CCL IDE ?
<phoe>
AFAIK it's a modified Hemlock that has been changed to use the macOS Cocoa user interface library
<luis>
Is there a recommended way to customize the compile-file/load output using ASDF? I want to instrument it with things like *compile-verbose* and print a summary of warnings per file compiled/loaded for instance.
<paule32>
IDE for CL/SBCL in work?
<rpg>
luis: I think there's a way to hook around compile file....
<luis>
rpg: tell me more! (and what about LOAD?)
<paule32>
is ASDF not absolute ?
<luis>
paule32: what does "absolute" mean?
<luis>
universal?
<paule32>
luis: i mean deprecated
<rpg>
luis: look for `:around-compile` in the manual.
<luis>
rpg: thanks.
<luis>
paule32: deprecated? in favor of what?
<rpg>
see 11.1, "Controlling file compilation". I'm finding it a little difficult to read, so feel free to discuss with me and we can try to get the docs tweaked to be more informative.
<paule32>
luis: i can smesh remember that somewhere stand, ASDF is old
<luis>
paule32: Common Lisp is old, we like old things around here ;-) And I don't understand half the words you write, maybe I'm old too.
<rpg>
smesh?
<paule32>
luis: haha, yes, sorry for my slengsh, smesh in manner of "can be - can not be", i love old suff, too
<paule32>
smesh = cooled mixed watter ice
<luis>
rpg: I'd like to control this at load-system time. I don't want to change any system.
<rpg>
luis: `:around` method on `asdf:perform`?
<paule32>
luis: have you quicklisp?
<luis>
rpg: can you recommend a good specialisation for that around?
<rpg>
luis: Going to be nasty, though, because you don't have an easy way to identify how to specialize.
<luis>
paule32: yes, I'm not /that/ old!
<rpg>
luis: haha
<luis>
rpg: the :around on operation + component is taken :)
<rpg>
luis: Probably not without knowing what specifically you want to do this to. Everything you load? Or only some specific files/
<rpg>
Files in a system?
<luis>
rpg: everything. maybe an :around on load-op + component? that seems to be free.
<rpg>
luis: That probably would be good. You might want `load-op` and `cl-source-file`.
orivej has quit [Ping timeout: 256 seconds]
orivej_ has joined #lisp
<rpg>
And of course, then you only get the load info, nothing about compilation.
<rpg>
`component` will get you the `system` ops, etc.
<luis>
rpg: should I add something to compile-op too? I thought load-op implied compile-op?
<rpg>
luis: I think that compile file hook is probably there because of the around method being hijacked.
<rpg>
luis: if you load-op, then compile-op will be put in the plan, but compilation does not happen in the scope of loading. ASDF plans are flat, not hieararchical.
<rpg>
So also, loading files does NOT happen INSIDE loading a system.
<rpg>
This is one of the most counter-intuitive facts about ASDF
<luis>
rpg: I see, thanks. I might try to advise load/compile-file if SBCL/ACL let me.
<rpg>
ACL lets you, but they are pushing use of their FWRAP instead of DEFADVICE. I dunno about SBCL. It has wrappers, but I don't understand them at all well.
<rpg>
It would be just LOVELY to have a DEFADVICE portability layer library, but I don't think one exists (I'd be so happy to be wrong).
<luis>
rpg: yeah, that'd be nice. We have something internally for excl:fwrap and sb-int:encapsulate, should try to publish it, maybe.
joast has joined #lisp
Inline has quit [Ping timeout: 256 seconds]
<rpg>
luis: Yes, please!!!
<rpg>
I don't know if CCL has internals that would support that.
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
bocaneri has quit [Read error: Connection reset by peer]
dominic34 has joined #lisp
orivej_ has joined #lisp
paule32 has quit [Quit: Leaving]
orivej has quit [Ping timeout: 256 seconds]
cosimone has quit [Quit: Quit.]
orivej_ has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
technobean has quit [Quit: ERC (IRC client for Emacs 26.2)]
technobean has joined #lisp
ayuce has quit [Remote host closed the connection]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
v88m has quit [Ping timeout: 240 seconds]
even4void has joined #lisp
v88m has joined #lisp
wsinatra has quit [Ping timeout: 246 seconds]
wsinatra has joined #lisp
<markasoftware>
Can I not use a lambda for a `satisfies` type?
Codaraxis_ has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
<markasoftware>
ok, teh spec explicitly says I may not
orivej has joined #lisp
<jackdaniel>
- can I not use X? - even better, you can't use X! :)
Codaraxis__ has quit [Ping timeout: 256 seconds]
<markasoftware>
so (list-of 'some-type) is basically impossible to enforce without generating a `list-of-some-type-p` function during deftype expansion?
terpri has quit [Remote host closed the connection]
<jackdaniel>
if I understand your question correctly than yes
<jackdaniel>
I had a similar prolbem with a type (sequence type)
technobean has quit [Quit: ERC (IRC client for Emacs 26.2)]
<jackdaniel>
however, as someone noted the other day, cl implementation is free to reorder types in the AND specifier, so you should probably check whether it is a sequence directly in the lambda body
karlosz has quit [Remote host closed the connection]
<markasoftware>
it's too bad, i was reading an article where they used lambda for satisfies to implement list-of, but it was emacs lisp
<markasoftware>
just this one time, emacs lisp, you have won
<markasoftware>
Thanks for the link, time to gensym
* jackdaniel
also mentions, that in CLIM you may parametrize even built-in types
orivej has quit [Ping timeout: 256 seconds]
orivej_ has joined #lisp
Codaraxis__ has joined #lisp
<jackdaniel>
so i.e there is a presentation type (sequence type)
zigpaw has quit [Ping timeout: 240 seconds]
Codaraxis_ has quit [Ping timeout: 256 seconds]
karlosz has joined #lisp
himmAllRight17 has quit [Ping timeout: 264 seconds]
himmAllRight has joined #lisp
zigpaw has joined #lisp
narimiran has quit [Quit: leaving]
ilshad has quit [Remote host closed the connection]
<jmercouris>
beach: is the whole point of eclector that it is implemented in Lisp?
orivej_ has quit [Ping timeout: 256 seconds]
ToeTag has joined #lisp
orivej has joined #lisp
ToeTag has left #lisp [#lisp]
markong has joined #lisp
orivej has quit [Ping timeout: 258 seconds]
orivej has joined #lisp
even4void has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
johnjay has quit [Ping timeout: 260 seconds]
<jmercouris>
?
<jmercouris>
sorry, typo
johnjay has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
wsinatra_ has joined #lisp
wsinatra has quit [Quit: WeeChat 2.9]
ft has quit [Ping timeout: 256 seconds]
<jackdaniel>
various benefits come from the fact, that it is implemented in lisp. i.e you may easily integrate it in cl applications which analyze common lisp code
<jackdaniel>
(and of course, you may extend it)
<jackdaniel>
not to mention that code written in cl is usually more concise, so it is easier to look over it when debugging
orivej has quit [Read error: Connection reset by peer]
orivej_ has joined #lisp
<jmercouris>
that's true
stylewarning has quit [Excess Flood]
stylewarning has joined #lisp
q3d has joined #lisp
<jmercouris>
I'm using cl-css and I can't figure out for the life of me how to produce this simple css
<jmercouris>
sorry for the double paste, only the second one is fine
orivej has joined #lisp
orivej_ has quit [Read error: Connection reset by peer]
orivej has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
nullheroes has quit [Quit: WeeChat 2.8]
ghard has quit [Ping timeout: 244 seconds]
Alfr__ has quit [Ping timeout: 260 seconds]
ghard has joined #lisp
Inline has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
<phoe>
markasoftware: I solved this issue some time ago
<phoe>
...and jackdaniel already posted a solution equivalent to mine :D
red-dot has joined #lisp
q3d has quit [Ping timeout: 245 seconds]
Alfr has joined #lisp
Inline has quit [Remote host closed the connection]
<phoe>
jackdaniel: what's the question about conformance that you have on L3 of that file? I think it conforms as long as you make an additional check if SEQ is of type SEQUENCE inside the lambda, since the implementation is allowed to reorder the contents of the AND type specifier
shifty has quit [Ping timeout: 260 seconds]
Inline has joined #lisp
shifty has joined #lisp
<jackdaniel>
phoe: had you read carefully what I've said above you'd knew that I've said exactly that
dominic35 has joined #lisp
<jackdaniel>
(that is, that and may be reordered)
ayuce has joined #lisp
dominic34 has quit [Ping timeout: 256 seconds]
dominic35 is now known as dominic34
<phoe>
geez
* phoe
goes to sleep in shame
<phoe>
you are right
<jackdaniel>
another question is whether putting result of compile in deftype is conforming
<jackdaniel>
because eval-when block is not a top-level form
<jackdaniel>
and I didn't bother to investigate answer to that question
<phoe>
my understanding is that COMPILE with a non-NIL name performs the equivalent of SETF FDEFINITION, so the function with the provided name is ensured to exist before the actual type expansion is returned
<jackdaniel>
it certainly /works/ under implementations I've checked; but that was not important enough for me to validate code conformance
<phoe>
so by the time the type expansion that includes (SATISFIES FOO-SEQ-P) is returned, #'FOO-SEQ-P always exists
<phoe>
that's my understanding
<jackdaniel>
as noted in the comment, it is merely for the convenience of the code reader
* phoe
actually runs off to sleep now
<jackdaniel>
I don't contest nor agree with your understanding
<jackdaniel>
good night
karlosz_ has joined #lisp
karlosz has quit [Ping timeout: 240 seconds]
karlosz_ is now known as karlosz
renzhi has quit [Ping timeout: 256 seconds]
dominic34 has quit [Ping timeout: 246 seconds]
dominic34 has joined #lisp
ahungry has quit [Remote host closed the connection]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
gravicappa has quit [Ping timeout: 256 seconds]
diamondbond has joined #lisp
akoana has left #lisp ["Leaving"]
Codaraxis__ has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 258 seconds]
Frobozz_ is now known as Frobozz
orivej has joined #lisp
shifty has quit [Ping timeout: 256 seconds]
shifty has joined #lisp
sjl_ has quit [Ping timeout: 240 seconds]
diamondbond has quit [Quit: Leaving]
markoong has joined #lisp
orivej_ has joined #lisp
markong has quit [Ping timeout: 258 seconds]
orivej has quit [Ping timeout: 246 seconds]
mrcom has quit [Read error: Connection reset by peer]
orivej_ has quit [Read error: Connection reset by peer]
orivej has joined #lisp
diamondbond has joined #lisp
adyatlov has joined #lisp
dominic34 has quit [Quit: dominic34]
shifty has quit [Ping timeout: 246 seconds]
<adyatlov>
Has anyone ever heard of a virtual machine implemented in Common Lisp? Say, blocks of opcodes being translated to (defun (...) ...) forms and passed to eval?
<Xach>
adyatlov: does the java virtual machine count?