IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
IPmonger has joined #lisp
jonatack has quit [Ping timeout: 265 seconds]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
karlosz has quit [Quit: karlosz]
IPmonger has joined #lisp
karlosz has joined #lisp
jonatack has joined #lisp
jedii has quit [Ping timeout: 260 seconds]
jedii has joined #lisp
sts-q has quit [Ping timeout: 260 seconds]
dbotton has quit [Quit: -a- Connection Timed Out]
orivej has joined #lisp
dbotton has joined #lisp
theBlackDragon has quit [Ping timeout: 256 seconds]
rogersm has joined #lisp
theBlackDragon has joined #lisp
dbotton_ has joined #lisp
torbo has quit [Remote host closed the connection]
rogersm has quit [Ping timeout: 240 seconds]
dbotton has quit [Ping timeout: 260 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
clintm has joined #lisp
CrazyEddy has joined #lisp
wxie has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
rogersm has joined #lisp
galex-713 has quit [Ping timeout: 246 seconds]
rogersm has quit [Ping timeout: 256 seconds]
shifty has quit [Ping timeout: 260 seconds]
Alloc has quit [Ping timeout: 265 seconds]
kiroul has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
Alloc has joined #lisp
shka_ has joined #lisp
gravicappa has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
sts-q has joined #lisp
narimiran has joined #lisp
jedii has quit [Remote host closed the connection]
wxie has joined #lisp
bilegeek has quit [Quit: Leaving]
space_otter has quit [Remote host closed the connection]
Alloc has quit [Ping timeout: 272 seconds]
bocaneri has joined #lisp
ggole has joined #lisp
rogersm_ has joined #lisp
bocaneri has quit [Max SendQ exceeded]
bocaneri has joined #lisp
bocaneri has quit [Max SendQ exceeded]
bocaneri has joined #lisp
rogersm_ has quit [Ping timeout: 240 seconds]
bocaneri has quit [Max SendQ exceeded]
bocaneri has joined #lisp
bocaneri has quit [Max SendQ exceeded]
bocaneri has joined #lisp
IPmonger has quit [Ping timeout: 272 seconds]
IPmonger has joined #lisp
Alloc has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
jgodbout has quit [Quit: Ping timeout (120 seconds)]
pankajsg has joined #lisp
ivansviatenko has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
rwcom60 has joined #lisp
rwcom6 has quit [Ping timeout: 260 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
gaqwas has joined #lisp
jonatack has quit [Ping timeout: 260 seconds]
rogersm_ has joined #lisp
ljavorsk has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
rogersm_ has quit [Ping timeout: 272 seconds]
amb007 has joined #lisp
antaoiseach has joined #lisp
test1600 has joined #lisp
antaoiseach has left #lisp [#lisp]
liberliver has joined #lisp
Oddity_ has joined #lisp
shifty has joined #lisp
Oddity has quit [Ping timeout: 260 seconds]
srhm has joined #lisp
jonatack has joined #lisp
ljavorsk has quit [Quit: I'm out, bye]
ljavorsk has joined #lisp
arpunk has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
phantomics has quit [Quit: Ex-Chat]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
ChoHag has quit [Ping timeout: 256 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Blukunfando has joined #lisp
contrapunctus has joined #lisp
pve has joined #lisp
<easye>
Mornin' Just to confirm an obscure part of our favorite CONS: the only standard way to associate documentation with the MAKE-* constructor created by DEFSTRUCT is to use the DOCUMENTATION SETF expander?
<phoe>
easye: yes, it seeems that (setf (documentation 'make-foo 'function) "...") is the way to go
<phoe>
after (defstruct (foo ...) ...)
<easye>
phoe: thanks for the confirmation.
<beach>
easye: It's the way I recommend in other cases as well, since I don't think documentation belongs in the source code.
<easye>
That's a strong philosophical position.
<beach>
Documentation is for the user, whereas the person reading the code presumably knows how to use it already, so documentation is noise for the maintainer.
<beach>
The practice of putting documentation in the source code seems to encourage too brief documentation strings.
<easye>
Writing as an implementation maintainer, I don't find documentation to be noise at all. I often forget things about something I wrote some time ago.
<no-defun-allowed>
Does bordeaux-threads define if a thread can release a lock that a different thread acquired? Or, to cut out the middleman, is there an easy to access implementation of a readers-writer lock?
<beach>
Like SBCL (documentation 'car 'function) => "Return the 1st object in a list." which is incomplete.
<phoe>
no-defun-allowed: AFAIK that's undefined by BT, but let me check
<beach>
easye: I didn't recommend eliminating the documentation. Just putting it in a different place from that of the source code.
<easye>
But regardless of whether source code should contain documentation, I would argue that ANSI CL could use some way of documenting the constructor that DEFSTRUCT makes in the same form, otherwise such additions tend to get "lost" when moving code around.
<easye>
Sometimes what you call "documentation", I might soften as "annotation" to indicate that something is better than nothing.
<beach>
Oh, but comments exist for the maintainer. I have nothing against those.
<easye>
Anyways, beach, it is an interesting, strong position to advocate. It does require some level of tooling to keep the source and the docs in sync as well as docstrings.
<beach>
I mean, I have nothing against comments next to the source code.
<phoe>
"It is an error to call this unless the lock has previously been acquired (and not released) by the same thread."
rogersm_ has joined #lisp
<phoe>
so, the acquiring thread must also release it
<beach>
easye: Yes, and unfortunately we seem to lack good support for my position, at least at the moment.
<easye>
A lot of interesting stuff is happening with org-mode.
<easye>
But the presupposes "everyone" uses Emacs which is probably untennable.
<easye>
s/untennable/untenable/
<beach>
Especially since Emacs is not that great for editing Common Lisp code.
<beach>
It's the best we have, but it's not great.
rogersm_ has quit [Ping timeout: 256 seconds]
madage has quit [Remote host closed the connection]
<TMA>
beach: It sounds like a sound position to me. Multiline docstrings are bothersome in the code. Single-line ones are not informative enough.
dbotton_ has quit [Ping timeout: 246 seconds]
<cl-arthur>
beach: what improvements/differences do you have in mind? (Or maybe there's some good discussion of emacs' deficiencies somewhere you can link me?)
<beach>
TMA: Definitely. I sometimes use #.(format nil "..."). That way, I can at least indent the lines correctly, using ~@ to end the preceding ones.
<beach>
cl-arthur: Here is fine.
<beach>
Emacs doesn't really analyze the code very well, so it often can't distinguish between different roles of a symbol.
<beach>
Plus, indentation is based on regular expressions, which is often wrong.
<beach>
To get a better analysis, you can invoke the compiler, but then you have to it some key sequence, like C-c C-c. It would be preferable to get feedback sooner, like for each keystroke.
<phoe>
the recent Online Lisp Meetings talk on Eclector already shows a bit of work that has been done towards that on the reader level, so before the code is read and passed to the compiler
<beach>
Emacs/SLIME can often indent code sort of OK-ish, but there is no feedback when indentation is bad. Such feedback would catch mistakes like missing parentheses or too many closing parentheses much earlier.
madage has joined #lisp
madage has quit [Remote host closed the connection]
jonatack has quit [Read error: Connection reset by peer]
<beach>
phoe: Sort of. But scymtym also included sneak previews of the next level of processing.
<phoe>
oh!
<phoe>
I see
<beach>
Unfortunately, he sometimes forgot to clearly distinguish between the different levels.
<beach>
Like Eclector can't tell that a number is an illegal function name.
davepdotorg has joined #lisp
<phoe>
yes, that is what I was thinking
<beach>
That kind of real-time analysis is highly desirable, and Emacs is totally incapable of doing it.
<beach>
In my opinion, we still haven't figured out how to give feedback to the user, in a way that it is immediately obvious, yet still discreet.
<cl-arthur>
yeah, that sounds like it'd be really nifty
<beach>
Good! :)
<beach>
I think I know how to do it, but I am too busy with SICL at the moment.
<easye>
I thought there are facilities in contemporary Emacs that allows one to provide asynchronous messages, like flyspell does?
<beach>
You may be right, but how would you go about analyzing the contents at typing speed?
<phoe>
that'd likely require sending messages to swank and receiving them back for every keystroke
<beach>
Probably providing the entire buffer contents each time.
<beach>
Since our Common Lisp compilers can't really work incrementally.
<phoe>
probably doable but with either lots of overhead or lots of state synchronization
<easye>
I would have separate common lisp process running its analysis pass. When it has something intelligent to report, it could message Emacs. I would also rate-limit such messages to a reasonable time window.
<phoe>
(or both)
madage has joined #lisp
<beach>
easye: I am thinking of essentially the very opposite structure.
hendursa1 has joined #lisp
dilated_dinosaur has joined #lisp
<phoe>
I imagine that you don't need to message the Common Lisp implementation if the editor is inside the Common Lisp implementation
<beach>
Exactly.
<phoe>
that would be a point for climacs or whatever other lisp-based editor
<easye>
My strategy would require that the process external to Emacs somehow be able to peek at the contents of a buffer without it being flushed to disk.
<phoe>
easye: and I don't know if that is doable easily
<phoe>
the best I can think of is RPC + sockets
<beach>
easye: Still, you can't run the compiler incrementally, so you would have to feed the entire buffer contents to it for every keystroke.
<easye>
Certainly, having the editor in CL would be the win.
<OlCe>
beach: Hi. Maybe should you have a look at Flycheck/Flymake if you have not already.
<OlCe>
beach: They are doing exactly that AFAIK.
<beach>
OlCe: Why is that?
<easye>
Yes, and "feeding the buffer" would probably slow down Emacs, so one would need an non-intrusive observer of some kind.
<beach>
OlCe: Analyzing Common Lisp code in real time?
<OlCe>
beach: Yes, sending the code to a separate process.
<OlCe>
beach: But, to be honest, this does not work that well.
<beach>
OlCe: I am saying that doing that won't work in this situation.
hendursaga has quit [Ping timeout: 240 seconds]
dbotton_ has joined #lisp
<OlCe>
beach: Why is that? This is generally fast enough, even without incremental compilation.
<beach>
OlCe: Because you would still have to run the compiler for each keystroke, and you would have to send the entire buffer contents for each keystroke.
jello_pudding has quit [Quit: WeeChat 2.3]
<OlCe>
beach: Yes. FC mitigates that with options to send only X seconds after a keystroke with no other keystroke in the interval.
<beach>
You may even have to start a fresh Common Lisp image for each keystroke, since some compile-time side effect could influence the result.
<OlCe>
beach: For Emacs Lisp, I remember the Emacs process is forked. Don't remember what is done for CL.
jello_pudding has joined #lisp
<beach>
OlCe: What we do know is that there is a wire protocol between Emacs and a Common Lisp process.
<OlCe>
beach: Clearly, you want (in some scenarios at least) a single image running which provides context.
<beach>
I do, yes.
<OlCe>
beach: Precisely to avoid launching a new image each time, and loading all packages.
<beach>
Exactly.
<OlCe>
beach: I find Slime support great in the sense that everything that is typed is xrefed to the running image.
<OlCe>
beach: In FC (or similar), I would want exactly that.
<beach>
I don't think that's true.
<OlCe>
beach: Didn't use much FC with CL up to now.
<beach>
If I type (defun foo (x) x) in a buffer, it is not available in the image.
davepdotorg has quit [Remote host closed the connection]
<OlCe>
beach: Yes, and personnally I prefer that behavior. But for automatic buffer checking, obviously, I would want the definition to be installed.
Alfr_ has quit [Remote host closed the connection]
<beach>
There is another alternative though.
redeemed has joined #lisp
Alfr_ has joined #lisp
<beach>
Information about the function could be available in the compilation environment, but not in the startup environment, until the user wants to migrate it.
<OlCe>
beach: But then, we have to define the scope of these definitions. For example, up to which point do we reload files (such as the current ASDF system), because some other files may depend on function FOO, in the case you provide a new definition of FOO.
<beach>
So that if you type (defun foo (x) x) and then (defun bar (y) (foo y 234)) then you get a warning about the number of arguments to foo.
<beach>
The scope is that of the file compiler.
<OlCe>
beach: Yes, could be enough. And great on this example;
<OlCe>
beach: Yes, file scope is the obvious and first thing to do.
<OlCe>
beach: And then, this can be extended.
<beach>
You start with the startup environment, that you then don't change. Then you define an incremental evaluation environment and an incremental compilation environment for the buffer.
<beach>
That way, the buffer will be analyzed with respect to the startup environment and the preceding code in the buffer, but the startup environment will be modified only when the user wants it to be.
<OlCe>
beach: This sounds great, at least in theory. I do not know much about how far you can manipulate environments in the current compilers.
<beach>
You can't.
<beach>
That's why I invented first-class global environments.
davepdotorg has joined #lisp
cods has quit [Ping timeout: 240 seconds]
<OlCe>
beach: Invented? They are dating back to CLtL2 at least. Are you that old? ;-)
<beach>
CLtL2 has a section on lexical environment. Nothing on first-class global environments.
<OlCe>
beach: True. This is not the same thing. ;-)
<beach>
Not at all. But we also fixed the broken definition of lexical environments in CLtL2 by creating Trucler.
<beach>
first-class global environments are implemented in Clostrum.
<OlCe>
beach: The hyperspec defines the environments you are talking about, but no mechanism to interact with them explicitly.
<beach>
OlCe: Yes, it does, and it also says that the startup environment, the evaluation environment, and the compilation environment are allowed to be one and the same in a conforming implementation.
wxie has quit [Ping timeout: 260 seconds]
<OlCe>
beach: Exactly. I find it very unconvenient that they can be the same, truth said.
<beach>
OlCe: And since every existing Common Lisp implementation actually have only one environment, it is pretty useless for what I want to do.
<beach>
s/have/has/
<beach>
Thanks phoe.
<OlCe>
phoe: Thanks.
<OlCe>
Very interesting.
<beach>
OlCe: Then, all you need is a compiler that uses Clostrum and Trucler...
jonatack has joined #lisp
<beach>
minion: Please tell OlCe about Cleavir.
<minion>
OlCe: 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
<OlCe>
beach: Yeah, thanks, I knew about SICL. Discovered it a few months ago by chance.
<beach>
I see.
Lycurgus has joined #lisp
<OlCe>
beach: All these are works done at Strandh's lab, aren't they? Or are some "independent"?
<OlCe>
"are" -> "are there"
<beach>
Lucky for me, some other smart people are working on extracted parts.
<beach>
Bike and karlosz are working on Cleavir. jackdaniel is working on Clostrum. heisig wrote Trucler. scymtym wrote most of Eclector.
<beach>
froggey provided streams. lonjil is creating the printer.
<OlCe>
beach: So you're Robert Strandh, I presume? (Don't know if it's against IRC etiquette to ask for that.)
<OlCe>
Ok.
<beach>
The literal translation of "strand" is "beach", so yes.
<beach>
no-defun-allowed is creating the hash tables.
<beach>
I may have forgotten a few.
<OlCe>
beach: I'm very glad you are working on all this.
<beach>
OlCe: Many people here have met several times at the annual ELS, so we pretty much know who most people are.
<OlCe>
beach: Yeah. I guess I'll have to show up there some day.
<beach>
... if we can just get rid of this virus, yeah.
<OlCe>
In fact, I know a bunch of you, but only by name and code.
<OlCe>
Yes...
saganman has joined #lisp
saganman has joined #lisp
<OlCe>
beach: I even remember reading your rant about teaching computer science at universities.
<flip214>
beach: or in spite of it
<easye>
Unfortunately, it's looking like a couple years on COVID19. And hopefully we don't get the next pandemic that fast.
<OlCe>
beach: and why teachers should not compromise and teach Lisp to their students.
<beach>
OlCe: That rings a bell.
<no-defun-allowed>
I'm still hoping to attend next year, though hope doesn't arrange for intercontinental travel--oh dammit. Well, in a couple more years, I won't have to schedule university around ELS.
<OlCe>
easye: You're right.
* easye
wishes he wasn't. Sigh.
pankajsg has quit [Ping timeout: 256 seconds]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
<OlCe>
beach: I think garbage collection for example could benefit a lot from your approach of separating components.
<OlCe>
beach: This is a point I find weak in e.g., SBCL. But maybe there are ways to control it that I don't know.
<OlCe>
beach: More generally, I would like to have some Lisp with sections of code without garbage collection.
<OlCe>
beach: Built into the language. Because I can achieve some of that with alien functions.
<OlCe>
beach: Then, Lisp could go extremely low level, without external tools.
<OlCe>
beach: That's just a tiny example of what could be improved.
* OlCe
wish I had time for that
<White_Flame>
yeah, I'd like separate first class heaps/regions
<OlCe>
White_Flame: Would be great.
nicktick has quit [Ping timeout: 260 seconds]
<beach>
OlCe: The SICL specification contains a very long description of the design of the memory manager that I would like to use. But it has not been tested.
<beach>
Why would you want to have sections without garbage collection?
vutral has joined #lisp
<beach>
OlCe: And I am not sure what you mean by my "approach of separating components".
<OlCe>
beach: For several reasons. To avoid GC pauses for real-time stuff. To be able to reclaim memory right away in case I know it was used only for temporary manipulations (a problem I hit with SBCL, may be a GC bug though, SBCL doesn't notice that and refuses to free it). To be able to use Lisp embedded. To avoid (SBCL again) having to set beforehand a big memory-mapped region sized against max anticipated memory use, which still will be
<OlCe>
filled with temporary stuff, using up memory against the whole system.
<OlCe>
beach: I agree that all these could be circumvented in some way.
<OlCe>
beach: But that's impractical.
<OlCe>
beach: Building compiler parts that can be (re)used separately.
<beach>
OlCe: Oh, but those are problems with the particular technique used by SBCL. Not a general problem for garbage collectors. And malloc/free is often slower than a good GC. Plus the SICL GC is planned to be parallel and concurrent, running in multiple threads.
<OlCe>
beach: Yes. Good then! That's my primary reason to be excited about SICL.
<beach>
Excellent!
<OlCe>
beach: The only thing is that I'm not so keen on the GPL, but anyway... It's much much better than nothing.
<beach>
SICL is BSD
<White_Flame>
and the SICL GC will be implemented in Lisp?
<beach>
White_Flame: It already is, basically, except for the stack scanning part.
<White_Flame>
cool
<OlCe>
beach: Ah sorry, thought it was GPL. Perfect than!
<OlCe>
'than' -> 'then'
<beach>
I find it very sad that people avoid the GPL, but that's the way it is.
<beach>
... and that discussion is off topic anyway.
<OlCe>
beach: Yes, and no. People have to eat also. And the service model is great... for services, not so for developing long-term robust software.
<OlCe>
beach: Yes, off-topic, so I'm stopping here. ;-)
<cl-arthur>
"< OlCe> beach: I even remember reading your rant about teaching computer science at universities." - sounds like a fun rant, would be interested in knowing the main points. My experience of (recently) studying undergraduate compsci was largely disappointing. Lowest common denominator, very 'practical' orientation. Algorithms and some exposure to the CTMCP book were the highlights from the courses. I
<cl-arthur>
suppose it did create a background environment where Graham's essays advocating lisp were personally appealing through contrarianism, though.
frost-lab has quit [Quit: Connection closed]
test1600 has quit [Quit: Leaving]
<beach>
cl-arthur: I have produced several rants over the years. My current one is that teachers of undergraduate courses are often incompetent for the task. A typical teacher did the same undergraduate degree, then specialized for a master, and then even more for a PhD. So that teacher has written very little code, and has not studied the undergraduate topics beyond the course contents.
<beach>
My example of binary search is typical. Half the books, written by highly experienced academic people, get it wrong, in that their code takes twice the time it has to.
Lycurgus has quit [Quit: Exeunt]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
decentyousername has joined #lisp
contrapunctus has joined #lisp
<easye>
I think that separating "Computer Science" from "Software Engineering" would be a good step.
<beach>
Indeed.
ecraven has quit [K-Lined]
<decentyousername>
I've just joined. What's the difference? Software engineering seems to me like the art of controlling complexity.
ecraven has joined #lisp
nullman has quit [Ping timeout: 246 seconds]
<easye>
Computer Science would be more of a Venn intersection of Math and Physics; Software Engineering would be about programming computers.
<ck_>
decentyousername: the difference that one is more of a craft or trade, and computer science is more research oriented, in my opinion
<beach>
Furthermore, just to get back on topic, I used to be a bit apologetic about my preference for Common Lisp. But the more I learn about other languages, the more I think Common Lisp (or something similar) should be taught in every undergraduate program (CS and SE) in order to deserve the name.
<decentyousername>
that's what I thought as well
<White_Flame>
programming is to software engineering is as metalworking is to mechanical engineering
nullman has joined #lisp
<White_Flame>
so programming, software engineering, and computer science are 3 different levels of study/practice
<beach>
Actually, strike the "(or something similar)". I think we should insist on languages that have independent standards.
<decentyousername>
beach: I think the problem with teaching Common Lisp to the worker is that it takes more knowledge and maybe intelligence to rake in the benefits of Lisp.
<cl-arthur>
beach: "independent standards" -> do you mean like ANSI standards etc, as opposed to the 'guiding implementation' of some other languages?
<OlCe>
Funny that you have these viewpoints on separating these disciplines.
<beach>
cl-arthur: Yes, standards published by organizations who have no interest in the implementations of it.
<OlCe>
On the contrary, I think that those involved in one should absolutely practice the others,
<OlCe>
to the extent possible.
<easye>
In many ways, having languages without independent standards returns us to the world of the 1960s which each computer installation had its own languages, tools, and practices. We're just on a much bigger number of "computer installations"
<no-defun-allowed>
The DOM of that document appears to be broken; there are two </head>s instead of </title> </head> and Firefox puts everything in the title.
<OlCe>
no-defun-allowed: Yes, same here. Had to open the source.
<White_Flame>
OlCe: one can practice just one of the 3 without being very good at the others. But they are distinguished fields of study at least, with CS being the primary one represented in academia, to the lack of the other 2
<cl-arthur>
OlCe: thanks, I'll see how nice a job google translate does :D
<decentyousername>
xlinks doesn't even display the page
<p_l>
of the "guiding implementation" languages, only one I know can be considered to have succeeded beyond its original implementation
<p_l>
and it involved ISO
hendursa1 has quit [Ping timeout: 240 seconds]
elflng has quit [Remote host closed the connection]
<p_l>
(Ruby community put in a lot of effort to both make a formal independent standard and a way to continue it, which is why there are multiple compatible Ruby implementations and the compatibility is stable, unlike say Python)
<OlCe>
White_Flame: Sure. But is naming and separating these a good way to attract people to these? In the short-term yes, but longer term? And what is going to happen if one of these replaces CS as the primary one? We'll have reverse problems them.
hendursa1 has joined #lisp
<White_Flame>
OlCe: the primary point of distinguishing them is pointing out the lack of representation of some when there's an overfocus on others
<OlCe>
White_Flame: Really, I would prefer all of them to be under the same umbrella.
<White_Flame>
yep, it's all under "software development" imo
* p_l
would like to point out that "CS" isn't even the term used everywhere
<White_Flame>
yep, and it is of course a terrible name anyway
<White_Flame>
"computational calculus" or something might be more apt
<OlCe>
OlCe: Maybe "Computing Machinery" (could be a tribute to the ACM as well ;-)).
<OlCe>
OlCe: But I still prefer CS for the umbrella term.
<White_Flame>
I don't
<no-defun-allowed>
I feel like the ACM gets enough tributes with how it handles accessing papers.
<White_Flame>
doing "science" is not what progrmaming is about. it's a background enrichment study
<OlCe>
OlCe: It is a science, in all the broad meanings of the word.
<OlCe>
Oups.
<OlCe>
White_Flame: Science can also be a synonym for art (how improper it may sound to scientists).
<White_Flame>
which is why I put it into quotes. Doing the work/process of computer science has nothing to do with actually writing code
<OlCe>
White_Flame: And hacking is as much an art as (hard) science.
<cl-arthur>
seperating compsci as a discipline from general software development seems nice to me. creates better space and focus for theory etc. for those inclined/interested. Dijkstra's opinions on the topic of compsci vs. software engineering as expressed in e.g. EWD898 and EWD1036 are amusing, though.
<White_Flame>
just like doing material science has nothing to do with making widgets
<White_Flame>
and obviously, those just doing basic programming are not informed in nor practicing computer science
<White_Flame>
nor are they doing software engineering
<beach>
I consider something a "science" not as synonym for "good stuff", but for a discipline that uses the scientific method. Then, mathematics and computer science do not qualify.
<no-defun-allowed>
Also, I vote for calling it computer-related magic.
<White_Flame>
but, you can still create working, delivered code by doing programming wihtout CS or SE
<decentyousername>
I'm for computer-related magic
<beach>
White_Flame: Yes, but it is extremely rare. More common is that unqualified programmers create a total mess that is inefficient.
<White_Flame>
we conjure the spirits of the computer
<White_Flame>
beach: it's more applicable to very small scale
<decentyousername>
having the name of a computation gives you power over it.
<decentyousername>
magical
<White_Flame>
and stuff like hypercard
<beach>
White_Flame: What do you mean? I have seen industry code of considerable size that I would not want to maintain.
<White_Flame>
I'm not talking about industry code at all
<White_Flame>
and again, small scale
<White_Flame>
on the order of maybe less than 200 loc
<beach>
I see.
<beach>
Sure, then pretty much anybody (including medical doctors apparently) can produce working code.
jesse1010 has joined #lisp
<White_Flame>
and that is legitimately programming
<beach>
Fair enough.
<White_Flame>
but, SE and CS are enablers beyond that
<beach>
It seems we agree.
<White_Flame>
one of my biggest complaints is that university tracks tend not to teach programming
<White_Flame>
which is one of the 3 slices of the overall skillset of developing software
<beach>
Yes, but then, there are few universities with staff that is qualified to teach it.
<White_Flame>
and as mentioned above, it is very much related to craft
<beach>
Right. Which in turn is incompatible with the career of a typical university teacher.
<White_Flame>
where SE is more related to process & abstraction, and CS is related to making solid theory
<White_Flame>
(definitely not hard boundaries between any of them though)
test1600 has joined #lisp
<beach>
I am one of a tiny number of exceptions in that I worked in the software industry, and in that I acquire some experience by actually writing code and reading papers, watching talks, etc., about programming.
<White_Flame>
yeah, that's pretty rare. And the one prof I had that came from industry didn't know at all how to teach, with is the opposite problem
<beach>
Exactly. And there we have the essence of the problem.
<beach>
... plus, of course, people working in industry are not that good developers on the average either.
<White_Flame>
yep
<White_Flame>
bringing back on semi-topic, if CL was much more widely represented in industry, I doubt there would be an air of "CL makes you a better programmer because you abstract more" sort of claims, as all the below-mediocre developers would happen to be working in it as well
<beach>
Sounds right.
<cl-arthur>
I had a big surprise when I took over some code maintenance and found numbered fn versions. Aka (defun some-fn-1 ...) (defun some-fn-2 ...) and only the latter was used anywhere.
<White_Flame>
yep, a refactor without a hard committing to the new version
<beach>
White_Flame: It is a fluke that there is a correlation between Lisp and highly intelligent and highly knowledgeable people.
<White_Flame>
that eventually filtered out all the old usages
<White_Flame>
beach: those with a greater passion for programming will find themselves in some esoteric niches; the average programmers won't
<beach>
I tend to agree with your analysis.
<beach>
Never thought much about the reason myself.
<White_Flame>
and that distinguishes back with the "if CL were more widespread" scenario
<cl-arthur>
White_flame: just reduce the size of the industry at the same time to move the average quality higher :D
<White_Flame>
that isn't incorrect! :)
<beach>
I am in favor of that idea too.
<White_Flame>
just look back to the 80s and prior, it wasn't a common thing to get into
<White_Flame>
financial prospects blew up in the 90s, and the crowds arrived
ivansviatenko has quit [Read error: Connection reset by peer]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
zaquest has quit [Quit: Leaving]
zaquest has joined #lisp
notzmv has quit [Remote host closed the connection]
pankajsg has joined #lisp
notzmv has joined #lisp
rogersm has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
malm has quit [Quit: Bye bye]
malm has joined #lisp
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
Blukunfando has quit [Remote host closed the connection]
shka_ has quit [Remote host closed the connection]
iissaacc has quit [Remote host closed the connection]
cyberlard has quit [Ping timeout: 256 seconds]
Blukunfando has joined #lisp
cyberlard has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
beach has quit [Ping timeout: 272 seconds]
rogersm has quit []
shka_ has joined #lisp
<Xach>
if you are an amateur and something bothers you about common lisp. if you are paid only if you use common lisp, anything that bothers you will be a real source of pain.
<Xach>
sorry - if you are an amateur, you can just not use it any more.
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
Lord_of_Life has joined #lisp
Lord_of_Life has quit [Changing host]
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
<phoe>
:(
<phoe>
okay
<Xach>
i knew your love for cl was conditional
<phoe>
Xach: ouch2
<decentyousername>
That's not real love!
<flip214>
when SBCL tells me "Don't know how to REQUIRE sb-bsd-sockets." when trying via ASDF, but an interactive REQUIRE works fine, what's the problem?
<jackdaniel>
what were we discussing again?
<decentyousername>
jackdaniel: No idea.
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<flip214>
ain't amateur love the real love? professionals rather get paid for it?
contrapunctus has joined #lisp
<Xach>
flip214: i don't know in specific detail, but to me that usually signals some kind of incorrect/incomplete installation
sleepingisfun has quit [Quit: hewwo]
<Xach>
flip214: what were you trying via asdf? (asdf:load-system "sb-bsd-sockets")?
davepdotorg has quit [Ping timeout: 256 seconds]
<flip214>
Xach: thanks, solved. outdated FASL cache, as slime doesn't use the default location ~/.cache/common-lisp/
<flip214>
grrr no, still happens after cleaning up?!
<flip214>
Xach: the ASD file has a :DEPENDS-ON
<Xach>
flip214: is there anything different about the environment where REQUIRE and loading the system are different?
<Xach>
i mean, do you get the same thing if you start sbcl from the terminal and the only thing you do is require or asdf:load-system?
<jackdaniel>
flip214: what is a result of (asdf:locate-system 'sb-bsd-sockets)
<flip214>
that's what I'm trying to find out... interactive running works, but the image doesn't
<Xach>
image!
<Xach>
this is the first mention of an image
<flip214>
yeah, sorry... in my dev environment I also use an image with lots of things already loaded
<jackdaniel>
you might have dumped an image with asdf that has already cached location of asd files (and that location may be obsolete now)
<flip214>
but I don't understand why sb-bsd-sockets is REQUIREd at that time, it should be included in the image anyway
<jackdaniel>
asdf reloads the system if it changes. if the location of asd changed (or asd disappeared) it will try to reload it
<flip214>
ah, disappearing makes it reload? does that make sense? if it knows it's gone where would it reload from?
<jackdaniel>
since the definition is already registered in the system, asdf won't fall back to calling require (it does that by default when definition is not found)
<jackdaniel>
well, that's precisely the problem you have I think -- you should register the system either as preloaded, or eventually as immutable
<jackdaniel>
then asdf won't attempt doing so
<flip214>
jackdaniel: good idea, trying
vutral has quit [Quit: Connection closed for inactivity]
beach has joined #lisp
Necktwi has quit [Ping timeout: 256 seconds]
<flip214>
thanks, seems to help
<jackdaniel>
sure
davepdotorg has joined #lisp
jeosol has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
Bike has joined #lisp
contrapunctus has joined #lisp
davepdotorg has quit [Ping timeout: 264 seconds]
<flip214>
grr.... in production there's a symptom, locally I get it only if I don't use (load?) swank
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
EvW has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
jonatack has quit [Ping timeout: 260 seconds]
arpunk has joined #lisp
davepdotorg has joined #lisp
<Xach>
|3b|: where can i find 3b-glim/2d?
davepdot_ has joined #lisp
davepdotorg has quit [Ping timeout: 260 seconds]
Necktwi has joined #lisp
davepdot_ has quit [Ping timeout: 246 seconds]
ljavorsk has quit [Ping timeout: 246 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
Nilby has joined #lisp
srhm has quit [Read error: Connection reset by peer]
madage has quit [Ping timeout: 240 seconds]
davepdotorg has joined #lisp
madage has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
davepdotorg has quit [Ping timeout: 256 seconds]
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
Stanley00 has quit []
davepdotorg has joined #lisp
saganman has quit [Ping timeout: 258 seconds]
<decentyousername>
How would I list all intered symbols of a specified package?
<phoe>
(loop for symbol being the present-symbols of :alexandria collect symbol)
davepdotorg has quit [Ping timeout: 240 seconds]
<phoe>
present-symbols, or symbols, or external-symbols
<phoe>
you choose
<decentyousername>
thanks, I'll note that down
<Xach>
decentyousername: what prompts the question? what will you do with this ability?
<decentyousername>
Xach: I'm trying to understand a system someone wrote and I wanted to get an overview of all the symbols
<jackdaniel>
I've read "how do I list all internal symbols of a specified package" and it got me curious :)
<decentyousername>
jackdaniel: I guess it didn't help that I've spelled "interned" wrong.
<phoe>
decentyousername: that's not the best idea
<Xach>
decentyousername: ahh. i don't think all interned symbols will necessarily get you there - it might be more helpful to limit it to bound/fbound symbols.
<Xach>
or some other metric that measures meaning in a symbol
<phoe>
you'll get things like local variables and internal function/macro names and what else mixed in there
<phoe>
I'd start with the exports rather than present symbols
<decentyousername>
phoe: It's a little tool written by borodust to parse tiled maps. It only exports 'convert.
<phoe>
then it's a very good library
<phoe>
you don't need to choose where to start trying to understand it
<decentyousername>
I still need to know how to use the function, because there is no documentation.
<decentyousername>
The source code is the documentation.
<_death>
M-. is a programmer's best friend
<phoe>
ooh
<phoe>
well, that's a troublesome thing then
saganman has joined #lisp
cods has joined #lisp
cods has quit [Changing host]
cods has joined #lisp
<jackdaniel>
(do-symbols (var 'climi) (when (eq (nth-value 1 (find-symbol (symbol-name var) 'climi)) :internal) (print var))) ; is what I came up with, quite clumsy
<jackdaniel>
(re /internal/ symbols)
nicktick has joined #lisp
<_death>
(let ((package (find-package "FOO"))) (remove package (apropos-list "" package) :test-not #'eql :key #'symbol-package)) ;; may be of interest, on some implementations
<jackdaniel>
it does look for all not inherited symbols, doesn't it?
<decentyousername>
it does the same as the prior two examples
<decentyousername>
at least the output is the same
test1600 has quit [Ping timeout: 260 seconds]
<_death>
it gives all symbols that are at home with the package
pankajsg has quit [Ping timeout: 264 seconds]
davepdotorg has joined #lisp
srhm has joined #lisp
<Xach>
i sometimes use mpage -4 to print out source code and then just read it through that way, taking notes directly on paper.
<Xach>
not for everyone, and not something i do a ton lately, but it has helped in the past
<_death>
if you import symbols from another package, they may become internal symbols as well
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
<_death>
I often use the asdf system dependencies to read a library serially
test1600 has joined #lisp
<flip214>
Xach: around 1985 my neighbor printed his source code on continuous paper... about 15m (45 ft) or so, and marked the GOTO cross-references with colored pens ;)
<Xach>
flip214: i used to think paper was hopelessly old-fashioned until i tried it. i suppose it only works for projects of a certain size.
<borodust>
decentyousername: load the system, and go down the rabbit hole by going from convert to what it uses jumping around with M-.
<Xach>
15m seems like it may exceed that size...
<borodust>
decentyousername: one of those days i might make it into a useful library ;p
<borodust>
decentyousername: it was hacked during a jam, there was little time to do anything properly
<decentyousername>
I'm trying to figure out how to specify the files so it works.
davepdotorg has quit [Ping timeout: 246 seconds]
<decentyousername>
I've created new levels, and would like to test them out.
<decentyousername>
I've assumed it takes a .tmx and transforms it into an .sexp file.
<flip214>
Xach: well, you know, it seems that 40x25 character screens held too little of the sources for a good overview...
wsinatra has joined #lisp
davepdotorg has joined #lisp
ski has quit [Ping timeout: 260 seconds]
test1600 has quit [Quit: Leaving]
shifty has quit [Ping timeout: 272 seconds]
ski has joined #lisp
shifty has joined #lisp
orivej has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
loli has quit [Quit: WeeChat 2.9]
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
jprajzne has quit [Client Quit]
sr-hm has joined #lisp
jprajzne has joined #lisp
scymtym has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
srhm has quit [Ping timeout: 256 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
srhm has joined #lisp
contrapunctus has joined #lisp
loli has joined #lisp
sr-hm has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
<borodust>
decentyousername: i dont actually remember, ill have a look in the evening
<borodust>
decentyousername: you would also need a lib libtiled blob
<decentyousername>
that's what I was missing
jonatack has joined #lisp
<fe[nl]ix>
no-defun-allowed: I will be adding a RWlock to bordeaux-threads APIv2
<flip214>
fe[nl]ix: a fair one?
kiroul has joined #lisp
<|3b|>
Xach: 3b-glim/2d will probably eventually be in https://github.com/3b/3b-glim but i don't think it does anything yet. if you are trying to run graph-paper, i think you can just comment it out for now
orivej has quit [Ping timeout: 246 seconds]
Alloc has quit [Ping timeout: 246 seconds]
<fe[nl]ix>
flip214: maybe, I don't know if that's possible on top of the existent mutexes provided by implementations
Alloc has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
<fe[nl]ix>
I know but that's not very relevant because I can only use whatever the implementation exposes
jeosol has quit [Remote host closed the connection]
skapata has joined #lisp
kirtai has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
<kirtai>
hi
contrapunctus has joined #lisp
<phoe>
heyyy
<kirtai>
regarding the discussion earlier about editing, how do the Medley structure editors hold up?
<phoe>
hmm, that reminds me of this interlisp-as-free-software project
<kirtai>
yep, that's exactly what I'm referring to
elimik31 has joined #lisp
<kirtai>
it supports both interlisp and (very old) common lisp
Alloc has quit [Ping timeout: 260 seconds]
Alloc has joined #lisp
dbotton has joined #lisp
<beach>
I started writing a GUI structure editor in the past, but it quickly became quite messy. I had a quadratic correspondence between states (cursor positions) and commands.
<beach>
I am sure my initial idea was wrong, but I haven't investigated other possibilities.
dbotton_ has quit [Ping timeout: 260 seconds]
nymphet has joined #lisp
Mandus has quit [Ping timeout: 260 seconds]
Mandus has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
<kirtai>
I'm pretty sure the Medley release has the structure editors in it. I don't know which language they're in though, and unfortunately it still uses CLtL rather than ANSI CL
<kirtai>
might be worth a look sometime though, once the devs have sorted through what they have
<kirtai>
sedit and dedit iirc. I know the first is interlisp, it's the second I need to check
<Xach>
|3b|: thanks. when i try (display (make-instance 'graph-paper) t) i get an unhandled memory fault
random-nick has joined #lisp
sjl_ has joined #lisp
<kirtai>
sedit looks like a weird hybrid. CL with lots of calls to the interlisp package
smazga has joined #lisp
<kirtai>
check the sedit-* files under sources
<beach>
Structure editing is going to be tough for Common Lisp with the presence of user-defined reader macros.
elimik31 has quit [Remote host closed the connection]
elimik31 has joined #lisp
<phoe>
you'd need to instruct the editor how it should interpret a given macro
<phoe>
that's kinda doable, if somewhat annoying
<beach>
You then kind of need to write code for the macro twice. Once for the reader and then another time for the editor.
rgherdt has joined #lisp
<phoe>
yes
<beach>
And if you distribute the code, you need to ship it with the editor customization as well.
<phoe>
yes
<kirtai>
would medleys more image based orientation help? Since it's editing live code and not files directly
<beach>
kirtai: That's a big change in how people work.
<jackdaniel>
what is the "live code" textual representation? i.e the loaded file is (list #p"/foo/"), how do you see that in the editor after loading it?
<kirtai>
beach: true, but it's also core to how medley works
<kirtai>
jackdaniel: medley works more like a smalltalk system. Source is attached to the in memory code and is imported/exported to files
<beach>
kirtai: Yes, but how is the code presented when the programmer wants to edit it?
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
elimik31 has quit [Remote host closed the connection]
contrapunctus has joined #lisp
<kirtai>
if I understand you correctly, when you call up the code, the way it works is it shows you and lets you edit the in-memory version of the source.
elimik31 has joined #lisp
<beach>
OK, so let's take an example. Let's say a Common Lisp programmer writes a reader macro, say ι to mimic APL vectors.
<beach>
Normally, the programmer would write ι100 for a vector with number 0 to 99 in it.
<Nilby>
My opinion is structure editors should work on post-read objects. The trouble then is is the aesthetic art of indenting, and so also semantic parsing.
<beach>
Now, the in-core version is just a vector. Is that going to be presented to the user as a vector of 100 elements, and if so, how does the programmer change it so that it is now the result of (say) ι50 instead.
<beach>
?
<beach>
Nilby: Sure, but is that really convenient? Don't you have to stop using reader macros?
<kirtai>
I'm afraid I haven't got far enough into medley to answer that yet :(
<kirtai>
still studying it
<beach>
kirtai: That's fine. But you see why we are asking these questions, right?
<Nilby>
beach: Reader macros become keyboard input macros.
<Nilby>
beach: and display code
<beach>
Nilby: For input, yes, but what about edit?
<phoe>
I guess you could tag objects with their respective source forms
<beach>
How does the system "know" that this particular vector was the result of typing ι100?
resu has joined #lisp
<kirtai>
phoe: I think that's how it works
<beach>
So then the in-core structure is more than just the code?
<shka_>
i used this function before but somehow i forgot about it
<jackdaniel>
hm, using /me mandates s/myself/himself/
dbotton_ has joined #lisp
<shka_>
thanks for help!
<jackdaniel>
sure
Lord_Nightmare has joined #lisp
resu has quit [Ping timeout: 260 seconds]
dbotton has quit [Ping timeout: 246 seconds]
elimik31 has quit [Remote host closed the connection]
<kirtai>
I'm poking at medley to see what I can find re macros in code
<beach>
Macros are no problem. They are represented like everything else. The main issue is reader macros.
dbotton has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
l has joined #lisp
l is now known as Guest84358
dbotton_ has quit [Ping timeout: 265 seconds]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
<phoe>
the way I see it, ι100 is always supposed to evaluate to #(0 1 2 3 ... 99)
contrapunctus has joined #lisp
<phoe>
so if we have (defun foo () ι100) then I suppose that the ι100 macro could be handled without much trouble
<Nilby>
I'm sure its obvious, but for example the reader macro for " turns into a keyboard macro which says let the user type a string a push it at the point. The display method (display (obj string) ...) puts quotes around it.
dbotton_ has joined #lisp
<beach>
Nilby: Again, the problem is not input. The problem is output. How does the system display the code in a way that allows user to edit it in a way that it was originally typed in.
Guest84358 has quit [Client Quit]
<Nilby>
If you have a custom reader macro, you have to have custom display code, or you just get #(0 1 ..)
l_ has joined #lisp
Lycurgus has joined #lisp
<beach>
Nilby: Hence the "define the macro twice" conclusion above.
<phoe>
or we remember the whole form as a string and re-read it
dbotton has quit [Ping timeout: 256 seconds]
<jackdaniel>
my naive attempt at this would be preserving the textual representation and the underlying object (so reading it basically), when the programmer modifies the textual representation, then that part of the buffer should be re-read
l_ has quit [Client Quit]
<beach>
phoe: Yes, and I am now thinking whether that is really what is meant by "structure editing".
l_ has joined #lisp
<beach>
jackdaniel: That is *definitely* not structure editing. And you are describing exactly what I do for Second Climacs.
<jackdaniel>
OK
<Nilby>
beach: That doesn't seem like much of a problem to me, especially given that hopefully non-standard reader macro use infrequent and close to redefining the language, e.g. zeta-c.
<Nilby>
beach: One could have a define-editable-reader-macro
<beach>
Nilby: OK.
<phoe>
beach: I guess that you'd need to add a layer of indirection; if you have (defun foo () ι100) then you have a simple list structure under the hood, but you also could have a layer of indirection that points to that concrete list structure and also holds information about e.g. macro usage
<phoe>
so it can figure out that (make-array 100 :initial-contents '(0 1 2 ... 99)) was actually macroexpanded from ι100
<phoe>
then you'd need editable function objects to refer to this sorta-textual context information so it can be picked up by the structure editor
<beach>
phoe: Something like that would be needed, yes. Not sure about the implications of it.
<phoe>
I guess there would be none, other than for the fact that if such information is not provided then some reader macros may be expanded
elimik31 has joined #lisp
<beach>
I am kind of wondering now what the original advantages of structure editing were meant to be, and how they would be preserved in such a scenario.
l_ has quit [Quit: Leaving]
<phoe>
beach: please note that this is an edge case scenario
<phoe>
reader macros are not *that* common
l_ has joined #lisp
<beach>
User-defined ones certainly aren't.
elimik31 has quit [Remote host closed the connection]
Alloc has quit [Ping timeout: 272 seconds]
<Nilby>
I worked on a structre editor and my biggest problem was indendting and line filling, eg. when to + 2 3 vs. + next-line 2 next-line 3
<beach>
Nilby: Do you mean you created/maintained one, or just used it as an end user?
hnOsmium0001 has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
<Nilby>
My fingers typed it, but my brain as usual has little recollection of the event. It so far hasn't made it out of the laboratory.
drl has joined #lisp
elimik31 has joined #lisp
<beach>
Hmm. OK.
<Nilby>
It needs a lot of framework to be useful as I'm sure you can imagine.
<beach>
Sure.
<kirtai>
only thing I can find is that it does display 'foo for (quote foo)
orivej has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
<Nilby>
I think I used medley a little bit a long time ago on a TI lispm. it was cool but as an emacs user, the key bindings felt awkward and would take some getting used to, probably like paredit.
dbotton_ has quit [Read error: Connection reset by peer]
notzmv has joined #lisp
dsiypl4 has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
Steeve has joined #lisp
Noir has joined #lisp
gaqwas has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
Noir has quit [Quit: Leaving]
jonatack has quit [Quit: jonatack]
dsiypl4 has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
EvW has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
ggole has quit [Quit: Leaving]
Lycurgus has quit [Quit: Exeunt]
amb007 has quit [Ping timeout: 260 seconds]
contrapunctus has joined #lisp
karlosz has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
bitmapper has joined #lisp
amb007 has joined #lisp
jonatack has joined #lisp
kiroul has quit [Quit: Leaving]
kiroul has joined #lisp
<tfb>
SEdit was ... well, if you haven't used SEdit it's hard to describe what it was like, but it was astonishing, or at least I remember it being so.
dsiypl4 has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
redeemed has joined #lisp
devon has joined #lisp
clintm has quit [Remote host closed the connection]
dbotton has quit [Ping timeout: 260 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
earl-ducaine has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
dbotton has joined #lisp
ebrasca has joined #lisp
dbotton has quit [Ping timeout: 272 seconds]
uragagarin34 has joined #lisp
hiroaki has joined #lisp
<phoe>
Xach: regarding print-hash-table-readably, that's actually my code
<phoe>
so, if it's broken, I'll be happy to fix it
hjudt has quit [Ping timeout: 256 seconds]
hjudt has joined #lisp
kirtai has quit [Quit: Leaving]
liberliver has quit [Ping timeout: 256 seconds]
iskander- has joined #lisp
iskander has quit [Ping timeout: 260 seconds]
<Xach>
phoe: the unconditional symbol case is concerning
vutral has quit [Quit: Connection closed for inactivity]
Posterdati has quit [Read error: Connection reset by peer]
Posterdati has joined #lisp
sts-q has quit [Remote host closed the connection]
dbotton has joined #lisp
<Xach>
As I wrote, I'm happy to add anything and (perceived by me) quality is not a roadblock. But I do look at personal utility libraries a little harder than other stuff and would love to see if the authors are open to feedback and possible improvement.
<shka_>
*gulp*
bocaneri has quit [Remote host closed the connection]
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
galex-713 has joined #lisp
saganman has quit [Read error: Connection reset by peer]
nymphet is now known as loli
loli has left #lisp ["WeeChat 2.9"]
drl has quit [Ping timeout: 244 seconds]
l_ has quit [Ping timeout: 260 seconds]
Necktwi has quit [Ping timeout: 260 seconds]
Necktwi has joined #lisp
sm2n has quit [Read error: Connection reset by peer]
sm2n_ has joined #lisp
nicktick has quit [Ping timeout: 264 seconds]
nicktick has joined #lisp
EvW has quit [Ping timeout: 244 seconds]
aindilis has quit [Remote host closed the connection]
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
srhm has quit [Quit: srhm]
gravicappa has quit [Ping timeout: 264 seconds]
madage has quit [Remote host closed the connection]
gravicappa has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
madage has joined #lisp
EvW has joined #lisp
madage has quit [Ping timeout: 240 seconds]
Nilby has quit [Read error: Connection reset by peer]
uragagarin34 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
drl has joined #lisp
dbotton_ has joined #lisp
decentyousername has quit [Remote host closed the connection]
dbotton has quit [Ping timeout: 272 seconds]
shka_ has quit [Ping timeout: 256 seconds]
dbotton_ has quit [Ping timeout: 264 seconds]
madage has joined #lisp
ech has quit [Ping timeout: 240 seconds]
wsinatra has quit [Ping timeout: 260 seconds]
dbotton has joined #lisp
wsinatra has joined #lisp
supercoven_ has quit [Ping timeout: 240 seconds]
ech has joined #lisp
narimiran has quit [Ping timeout: 258 seconds]
dbotton_ has joined #lisp
Alloc has quit [Ping timeout: 260 seconds]
izh_ has joined #lisp
Alloc has joined #lisp
ebrasca has quit [Remote host closed the connection]
<dlowe>
is there a library or implementation feature that allows for asserting that only one reference is held to a particular object?
<Xach>
shka_: i would like to say but you are gone now!
<Bike>
dlowe: kind of hard to define, or to know that it's true given everything that happens under the hood
<Bike>
for example, if you write a defmethod, machinery is gonna keep the original arguments around for (call-next-method)
<dlowe>
Bike: correct!
<Bike>
c.f. the weird convoluted description of dynamic-extent in the CLHS
<dlowe>
all the more reason to have such a thing while tracking down memory leaks
<dlowe>
if it's hard for a function, it's even harder for the poor human trying to figure it out
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
<dlowe>
my other thought was a really-should-be-garbage mark that could be put on an object
<phoe>
dlowe: sb-ext:search-roots
<dlowe>
so a gc in its reaping or copying phase comes across something that really-should-be-garbage but isn't, it can signal an error or comething
<dlowe>
phoe: that works as long as I make a weak-pointer for it, I guess.
<phoe>
yes
<dlowe>
looks good for debugging, at least. Thanks!
<phoe>
I wonder if it can be used to find all references, or their count, though...
<dlowe>
both, looks like
<phoe>
I don't know if I can use this tool properly though and if it does what I think it does
dbotton_ has quit [Ping timeout: 258 seconds]
wsinatra has quit [Quit: WeeChat 2.9]
dbotton_ has joined #lisp
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
dbotton_ has quit [Quit: Leaving]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<mseddon>
dlowe, I appreciate your pain, and thanks for both your and phoe's insight into observing this
orivej has quit [Ping timeout: 240 seconds]
<dlowe>
I might see if I can hack a please-be-garbage flag into sbcl
<mseddon>
Please do report back how complete it's coverage is. It's at least conservatively great.
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
<_death>
dunno if it could signal, but maybe it could log to the gc logfile
<dlowe>
mseddon: I would have to manually add (garbagify <object>) calls everywhere to figure out coverage
<dlowe>
I'd prefer to have the option to do this just for large leaks
<phoe>
dlowe: this makes stuff memory-unsafe though
<dlowe>
no, because it doesn't free anything
<phoe>
oh, like that
<dlowe>
nothing will happen if you access please-be-garbage objects
<phoe>
but won't the GC be free to collect them if they are garbage?
<dlowe>
it's a flag that says to the gc that the object shouldn't have a mark
<dlowe>
that it *should* be garbage, and it's an error if it isn't
<phoe>
an error, what do you mean? that you want to signal an error if a given object is alive?
<dlowe>
the gc can then signal a continuable error
<phoe>
hm
<phoe>
a minor issue is that the SBCL GC runs in the C world, you'll need to jump back to Lisp... which will be troublesome because the world is stopped during GC
<phoe>
but I guess that's doable
<dlowe>
ugly if all the threads are paused though
<dlowe>
but this would be a debugging thing anyway
<phoe>
why does search-roots not work for your use case though?
<dlowe>
thinking about active and passive modes of debugging
<_death>
if it's just for debugging, you could simply map-allocated-objects and test for it
<dlowe>
utilizing the fact that gc is already searching roots
<_death>
or list-allocated-objects (which I recently found out about)
jprajzne has quit [Ping timeout: 240 seconds]
dbotton_ has joined #lisp
IPmonger has quit [Ping timeout: 244 seconds]
IPmonger has joined #lisp
dbotton has quit [Ping timeout: 258 seconds]
ildar1337 has joined #lisp
ildar1337 has quit [Client Quit]
dbotton has joined #lisp
ildar1337 has joined #lisp
dbotton_ has quit [Ping timeout: 264 seconds]
sjl_ has quit [Ping timeout: 260 seconds]
dra_ has joined #lisp
dra_ is now known as dra
dbotton has quit [Read error: Connection reset by peer]
dbotton has joined #lisp
random-nick has quit [Ping timeout: 264 seconds]
random-nick has joined #lisp
gravicappa has quit [Ping timeout: 256 seconds]
rwcom602 has joined #lisp
rwcom60 has quit [Ping timeout: 260 seconds]
izh_ has quit [Quit: Leaving]
aindilis has joined #lisp
aaaaaa has joined #lisp
random-nick has quit [Ping timeout: 265 seconds]
redeemed has quit [Ping timeout: 272 seconds]
akoana has joined #lisp
gaqwas has quit [Ping timeout: 260 seconds]
torbo has joined #lisp
pve has quit [Quit: leaving]
dbotton_ has joined #lisp
akoana has left #lisp ["Leaving"]
dbotton has quit [Ping timeout: 258 seconds]
Steeve has quit [Quit: end]
orivej has joined #lisp
dra has quit [Quit: Leaving]
dbotton has joined #lisp
ukari has quit [Remote host closed the connection]
dbotton_ has quit [Ping timeout: 258 seconds]
ukari has joined #lisp
ukari has quit [Remote host closed the connection]