warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
robotoad has quit [Quit: robotoad]
<stylewarning>
montxero: I actually don't add newlines to my docstrings at all unless im starting a new paragraph
<stylewarning>
much to the chagrin of the people that read my code
rpg has joined #lisp
rpg has quit [Client Quit]
rpg has joined #lisp
ealfonso has quit [Disconnected by services]
ealfonso has joined #lisp
<ealfonso>
does it make sense to import symbols outside of a defpackage form?
<ealfonso>
Oladon has joined #lisp
Jesin has quit [Quit: Leaving]
<emaczen>
ealfonso: It isn't something you would regularly do, but I'm sure there is an applicable scenario to do so
patrixl has joined #lisp
vxe has joined #lisp
K1rk has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<ealfonso>
I''ve seen the pattern of exporting within a file rather than centrally in a defpackage form
<rpg>
ealfonso, emaczen: I believe this to be explicitly deprecated by the ANSI spec.
warweasle has joined #lisp
ryan_vw has quit [Ping timeout: 268 seconds]
n3k0_t has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
ealfonso has quit [Ping timeout: 252 seconds]
<aeth>
Don't use something that's deprecated because a future version of the standard might remove it!
nowolfer has quit [Quit: leaving]
<Bike>
if it's deprecated, that doesn't seem to be mentioned in clhs import
<no-defun-allowed>
isn't remove-if-not also deprecated?
<Bike>
it is
<no-defun-allowed>
so to really be in good form, your code better not use remove-if-not or importing outside defpackages :P
<rpg>
Bike: I'm not finding this in CLHS, either. But I recall getting warnings about uses of `IMPORT` and `EXPORT` at top level
asarch has joined #lisp
cylb has quit [Ping timeout: 246 seconds]
<rpg>
There's some language in the DEFPACKAGE-ADDITION issue that explains why it's better to use DEFPACKAGE, but not to the extent of deprecating top level use of IMPORT and EXPORT.
* rpg
kind of wishes the committee hadn't made the default for package use be implementation-dependent...
<aeth>
no-defun-allowed: Well, that's controversial because all the foo-if-nots are deprecated, but the foo-if (complement #'bar) equivalent forms aren't optimized, which you'd expect if they were idiomatic. So they're deprecated functions where everyone ignores the deprecation and good luck actually removing them in the future.
<aeth>
So do you do (remove-if (complement #'evenp) #(1 2 3 4)) and future-proof your code against a removal that probably won't happen or do you do (remove-if-not #'evenp #(1 2 3 4)) and get a faster program?
arescorpio has joined #lisp
<aeth>
That's one of the lesser holy wars in CL!
<rpg>
aeth: number two. There will be no future standard.
<rpg>
aeth: That's like future-proofing against translating to Clojure! ;-)
<adlai>
but wat if golf
<aeth>
rpg: It's not up to you if there will be a future standard or not. It's up to the core developers of SBCL, CCL, etc. (Unless you are one, in which case it's fractionally up to you.)
<oni-on-ion>
whats the history on #() syntax convention
<aeth>
rpg: I don't see any talks about a standard in any of their channels, so it's doubtful to happen in the next 5 years, but forever is a long time.
SaganMan has quit [Quit: WeeChat 1.6]
ryan_vw has joined #lisp
xificurC has joined #lisp
stereosphere has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
<no-defun-allowed>
aeth: that's the joke
<aeth>
no-defun-allowed: idk, I expect at least one new standard in the next 60 years.
faraco has joined #lisp
dented42 has joined #lisp
<Ober>
we'll just keep redoing the website with more pictures and less content. :P
robotoad has joined #lisp
robotoad has quit [Client Quit]
esrse has joined #lisp
robotoad has joined #lisp
ryan_vw has quit [Ping timeout: 272 seconds]
ryan_vw has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
anamorphic has joined #lisp
arescorpio has quit [Quit: Leaving.]
makomo has quit [Ping timeout: 272 seconds]
buffergn0me has quit [Remote host closed the connection]
<LdBeth>
oni-on-ion (IRC): probably invented on MacLisp or Lisp Machine Lisp
<LdBeth>
In Lisp Machine Manual you can see most reader macros already existed there
dddddd has quit [Remote host closed the connection]
<Elronnd>
I want faster membership checks than I'd get with a list or array
<Bike>
not built in. there's an FSet library you might like.
<oni-on-ion>
CL has no built in set..?
<buffergn0me>
There are the SET- functions that operate on lists as though they were sets
<buffergn0me>
but there is no type specified in the standard
kyby64 has quit [Quit: Leaving]
charh has joined #lisp
<oni-on-ion>
ah. that sounds alright for my own uses.
<slightlycyborg>
is there any way that writing to a stream can trigger a hook?
<slightlycyborg>
I basically want to call a function that writes to a socket whenever I write to a stream
<slightlycyborg>
I think I will have to spaw a thread
<oni-on-ion>
im feeling that you may not need a thread for that
<LdBeth>
slightlycyborg: you can customize a write function
<LdBeth>
Would this makes difference in your use case?
<slightlycyborg>
I don't know what that would mean. However, I think I can just make a socket-stream
faraco has quit [Ping timeout: 268 seconds]
<buffergn0me>
slightlycyborg: You can use MAKE-BROADCAST-STREAM to take a bunch of streams. When you write to that broadcast stream, the same thing is written to all of them
<Elronnd>
Has anyone used ningle? Is there a good way to serve binary files with it aside from loading them into memory and returning them?
<anamorphic>
I have this function, (defun (setf attribute) (new-value handle attribute-name) ...) and it would be more useful if I returned `handle' instead of `new-value' (then I could chain things if I needed to). Is there anything wrong with returning an argument other than new-value from a setf function?
<Bike>
yes, it's against protocol.
<buffergn0me>
I would get confused
<Bike>
it could mess up macros that use setf.
igemnace has joined #lisp
<anamorphic>
I see..
rumbler31 has joined #lisp
Oladon has quit [Quit: Leaving.]
montxero has quit [Quit: leaving]
<slightlycyborg>
I know have the jankiest augmented reality machine imaginable. I took an rpi with a 3.5 inch lcd, mounted that to a bike helmet so that it hangs directly in front of my face. I then used SBCL sockets to create a *helmet-stream* so I can print things to my helmet console using (format *helmet-strea* ...)
<beach>
Good morning everyone!
<anamorphic>
slightlycyborg, that sounds awesome
Roy_Fokker has quit [Read error: Connection reset by peer]
<no-defun-allowed>
o/
<buffergn0me>
Good morning
<oni-on-ion>
good morning
ryan_vw has quit [Ping timeout: 268 seconds]
Oladon has joined #lisp
mathu has joined #lisp
<mathu>
herb sutter referenced defun defun () 3 in a talk; what is the tl;dr on what that does? :P
<beach>
mathu: That doesn't make any sense. Can you give a link?
<mathu>
the context is he's describing how you can go too far with giving users control over Words of Power and language mechanics. he says "google defun defun 3" in the talk, which leads me eventually to http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0707r3.pdf if you search "defun" here you can see
<mathu>
there are parens around it all if that makes it make sense. i don't know lisp :P
<Bike>
well, don't leave out those parentheses
<Bike>
(defun defun () 3) would mean to define "defun" as a function of no arguments that returns 3, but that's illegal because defun is already a standard macro
<no-defun-allowed>
it just says how to piss off people with redefinition and standards violations
<beach>
mathu: The positions of the parentheses are essential to the meaning of the code.
<no-defun-allowed>
additionally, it wouldn't work since there'd be too many args
<mathu>
a footnote in the paper on the page that includes (defun defun () 3) says that common lisp added the restriction that standard names are protected, so i take it there is a history where this code worked
<mathu>
yeah, that's why i didn't know about the parens haha. i don't know lisp
<no-defun-allowed>
>In Lisp and related languages, programmers can redefine other people’s code and even global language facilities (e.g., the notorious (defun defun () 3) in Lisp, or (define define () 3) in Scheme).
<no-defun-allowed>
>This is powerful, but undisciplined (causes arbitrary global effects up to and including breaking the language itself)
<no-defun-allowed>
you bet that's UB and/or illegal
<beach>
Herb Sutter clearly does not know any Lisp.
<beach>
mathu: You can safely ignore that remark.
<mathu>
i took all this to mean there is a history in which it was not disallowed
<no-defun-allowed>
mind you, it's a bit rich from a C++ programmer to say Lisp could get unreadable
<mathu>
if it were allowed, what would it mean? i don't know what the 3 is
<no-defun-allowed>
c++ is unreadable with minimal effort
<Bike>
i told you what it would mean.
<Bike>
3 is the function body.
<no-defun-allowed>
it returns 3 instead of doing anything
<Bike>
or rather (3) is the body.
<no-defun-allowed>
*doing anything useful.
<mathu>
ahhh i missed that, thank you Bike
<no-defun-allowed>
additionally, in scheme it is (define (define . args) 3)
<beach>
mathu: It sounds like someone who wants do discourage people from using one of the most powerful languages around by spreading misinformation by making people scared of using it.
<no-defun-allowed>
people who use ms word for papers are evil in general.
<beach>
mathu: The truth is that it is impossible to write a C++ program that is both modular and fast, whereas that is entirely possible in Common Lisp. So Sutter is sending the wrong message.
<no-defun-allowed>
i have a sample size of three: the author of that and the doofus who steals my laptop's parents.
<Bike>
i'm confused about the "infamous" part.
<beach>
Yeah, makes no sense.
<beach>
He must have made it up.
<Bike>
i mean there's even a footnote explaining it doesn't work in common lisp
<Bike>
which is pretty old already
<mathu>
no-defun-allowed: herb sutter has been at microsoft for like 15 years so he's probably required to use word for papers haha
<no-defun-allowed>
that explains A LOT
<beach>
mathu: Unfortunately, because of some very strong psychological phenomena, C++ programmers reading that paper will likely believe him and avoid looking at Common Lisp.
<no-defun-allowed>
"we gotta show our incompatible dialect of c++ and absolute bullshit language called c# are good what do we do"
<mathu>
beach: i feel like if you're reading proposal papers for c++ you're probably not writing a lot of common lisp as it is
<beach>
mathu: He should avoid making references to something that he knows nothing about and that is untrue.
<beach>
mathu: I advise you to avoid falling into that trap. We are here for you if you want to learn a better way of writing programs.
<no-defun-allowed>
if it's MS they'd probably get bonuses for FUD
<mathu>
lol if i ever want to learn lisp you will be seeing me again
<beach>
mathu: The sooner you do it, the more time you will save over your remaining lifetime.
<mathu>
lisp really is a cult huh lol
<beach>
No.
<beach>
Just a very powerful tool.
anamorphic has quit [Ping timeout: 276 seconds]
oni-on-ion has quit [Ping timeout: 250 seconds]
Bike has quit [Quit: Lost terminal]
<mathu>
anyway, thanks for explaining what the supposed meaning of that code snippet was folks
<beach>
mathu: If you are a C++ programmer, you have probably already accumulated a bunch of false information about Common Lisp.
<beach>
mathu: Anytime. #lisp is apparently one of the most helpful channels here.
<mathu>
beach: all i have are parenthesis jokes, no FUD internalized
<beach>
mathu: OK. So you know that Common Lisp is not an "interpeted language". Good.
<mathu>
well now i do haha
<beach>
I guess I meant to say: "OK. So you have not been told by anyone that Common Lisp is an "interpreted language". Good."
buffergn0me has quit [Read error: Connection reset by peer]
<beach>
mathu: I said that, because that is some of the misinformation about Common Lisp that ignorant people will spread in order to avoid that others discover its power.
<mathu>
i also don't regard being interpreted as a negative
<beach>
Ah, but it is. It makes things slow.
<mathu>
that's fine for most code
<beach>
mathu: People confuse "interactive" and "interpreted" because they believe that when something is compiled, it has to generate an executable file. Common Lisp is interactive, but most implementations compile the code on the fly and then immediately execute it.
<beach>
mathu: So Common Lisp can be very fast (if you choose the right implementation).
<mathu>
would you happen to know if haskell's ghci is a compiler of the kind lisp uses or if it's a true-blue interpreter?
<beach>
I don't know. But I would think it is a compiler. Others might know.
<LdBeth>
It’s a interpreter
<beach>
Oh.
<beach>
mathu: So with Common Lisp, you get the superior power of an interactive language, allowing you to test your code interactively as you code, not having to wait for the compiler and the linker every time. But you still have excellent performance.
<mathu>
it gives you a REPL, but i wasn't sure if it was the sort of iterative compiler that google is telling me CL has
<beach>
mathu: Plus, with Common Lisp you get a sane object system that is probably one of the most powerful object systems around, namely CLOS.
<beach>
mathu: Compared to C++, you also get the superior performance of a tracing garbage collector, compared to the slow new/delete or malloc/free (which in addition is terribly error prone).
<LdBeth>
GHCi can load compiled though, but it does not compile because GHC compiles really slow
<beach>
I see.
oni-on-ion has joined #lisp
buffergn0me has quit [Read error: Connection reset by peer]
<aeth>
With SBCL, you can make the same algorithm be up to 35x to 50x faster than slow (non-JIT) interpreters (like Python or Ruby).
<beach>
Yes, that's well known.
<beach>
mathu: Most people who have invested many years learning some inferior technology are not ready to take in such information, as this essay explains: http://metamodular.com/Essays/psychology.html
buffergn0me has joined #lisp
<LdBeth>
I believe with partial evaluation performance of lisp system can greatly boost
<LdBeth>
Today Lisp is still the ideal assembly for advanced stuff
<no-defun-allowed>
nice essay
pjb has quit [Ping timeout: 252 seconds]
buffergn0me has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
buffergn0me has joined #lisp
<beach>
no-defun-allowed: Thanks!
<no-defun-allowed>
my dad always told me i spent too much time messing about with things, that explains a lot
<gendl>
Ha nice essay. I didn't realize it was written by beach until I got to the end. Then suddenly I heard the whole thing in his voice.
<beach>
gendl: Heh! Thanks!
igemnace has quit [Ping timeout: 244 seconds]
buffergn0me has quit [Ping timeout: 252 seconds]
<gendl>
I had just tweeted something along those lines this morning (for some reason it seems I've taken to "tweeting" lately...)
<gendl>
i'm gonna "tweet" a followup reply with a link to that essay.
<gendl>
beach: not so fast, tiger. My tweets usually get liked/retweeted 1-2 times or so, if i'm lucky lol.
<beach>
Heh. Still, you correctly identified the phenomenon.
<beach>
I read up on it a bit more. The origin is form Carol Dweck, who used the terms "open and closed mind set".
<beach>
She has some interesting presentations on YouTube.
<no-defun-allowed>
hm, the cmusphinx speech model is actually a bit weak and underdeveloped
<no-defun-allowed>
phonemes at the start of syllables are quite different to ones at the end
<russellw>
I want to search a string for occurrences of whitespace, so find-if seems to be the right function to use, but returns an element, where I need the position. search returns a position, but wants a subsequence, which in this case I don't have. What's the recommended function to use?
<no-defun-allowed>
(position-if #'space-p string) i suppose
<russellw>
The position returned is the index within sequence of the leftmost (if from-end is true) or of the rightmost (if from-end is false) element that satisfies the test
<russellw>
typo? rightmost/leftmost should be reversed?
<beach>
I think that's an error in the Common Lisp HyperSpec.
rumbler31 has quit [Remote host closed the connection]
<aeth>
(the code example part)
<pjb>
aeth: the opinion expressed in that ycombinator news item is bullshit. Lisp is the most maintainable language. Even when you start from bad lisp code, it's easier to edit it and make it good than from any other programmming language.
<no-defun-allowed>
do you like msdos batch files?
<no-defun-allowed>
now your lisp can look like msdos batch files
<pjb>
It could be better, perhaps, but since it's the best already…
<no-defun-allowed>
(setf /a %foo (+ %bar %baz))
<aeth>
pjb: I think if there's a lesson to be learned it's that CL needs another CAS
<pjb>
I don't know. I don't use maxima routinely. That is, I've not used it since I installed last time, a few years ago…
<no-defun-allowed>
minion: what does CAS stand for?
<minion>
Churchliness Amaroidal Sulfomethylic
<russellw>
:)
<pjb>
Perhaps if it was a quicklisp system?
<jackdaniel>
speaking of atomic operations, support for them has been merged to ECL recently (interface is very much like sbcl's cas api)
<aeth>
Computer Algebra System (
<aeth>
CAS)
<jackdaniel>
cas is usually used as compare and swap (at least these days)
<no-defun-allowed>
nice wikipedia copy-paste, aeth
<no-defun-allowed>
lol
<no-defun-allowed>
jackdaniel (IRC): remembering your clim textbox demo, are there resources for theming McCLIM?
<aeth>
I wanted to say suite
<aeth>
surprised it's system, actually
<jackdaniel>
no-defun-allowed: I have some work on adding proper abstraction for that
<aeth>
the computer algebra part is the important part, though
<aeth>
No one wants to multiply matrices or factor things by hand.
<jackdaniel>
there is no abstraction for theming per se at the moment (of course CLLIM doesn't limit you on that front, it just doesn't have it)
<jackdaniel>
CLIM°
<no-defun-allowed>
cool! i'll probably write a frontend for netfarm with mcclim if i can make it prettier
<no-defun-allowed>
do you have resources on how you made that at least?
<jackdaniel>
as I said, I haven't finished that yet, I'm working on a support for applications for theming
<jackdaniel>
(but not right now, this task is suspended for other with higher priority)
<jackdaniel>
first make it work, then make it pretty
<no-defun-allowed>
may i at least see a diff or what you did do please?
<jackdaniel>
getting usable user interfaces is a very hard thing to do
<jackdaniel>
diff of what?
<no-defun-allowed>
what you did to make the textboxes look nice
<jackdaniel>
this does not work well and is wip, I won't share a code of the scraps being already there
<no-defun-allowed>
okay then
<russellw>
why the heck does ultraedit think defined-atomic-term is already defined?
<russellw>
is it a known keyword or macro in any context?
<jackdaniel>
probably not. could it be that you redefine your own definition?
<russellw>
SBCL doesn't seem to think so, at least. nope, I have never defined it before
<aeth>
CASes are useful because you can e.g. just say [1 1 1; 0 1 0; 0 1 1] * [1 0 -1; 0 1 0; 0 -1 1] and get the result of the matrix multiplication (that's GNU octave, not maxima... good syntax for matrices). Even if you're programming it, it's helpful to have an external, probably-reliable, alternate way to get the same result via a CAS to check your answer. Basically, math REPLs.
<aeth>
(The syntax for all of these CASes would be awful to actually program a non-trivial program in, though. That's why a CAS in CL is useful.)
tumdum has quit [Quit: bye]
<no-defun-allowed>
i wrote a lisp interpreter in maxima
<no-defun-allowed>
if there was a COND equivalent instead of IF it would be a bit easier though
<jackdaniel>
but maxima lets you to drop to underlying lisp repl, why would you do that?
makomo has joined #lisp
<no-defun-allowed>
fun
asarch has quit [Quit: Leaving]
<jackdaniel>
if it were my time I would be concerned - luckily it isn't
igemnace has joined #lisp
<no-defun-allowed>
what? fun mental excercise.
<jackdaniel>
I mean - there are so many fun things to work on as an excercise which are not solved yet in so many software libraries, that hacking something what is already there is a waste
* jackdaniel
gets back to minding his own business
<aeth>
You have to write stuff that other people have written before you get good enough to write new stuff
<oni-on-ion>
minion: what does aeth stand for?
<minion>
Adream Ensorcelize Troutful Harmala
JohnMS_WORK has joined #lisp
<jackdaniel>
if this kind of statements were true, we'd be still developing wheel and discovering fire
K1rk has joined #lisp
<oni-on-ion>
have you never said the same thing twice ?
<jackdaniel>
that's not my point, but I'll keep silent from now on
<oni-on-ion>
or something someone else has said, or will say ?
<oni-on-ion>
ok
* oni-on-ion
sees a quit message in another channel just now: "The only real mistake is one in which we learn nothing"
<ThJ>
so, intro books... "Land of Lisp" or "Practical Common Lisp"? i've been told that either is "the best one".
<jackdaniel>
ThJ: do you have prior programming experience?
<ThJ>
jackdaniel: 26 years.
<jackdaniel>
then you'll be good with practical common lisp
<jackdaniel>
another great piece of learning material released recently for free is PAIP
<jackdaniel>
which is arranged around a case studies in Common Lisp
<jackdaniel>
superficially, it is an excellent Common Lisp textbook
<no-defun-allowed>
well i wrote it around six months ago
* Ober
forgets how slow roswell based scripts are
<no-defun-allowed>
mind you, i've only had around a year of experience writing CL
Oladon has quit [Quit: Leaving.]
<no-defun-allowed>
roswell amazes me how un-cl-like cl can get tbh
razzy has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
eminhi has joined #lisp
<slightlycyborg>
jackdaniel: i am reading through paip right now
robotoad has quit [Quit: robotoad]
<slightlycyborg>
any ongoing project to implement emacs with mclim?
<no-defun-allowed>
(second) climacs?
<slightlycyborg>
oh ok. I only saw climacs, didn't know there was 2nd
<jackdaniel>
slightlycyborg: afaik beach works on a second climacs. first climacs is in quicklisp. I don't have any plans for emacs clone myself, I don't like this editor
<jackdaniel>
there are plans for improving text input gadgets though
<slightlycyborg>
robert_strandh is <beach>?
<slightlycyborg>
on github
<jackdaniel>
yes
<slightlycyborg>
ok. cool.
<ThJ>
climacs? oh, the puns...
<jackdaniel>
I'll tell you a better one: climaxima ,) loke works on CLIM gui for Maxima
eminhi_ has joined #lisp
<ThJ>
i sort of found the "emacs"-like ending of it funny
<ThJ>
that disappears in climaxima, and also, another letter that makes it sound less sexual
<ThJ>
climacs still funnier imho
<oni-on-ion>
its that deep? clim + emacs = climax
<jackdaniel>
oh, OK
makomo has quit [Ping timeout: 250 seconds]
<ThJ>
humour is entirely subjective of course...
<oni-on-ion>
explanations of human tend to have an objective effect
<oni-on-ion>
humor*
<ThJ>
more like dejecting...or deflating even
<ThJ>
"oh no, he's going to explain the joke"
Lord_of_Life has quit [Ping timeout: 244 seconds]
eminhi has quit [Ping timeout: 276 seconds]
<ThJ>
are there jokes written in S-expressions?
* aeth
points to the topic
<oni-on-ion>
hehe. and yes all of them, if you get it
<ThJ>
every S-expression is a joke?
<aeth>
I think "Common Lisp, the #1=(programmable . #1#) programming language" is supposed to be a joke
<beach>
slightlycyborg: (first) Climacs was my first attempt at an Emacs-like editor written in Common Lisp. It has some limitations that I want to fix, in particular when it comes to analyzing Common Lisp code. Second Climacs is work in progress. I am not working on it right now, but with a bit of luck, progress will be made in the near future.
<ThJ>
i need to learn that bit of lisp to get it first, haha
<Ober>
Climax, because we'll be damned if CL does have any it's own 2nd System Syndrome!
<jackdaniel>
ThJ: #1=(foo . #1#) is a self reference, you could expand it as #1=(foo . (foo . (foo . #1#))) ; (ad infinitum)
<oni-on-ion>
"ha. ha. ha."
<ThJ>
jackdaniel: the dot is concatenation syntax?
<oni-on-ion>
(a . b) = (cons a b)
robotoad has joined #lisp
<jackdaniel>
ThJ: dot is a pretty way of printing a cons
<jackdaniel>
cons is a basic data structure with head and tail (two pointers)
<jackdaniel>
common lisp lists are linked lists made of cons
<jackdaniel>
(list 1 2 3) is equivalent to (cons 1 (cons 2 (cons 3 nil)))
<ThJ>
oh, so (list) isn't a fundamental data structure...
<jackdaniel>
nil has a special meaning in a sense that it terminates the list.
<oni-on-ion>
export PATH=/sbin:$PATH but ReAl TiMe
<jackdaniel>
(list) is the same as NIL (empty list). there is #clschool channel for basics (ftr)
orivej has joined #lisp
shka_ has joined #lisp
<aeth>
(let ((*print-circle* t)) (format t "~S~%" '#1=(programmable . #1#))) or even (let ((*print-circle* t)) (format t "~S~%" (nthcdr 1000 '#1=(programmable . #1#))))
<ThJ>
jackdaniel: i was trying to use the parenthesis to indicate that i was speaking lisp, not using the english word "list"
<jackdaniel>
as you can see this caused a misunderstanding, so it might be that such indicator is a poor one :)
<slightlycyborg>
beach. That is awesome. Do you think it wil be suitable as a daily driver? Do you use it as such?
<ThJ>
jackdaniel: yes...
nopf has joined #lisp
<aeth>
I actually found a practical (well, the program itself is impractical) use for *print-circle* and the whole #1= thing recently. https://gitlab.com/snippets/1761668
<aeth>
The best part is that if I coerced that vector into a list once the need for random access is over the return value itself would be n
Ober has left #lisp ["ERC (IRC client for Emacs 26.1)"]
<beach>
slightlycyborg: I fully intend to make Second Climacs extremely good for editing Common Lisp code, so I think I will use it myself for that. For other things, it would take some work to get it to become as competent as Emacs.
varjag has joined #lisp
<slightlycyborg>
beach: ya, I suppose you don't plan on implementing a cl->el compiler, so all modules will be in cl
<aeth>
slightlycyborg: wouldn't it be el->cl?
<slightlycyborg>
ya, nvm
<aeth>
el->cl should be easy (and it has been done at least once before). Common Lisp was literally made so you could port legacy Lisps like Emacs Lisp to it.
<slightlycyborg>
lol
<oni-on-ion>
guile
<no-defun-allowed>
yeah it probably would be
<aeth>
guile has a lot more of a mismatch
<oni-on-ion>
mismatch to what ? its elisp support matches with emacs now.
<no-defun-allowed>
guile is a Scheme, CL and EL are both Maclisp children.
<aeth>
oni-on-ion: mismatch in the language design
<oni-on-ion>
even going so far as to imitate dynamic bindings
<shka_>
good morning
<oni-on-ion>
guile is an implementation; it does elisp.
<no-defun-allowed>
although guile supports JS for the lols i think
<oni-on-ion>
why would i mention guile randomly, for fun? =) yeh emcascript was a test afaik. a real joke there =)
<shka_>
guile implements scheme
<aeth>
Having gone the other direction, and implemented large parts of Scheme on CL, I can say it's not entirely trivial. But Emacs on CL probably could actually be described as trivial.
<aeth>
s/Emacs/Emacs Lisp/
<oni-on-ion>
nto sure what you guys are saying. guile does elisp thats all im saying =)
<aeth>
Dynamic bindings are supported natively, t/nil instead of #t/#f/'(), etc.
<aeth>
Slightly different semantics for things like car etc
<oni-on-ion>
what are you talking about? guile> ,language elisp
<aeth>
oni-on-ion: I'm saying that implementing Emacs Lisp on top of Common Lisp is something you could probably do in a week or less.
<oni-on-ion>
it has 'languages' like racket does. maybe thats what was not immediately obvious. i dont mean to say that elisp is compatible with guile scheme in the same files.
<aeth>
oni-on-ion: Implementing Emacs Lisp on Guile was a major project
<oni-on-ion>
aeth: ah, yeap.
<oni-on-ion>
adding 'isnil?' and such
<aeth>
And the difference here is that Common Lisp was designed so that you could port "legacy Lisps" (Lisps with classic design decisions like Emacs Lisp choose) to it
<aeth>
So e.g. the EL:LET macro would just be the LET macro with (declare (special foo)) for every foo bound in the LET
<beach>
slightlycyborg: No, that would not be practical. Part of the reason for writing it in Common Lisp is to get a better architecture. That goal would be defeated if I had to support Emacs Lisp code without modification.
<oni-on-ion>
true aeth i often forget that about CL
<oni-on-ion>
plus theres guilemacs, just add CL into guile, bing bang boom 1 2 3
<oni-on-ion>
'(joke)
scymtym has joined #lisp
xificurC has joined #lisp
frodef has joined #lisp
eminhi_ has quit [Ping timeout: 250 seconds]
lemoinem is now known as Guest77499
Guest77499 has quit [Killed (verne.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
heisig has joined #lisp
DataLinkDroid2 has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 252 seconds]
robotoad has quit [Quit: robotoad]
angavrilov has joined #lisp
eminhi has joined #lisp
fikka has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
ggole has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
igemnace has quit [Remote host closed the connection]
shrdlu68 has joined #lisp
elfmacs has joined #lisp
DataLinkDroid2 has joined #lisp
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
shifty has quit [Ping timeout: 246 seconds]
dented42 has joined #lisp
igemnace has joined #lisp
nly has joined #lisp
akovalenko has quit [Ping timeout: 268 seconds]
dented42 has quit [Ping timeout: 260 seconds]
cl-arthur has joined #lisp
asymptotically has joined #lisp
dented42 has joined #lisp
solyd has joined #lisp
dented42 has quit [Ping timeout: 252 seconds]
nowhere_man has joined #lisp
dented42 has joined #lisp
zfree has joined #lisp
MichaelRaskin has quit [Quit: MichaelRaskin]
hhdave has joined #lisp
nly has quit [Read error: Connection reset by peer]
nly has joined #lisp
nowhere_man has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
python476 has joined #lisp
angavrilov has quit [Remote host closed the connection]
maarhart has joined #lisp
angavrilov has joined #lisp
dented42 has quit [Ping timeout: 244 seconds]
orivej has quit [Ping timeout: 276 seconds]
maarhart has quit [Client Quit]
varjag has quit [Ping timeout: 246 seconds]
orivej has joined #lisp
nly has quit [Read error: Connection reset by peer]
dmiles has quit [Ping timeout: 268 seconds]
<slightlycyborg>
flet on a already defined function, does it work like let on a dynamic variable?
<jackdaniel>
slightlycyborg: not exactly, function is bound in its lexical scope only
<jackdaniel>
try defining functions foo returning 3, bar calling foo and then call
<jackdaniel>
(flet ((foo () 4)) (bar))
<jackdaniel>
I think that at one els there was an overview of dynamically scoped functions, but I don't remember which
<jackdaniel>
(in a form of a library)
<jackdaniel>
also compare (flet ((foo () 4)) (funcall 'foo)) with (flet ((foo () 4)) (funcall #'foo)) and (flet ((foo () 4)) (foo))
<slightlycyborg>
Ok. That sucks. I want to override a function call somewhere deep in my code
<slightlycyborg>
I'm tweeting out my completed todos, but I want to test todo completion without tweetng them by overriding a function
dmiles has joined #lisp
<jackdaniel>
slightlycyborg: easy solution would be binding function to a dynamic variable and calling it with funcall
dddddd has joined #lisp
<jackdaniel>
like (let ((*my-fun* (lambda () 4))) (whatever))
<jackdaniel>
and whatever having (funcall *my-fun*)
<jackdaniel>
you may even hack it like: (defun foo (&rest args) (apply *my-fun* args))
<jackdaniel>
then when you call (foo) from whatever, it will automagically resolve to the dynamically bound variable having function
<slightlycyborg>
Ya, I don't want to litter my code with funcall for the sake of a hack.
<jackdaniel>
that's why I've suggested a second solution …
<slightlycyborg>
this wouldn't be a problem if cl was a lisp1 would it? I could dynamically let the fn name and the eval would operate on it properly.
<jackdaniel>
you mix up things
<slightlycyborg>
how?
<jackdaniel>
eval is rarely called in compiled code
<slightlycyborg>
oh.
<slightlycyborg>
so its the reader that would do that then?
dented42 has joined #lisp
<jackdaniel>
I think I'm not qualified enough to explain this topic despite having some understanding of it
<no-defun-allowed>
The compiler would handle scope of variables then.
<jackdaniel>
reading is yet another source code processing step and doesn't have much to do with calling functions
Lord_of_Life has joined #lisp
<_death>
it has to do with dynamic and lexical bindings, not with namespaces, so lisp1 is irrelevant
<no-defun-allowed>
Yep. If your function is in the variable namespace, lisp1/2/n doesn't matter too much.
<_death>
you could (letf (((fdefinition 'my-function) #'some-other-function)) ...) but it's a drastic measure, will affect other threads, and you'd want to declare the name notinline
<_death>
you could look into something like Pascal Costanza's filtered-functions
<trittweiler>
slightlycyborg, depending on how your code looks like, but one way to do this is to make that piece of code a generic function, and then in your test code, inherit from the TODO object and specialize on that subclass
frgo has joined #lisp
<_death>
(or contextl..)
eminhi has quit [Quit: leaving]
<slightlycyborg>
_death: that letf sounds interesting. if I am not using other threads would it cause problems?
<jackdaniel>
it will bite you eventually (ignoring multiprocessing issues)
<slightlycyborg>
jackdaniel: it is only for testing though
<jackdaniel>
you know best, I can only voice some heuristics ;)
<slightlycyborg>
wait, is letf supposed to be setf?
<jackdaniel>
yes, letf is a setf with setf-back in cleanup of unwind-protect
<jackdaniel>
it is hack which you may find sometimes and it bites in the ass if the whole algorithm depends on it *and* you want to make something work in multiprocessing environment
<slightlycyborg>
Ok. Ya, that seems drastic.
<slightlycyborg>
hahaha
<slightlycyborg>
So let on dynamic variables doesn't affect multiprocessing I suppose?
<jackdaniel>
I believe that solution suggested by me above (using dynamic variables and a trampoline) is 1) suitable for your purpose, 2) safe
<jackdaniel>
first thing is: CL doesn't have notion of multiprocessing, so it is all implementation-dependent
<jackdaniel>
second thing: yes, usually dynamic bindings are per-thread, so they are thread-safe
mingus has quit [Read error: Connection reset by peer]
<slightlycyborg>
Ya, true. I know from experience with *standard-output* that SBCL rebinds per thread, cause I had to lexically close over a variable like top-level that was let to *standard-output*
<slightlycyborg>
to print in a seperate thread
<jackdaniel>
all implementations with threads I've tried behave that way (but there are alternative implementation strategies and it would be still a conforming CL implementation)
<slightlycyborg>
Ok. Anyway, I will utilize the apply strategy for this.
<|3b|>
looks like you run out of ram while trying to print a backtrace from an error
<jmercouris>
Let me upgrade the VM
<jmercouris>
one second
<|3b|>
so you might end up with a bunch of copies of the upload if it is dumping whole thing to text for every frame it shows up in or something
<|3b|>
did you successfully upload a small file with that code?
<_death>
right, (ERROR "~@<When attempting to ~A, the slot ~S is missing from the ~ object ~S.~@:>" "read the slot's value (slot-value)" VECTOR #<SB-SYS:FD-STREAM for "file /tmp/tmpGHU3ALSW.tmp" {100 1889413}>)
<jmercouris>
|3b|: yes, I've successfully uploaded many small files
<jdz>
Is there no way to not read the whole file into memory before writing it to disk?
<_death>
it looks like you have a file stream already.. maybe it's just a matter of renaming a file
<jmercouris>
jdz: Probably, I just dont know how
<|3b|>
i'm guessing it has a way, and that's what happens to break it
<jdz>
Well, running out of disk space is probably as common as running out of memory.
<jmercouris>
so where you see |file| in the defroute lambda list is hash
<jmercouris>
and the first argument is the file name, the second is the file
<jmercouris>
so _death I assume you are suggesting take data (from the let), and somehow copy it to the desired location?
<|3b|>
i think you are getting different types for the file contents depending on size (or maybe upload format, chunked etc)
<jdz>
You might at least look at the content-length header and not process requests that are too big.
<jmercouris>
jdz: That's already configured on the nginx side of things, limited to 50mb
<jmercouris>
but I want users to be able to upload files of around 10, 20mb, as they will be uploading CAD files
<_death>
jmercouris: I'm thinking the framework you use already writes it to a file and passes a stream
<jmercouris>
_death: maybe, I am using caveman2, which uses clack and lack
<jmercouris>
I don't know how it handles multipart encoded requests
<_death>
so the next step is to find out what's going on
<jdz>
Anyway, 50MB should not be a problem with 1GB dynamic space size...
<jdz>
Unless multiple parallel uploads are being processed.
<|3b|>
yeah, i don't think file size is directly the problem (beyond it possibly changing how the server lib handles the data)
<jmercouris>
well, I went ahead and resized the droplet, now has 8gb of ram instead of 2
<jmercouris>
I remember some warning in the sbcl man page about when it tries to use more virtual memory than is allocated it causes a crash or something
<jmercouris>
I don't know, I'm just shooting in the dark here, but I figured I'll try the simple thing first
<jdz>
This is not really solving the problem, though.
<|3b|>
might give you a readable backtrace at least :)(
<jdz>
Just making it less likely to happen, but more likely to happen in most unfortunate moments.
<_death>
you're assuming the stream is a flexi-stream that has vector storage, but that ain't so
<_death>
so start with that
<|3b|>
from the backtrace it will happen either way
<|3b|>
underlying problem will happen i mean
<jmercouris>
ok, so I have a more reasonable trace now
<jmercouris>
one second
<|3b|>
but with more ram it might give you a backtrace from that instead of from thje error handler running out of memory
<jdz>
I had the impression that the heap exhaustion error is first, as a result of which the slot in the instance is not set, which causes problems when generating the backtrace.
<|3b|>
i think your problem is that you just need to treat the file as a stream, and read parts from it and write to your destination file rather than treating it as a sequence
rumbler31 has joined #lisp
<|3b|>
yeah, looks like with big files you get a stream to a temp file instead of an in-memory flexistream
<jmercouris>
right
<jmercouris>
this file /tmp/tmpGHU3ALSX.tmp
<|3b|>
alexandria has copy-stream, which might simplify the code
<jdz>
And the error message is clear: "the slot VECTOR is missing from the object ..."
rumbler31 has quit [Remote host closed the connection]
<jdz>
I bet that's the 'flexi-streams::vector slot.
<jmercouris>
so I went to /tmp/tmpGHU3ALSX.tmp, and that is the file I was trying to upload
<jdz>
And it also says that the object where the slot is missing is a stream.
<jmercouris>
so what, I have to handle big and small files differently in the code?
<|3b|>
(you could also try to detect file streams and move the file, but that risks conflicts with the server trying to delete the temp file or whatever)
<|3b|>
jmercouris: just use alexandria:copy-stream on both
<jdz>
You should read the documentation of the library.
<jmercouris>
jdz: This is a common lisp library, I think you and I both know there is no documentation beyond the readme
<jdz>
I'd expect the file parameter to always be a stream.
<jdz>
For short files it might be a FLEXI-STREAM, though.
<|3b|>
probably shouldn't be using flex::vector anyway, given the ::
<jdz>
That's a hint, yes.
<jmercouris>
|3b|: fair enough, let me try using alexandria:copy-stream
NB0X-Matt-CA has quit [Ping timeout: 245 seconds]
NB0X-Matt-CA has joined #lisp
solyd_ has joined #lisp
dented42 has joined #lisp
solyd has quit [Ping timeout: 252 seconds]
solyd_ has quit [Client Quit]
<jmercouris>
ok, so when I use a large file
astronavt has quit [Ping timeout: 244 seconds]
<jmercouris>
it is now a #<SB-SYS:FD-STREAM for "file /private/var/folders/98/plnqpl8j7k51bmshc0c9r60r0000gn/T/tmpJAIDFZTC.tmp" {1002DA7753}
<jmercouris>
for the first slot
<jmercouris>
I'm sorry, I don't mean slot, I mean list
<jmercouris>
I don't mean list, I mean element in the list, excuse me
<|3b|>
right, i think the only thing you can rely on is that it is a stream you can read from
<jmercouris>
hence why you suggested alexandria:copy-stream, right?
<|3b|>
right7
<jmercouris>
strange behavior
dented42 has quit [Ping timeout: 252 seconds]
<jmercouris>
I guess it makes sense though, for very large files
<|3b|>
possibly also for slow uploads
cl-arthur has quit [Quit: Lost terminal]
<jmercouris>
unfortunately I don't know how to make the output stream
<jmercouris>
I'm still learning about streams
<|3b|>
your existing code did that fine
<jmercouris>
so I should just use (with-open-file ...) and then put "s" as the output stream?
<|3b|>
just get rid of the DATA variable, and replace write-sequence call with (alexandria:copy-stream (first |file|) s)
<|3b|>
right
<jmercouris>
ok I already did the first part, I kept it in a let though so it is still (data (first |file|)), just easier for me to understand taht way
<jmercouris>
s/taht/that
<|3b|>
yeah, that's fine
<_death>
the default buffer size for copy-stream is 4096, which I would think is too small
<jmercouris>
is that in bytes or?
<|3b|>
yeah
<jmercouris>
maybe I should make it like 512kb or so
<|3b|>
depends on what sort of usage you expect
<_death>
and then there's already the fd-stream buffering.. so maybe it's not a big issue.. better profile
<|3b|>
lots of uploads at once or not, etc
<|3b|>
though most likely it doesn't matter either way :p
<jmercouris>
so, alexandria copy stream is agnostic of flexi stream or of a sb-sys:fd-stream?
<|3b|>
(unless you have lots of uploads, performance probably doesn't matter too much, and if you do you might want to keep ram per client down anyway)
<|3b|>
right, it should work on any stream with matching element types
<jmercouris>
that's amazing
<|3b|>
(and correct read/write, etc)
<jmercouris>
sure enough, problem solved
<|3b|>
well, flexistream and fd-stream are implementation details to the streams API in general
<|3b|>
there is a non-standard but pretty much universally implemented extension called "Gray streams" that lets you make your own stream types that work with the normal stream APIs, flexistreams is an example of that
<python476>
damn quicklisp is such a bliss
<python476>
zach beane needs an award
nowhereman has joined #lisp
<_death>
for a long time I felt uncomfortable with CL streams.. one day it occurred to me that the discomfort comes from Gray streams, which mostly just took the user's interface and adapted it to an extender's interface, resulting in a mess of a protocol.. I looked at Franz' simple-streams, and it's much better.. and SBCL also implements that, although I had to fix a bug there to make it work
<jmercouris>
I see
nowhereman is now known as Guest6910
<jmercouris>
well, I still don't understand what a stream IS exactly
<jmercouris>
its a file? a buffer?
<python476>
a stream is .. a stream
<jmercouris>
a pointer to a file that loads a file?
<|3b|>
something you can read or write to
<jmercouris>
a stream is a pipe?
<|3b|>
anything else is implementation details :)
nowhere_man has quit [Ping timeout: 268 seconds]
<python476>
one would say it's an object
<|3b|>
could be a pipe, socket, in-memory buffer, TTY, serial port, whatever
<jdz>
What is a "file descriptor"?
<|3b|>
it is an abstraction for (mostly) sequential IO
<jmercouris>
jdz: file descriptor is much easier for me to understand
<jdz>
Really? It's just an integer.
<jmercouris>
it just makes more sense to me
<|3b|>
jmercouris: well, FDs can be pretty much anything streams can... files, TTYs, memory maps, serial ports, etc
<shrdlu68>
CLHS glossary: "stream n. an object that can be used with an input or output function to identify an appropriate source or sink of characters or bytes for that operation."
<shka_>
jmercouris: stream is defined by well, stream operations
<jmercouris>
a stream is an abstract object that reads or writes between two locations
<jmercouris>
that's what I'm getting from this conversation
<shka_>
jmercouris: exactly!
<jmercouris>
and you just send it data and it does the reading or writing
<jmercouris>
and you can also query it for data if you are doing the reading
<python476>
jmercouris: too much cpp background ?
<jdz>
jmercouris: I brought it up because in CL a stream is basically the same thing a file descriptor is in Unix: an opaque object that can be used with some functions (call it a protocol, or an API).
<|3b|>
it is the CL abstraction for input and output
<python476>
incf jdz
<jmercouris>
ok, that simplifies a lot
<jmercouris>
thanks everyone
<|3b|>
IO to/from user in a terminal, i/o to/from files, i/o to/from sockets, pipes, etc
<jmercouris>
almost 2 years in and I finally understand this most basic concept :D
<|3b|>
:)
<jmercouris>
I guess I just never had to use them that much, but now it is much clearer
<shka_>
cool
<|3b|>
well, you probably used them a lot and just didn't notice :)
<shka_>
stream is basicly interface concept
<shka_>
and that's it
<_death>
I would say not all sockets fit the stream abstraction.. tcp, yes, because it's a stream oriented protocol.. udp, no, because it's datagram oriented
<|3b|>
*standard-output*, *standard-input*, *terminal-io*, *debug-io* etc are all streams
<python476>
jmercouris: heh, I hate when I click on simple shit years after the fact, but at the same time, you're now free to roll
<|3b|>
_death: yeah, the FD abstraction fails similarly
<python476>
are you on Next ?
<jmercouris>
python476: in which sense? I am the creator of Next, yes
<|3b|>
you /can/ call read/write on them, but stuff won't work right :)
<|3b|>
UDP sockets, lots of special devices, etc
<python476>
jmercouris: I was just curious if your question were related to that project
<jmercouris>
python476: yes and no
<|3b|>
where you need to send/recv, or ioctl to get things right
<python476>
there was a new paper from a team that decided to make an OS out of the 'everything is an object' out of curiosity
<python476>
ioctl is sad
<jmercouris>
my question is related to a webserver, I'll be redesigning the static site to be dynamic soon
<python476>
but anyway, linux says its bazaar
<python476>
jmercouris: ok
<|3b|>
ioctl is a result of "everything is a file, whether file ops make sense for it or not" :/
<python476>
yeah, so many things ends up being r/w annnnd a few other things bolted aside :D
<python476>
but the unixy/file myth still prevail
dented42 has joined #lisp
<jmercouris>
wow, still getting heap exhaustion errors on the server
<jmercouris>
WHAT!
<shka_>
jmercouris: use profiler :-)
anewuser has joined #lisp
<shka_>
jmercouris: you will have to load shorter file because if you out of memory before getting the result, you are not getting the result
<jmercouris>
shka_: so it is strange, I can load much larger files now
<jmercouris>
I did manage to load the 1mb file
<shka_>
hmmm
<shka_>
mysterious
<jmercouris>
now I think it is just maybe web-server issues, or my internet connection, because locally I can load massive files
<jmercouris>
so it shouldn't be anything really wrong on the lisp side of things
<jmercouris>
locally I did a 15mb file for example, no problem
<jmercouris>
Okay seems to be able to load large files now, not sure what changed
<jmercouris>
I did change the control-stack-size, not sure why that should matter as well
<jmercouris>
maybe the FCGI handler is running in some thread and who knows what it does
fikka has quit [Ping timeout: 245 seconds]
orivej_ has joined #lisp
orivej has quit [Read error: Connection reset by peer]
dented42 has quit [Ping timeout: 252 seconds]
rumbler31 has joined #lisp
eminhi has joined #lisp
shifty has quit [Ping timeout: 272 seconds]
anewuser has quit [Quit: anewuser]
warweasle has joined #lisp
Bike has joined #lisp
jmercouris has quit [Remote host closed the connection]
LiamH has joined #lisp
rumbler31 has quit [Remote host closed the connection]
hjudt_ has joined #lisp
hjudt has quit [Ping timeout: 252 seconds]
igemnace has quit [Quit: WeeChat 2.2]
sword` has quit [Read error: Connection reset by peer]
Lycurgus has joined #lisp
sword` has joined #lisp
FreeBirdLjj has joined #lisp
nokdoot has joined #lisp
solyd has joined #lisp
FreeBirdLjj has quit [Ping timeout: 276 seconds]
Essadon has joined #lisp
pfdietz has joined #lisp
dented42 has joined #lisp
eminhi has quit [Quit: leaving]
groovy2shoes has joined #lisp
eminhi has joined #lisp
eminhi has quit [Client Quit]
fikka has joined #lisp
Guest6910 has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 246 seconds]
elfmacs has quit [Ping timeout: 252 seconds]
asarch has joined #lisp
xvx has joined #lisp
heisig has quit [Quit: Leaving]
r0sebush has joined #lisp
<r0sebush>
hello
beach has quit [Ping timeout: 252 seconds]
nowhere_man has joined #lisp
<Lycurgus>
yello
beach has joined #lisp
varjag has quit [Ping timeout: 246 seconds]
dented42 has quit [Ping timeout: 252 seconds]
rpg has quit [Ping timeout: 272 seconds]
asymptotically has quit [Ping timeout: 256 seconds]
kushal has quit [Ping timeout: 256 seconds]
Inline has quit [Disconnected by services]
robotoad has joined #lisp
shrdlu68 has quit [Ping timeout: 252 seconds]
froggey has quit [Remote host closed the connection]
Copenhagen_Bram has quit [Remote host closed the connection]
Copenhagen_Bram has joined #lisp
dueyfinster has joined #lisp
anamorphic has quit [Quit: anamorphic]
hhdave has quit [Ping timeout: 245 seconds]
spm_ has joined #lisp
anamorphic has joined #lisp
<spm_>
Is there an existing mechanism to bind all slots of an object to a local var matching the name of the slot? Thinking along the lines of (with-all-slots (obj) ...) which I know doesn't exist in the spec. I see how I do it via macro, but don't want to recreate the wheel if there is already something there.
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<spm_>
^ I should say "local vars matching the slot names"
dueyfinster has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
<Xach>
spm_: no. i don't think something like that is a great idea. it leads to code that uses variables that are not visibly bound.
<LdBeth>
Good morning
<spm_>
Xach: so better to list each one specifically? I'm working on some bridge code from lisp to java, and it means I'm translating a lot of fields so was trying to shortcut. I can see the argument for doing it explicitly, but am lazy.
<Xach>
spm_: maybe there's some other more palatable abstraction level that can be found
<spm_>
sjl: Thanks. That's certainly a better approach than my initial thought.
<pfdietz>
spm_: how could one do that, even in principle? Different objects with different slots could be there at run time, and there's no way to know at compile time what the slots will be.
<spm_>
pfdietz: I was thinking of doing this inside the specific translation method for each distinct type I have to translate. That means I have a priori knowledge of what I'm translating into and therefore was looking to shortcut the binding boilerplate.
dented42 has joined #lisp
<pfdietz>
One you have the list of slots, you can easily (in a macro) produce the with-slots form. To get the list of slots from the class, that's something MOP lets you do.
<spm_>
pfdietz: Yes, that's exactly what I was thinking of doing, but thought it might be something that already existed and didn't want to recreate if it did.
<spm_>
Xach makes a good point that it has the potential to inject non-visible bindings which might not be such a good thing.
<spm_>
I think I'm just going to bite the bullet and explicitly list the slots for now.
<spm_>
Appreciate all the good input!
rpg has joined #lisp
anamorphic has quit [Quit: anamorphic]
anamorphic has joined #lisp
<ThJ>
i've been programming for 26 years. when i switched from pascal to c, i had an epiphany, because it was so powerful. when i learned the new functional syntax in ES6, i had a small epiphany, because that was powerful. just saw this little library and my brain went "BOOF!": https://github.com/fukamachi/sxql
<ThJ>
i'm new to lisp and i'm exploring what it can do
<Xach>
ThJ: fun!
<ThJ>
that's like JSX for SQL... and unlike JSX, you can do it to *any* language. you're not just stuck with what the language happens to offer
<ThJ>
it's like the other languages are just giving you slices of lisp, but the whole pie is available if you dare to explore it
<shka_>
heh
<shka_>
funny
<shka_>
today i showed cl-who to a colleague of mine
<shka_>
and he said "Oh now I see why lisp is so cool"
<shka_>
and I was like "WTF bro, this is trivial in lisp"
<pjb>
ThJ: what's more powerful in C than in Pascal? I never felt that!Q
dueyfinster has joined #lisp
themsay has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
themsay has joined #lisp
<ThJ>
pjb: well, my personal experience was that C had a far more expressive syntax, and felt far more permissive of bit-banging, and shit, here's direct access to the OS API instead of abstractions/wrappers.
<ThJ>
note that the pascal i knew was turbo pascal from the early 1990s.
<ThJ>
i know that things have changed a lot in the pascal world since then.
shrdlu68 has joined #lisp
<ThJ>
pascal had pointers, but they weren't such a central theme in the language, so they felt slightly mysterious to me.
<pjb>
ThJ: even at that time, Pascal was more powerful, always has been. Several OSes as or more avanced than unix were written in Pascal, including Sol, a unix-like one, pUCSD, MacOS, etc.
<ThJ>
i was aware of macos being written mostly in pascal.
<shka_>
ThJ: original macos
<ThJ>
yeah
<ThJ>
i recall seeing old API docs that had pascal data structures in it.
<shka_>
anyway the main reason why C is useful is that mainstay systems expose C API
<shka_>
other then that it is pretty meh
<ThJ>
i can't agree with that.
<shka_>
you don't have to
<pjb>
There are too many pitfalls in C, too many implementation and platform dependent behavior.
<ThJ>
pascal -> c definitely felt like a step up to me, because what i wanted at the time was a *lower* level language.
<pjb>
For example, can you list by heart the 27 operators precedence levels of C? When I worked with Pascal, I knew the syntax by heart, including all the operators precedence levels.
<ThJ>
i wanted less abstraction, not more, because that was educational to me.
<pjb>
Granted, but at that time, you had easy access to assembler, and processors of all kind, for the educational aspect. You didn't need C.
<pjb>
And still today, happily arm supplements intel, you can learn assembler.e
<ThJ>
i used assembly code as well, but C sat somewhere between.
<ThJ>
having "first-class citizen" access to the operating system APIs was definitely a big part of it, of course.
anamorphic has quit [Quit: anamorphic]
razzy has quit [Ping timeout: 272 seconds]
anamorphic has joined #lisp
<pjb>
ThJ: now, I must confess, that I felt the attraction for C too. The spirit coming from PL/1. But I was never entirely satisfied by it, I explored a lot of programming languages, including Modula-2, Eiffel, Ada, Modula-3. Modula-2 was my favorite for a long time. Until I found Common Lisp.
<ThJ>
but there was also stuff like the for-loop syntax, operators like += -= *= /= ++ --, etc.
<pfdietz>
Thj: Some cool things in lisp vs C: being able to load new (or redefined) functions into a running image. Being able to do arbitrary computations in macros, eliminating the need for preprocessors like yacc. Exception handling that doesn't necessarily unwind the stack before invoking handlers. An OO system that dynamically dispatches on all arguments, not just (as in C++ or Java) the first one. Being able to fully control th
<pfdietz>
syntax of the language, if needed.
<ThJ>
but do keep in mind that i was 12 at the time.
<ThJ>
C definitely felt like a world opening up to me, and nothing can take that feeling away from me.
<ThJ>
i don't like it so much these days
<pjb>
++
<pjb>
Also, there's a difference writing a little program in C, and writing a big application, with error handling, safety, etc.
<pjb>
And the worst of all: the programming style of the generic C programmer is horrible.
<aeth>
You can avoid precedence issue with a code style that mandates parentheses and spaces. ((x * y) / 3) + 4
<pjb>
Of course. This is how I write C :-)
dueyfinster has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
<aeth>
Of course, at that point you're one paren set away from an infix Lisp
<aeth>
Even using s-expressions! Just eval from the function position in the middle instead of the start
<aeth>
Limited length or repetition of +, though
<ThJ>
i'm not saying that C is greater than Lisp, but i've always been a right-tool-for-the-job person, and my interest at the time of learning C was stuff like demo coding, graphics, poking straight into unprotected memory from MS-DOS, talking to a NES controller's shift register via the parallel port, etc...
edgar-rft has joined #lisp
<ThJ>
and, well, when you look for documentation on how to do those things, here comes the C examples and C libraries.
<pfdietz>
Even lisp has the issue of how operations are ordered in multi-fix expressions. Is (+ x y z) (+ (+ x y) z) or (+ x (+ y z))? Either is allowed, as are commutative rearrangements.
<aeth>
Graphics are totally doable in CL because the performance intensive stuff is mostly in shaders these days
<LdBeth>
Does anyone know how to declare arglist in CCL
<ThJ>
aeth: yeah, but this was in the mid-1990s and i was writing my own triangle filling code, haha...
<aeth>
ah
<ThJ>
and the sort of developer i would've looked up to would be john carmack and linus torvalds.
<LdBeth>
Seems (setf ccl:arglist) works but I'd like to know how to declare it inside function binding
dented42 has quit [Ping timeout: 244 seconds]
<ThJ>
people on irc were telling me "you should quit using pascal and switch to C"
<ThJ>
muliple people
orivej has quit [Ping timeout: 244 seconds]
<ThJ>
and i resisted, because "the syntax is weird" and other reasons.
<ThJ>
pascal code looked more readable to me.
<ThJ>
but as i explored C, i found that i liked the cleverness you could exhibit.
<ThJ>
a ? b : c instead of if-then-else for an assignment, and that kind of stuff.
m3tti has joined #lisp
<aeth>
C is for memory constrained environments, like 1990s PCs
<ThJ>
programmers like to feel smart, and C made me feel smarter than pascal.
<ThJ>
well, that's what i was on.
<aeth>
C programs will start quite low in memory usage until the memory leaks raise it
<ThJ>
well, yeah. i was always good at containing memory leaks, though... a job made easier by the fact that i wasn't writing production code at the time, just small projects... for a larger multi-developer codebase, it's harder.
<ThJ>
it's always easy to keep everything "perfect" when it's just you.
<_death>
pfdietz: I think this can be a (theoretical) advantage.. you could choose an order that minimizes error, or allocations..
<pfdietz>
People eventually wrote garbage collectors for C.
<ThJ>
oh yes, there's one that i know about but forgot the name of...
<ThJ>
never used it, though.
<pfdietz>
aeth: C was for memory constrained environments, like the PDP-11/45. :)
anamorphic has quit [Quit: anamorphic]
sauvin is now known as Sauvin
<ThJ>
there was this whole culture surrounding the world i inhabited at the time where you wanted small and fast things and you used bit shifts instead of multiplies, and fixed-point integer instead of floats...
<ThJ>
and lookup tables
<_death>
ThJ: I spent very little time with Pascal as well.. but it did have SWAG (and BASIC had ABC).. which were cool
<ThJ>
now that even an arm device has the sort of power that was once reserved for powerful workstations, all of that stuff isn't so critical anymore.
m3tti has quit [Ping timeout: 244 seconds]
<ThJ>
except perhaps for special-domain applications like if you're optimising a H.264 decoder.
<ThJ>
_death: my progression was GW-BASIC, QBASIC, Turbo Pascal, Delphi, C (DJGPP), Java, C++, and then my career started, so i picked up PHP, classic JavaScript and finally stuff like ES6, ESnext...
<ThJ>
parallel to this, i was learning linux, opengl, electronics and embedded programming, etc.
Selwyn has quit [Ping timeout: 268 seconds]
<ThJ>
and i guess all i wanted when i drew the comparison to pascal->C is to express the joy of having a world open up to me again.
<ThJ>
...with lisp.
<_death>
ThJ: well, I started with an atari, and LOGO actually, then its basic.. with DOS similar start to yours.. basica/gwbasic/qbasic/quickbasic etc. but x86 assembly too.. then a long chain of C and C++ implementations.. then Windows came... too long and uninteresting to elaborate the history ;)
<ThJ>
oh yes, i forgot about the x86 assembloy.
<ThJ>
*assembly
pent has joined #lisp
<ThJ>
i did a fair bit of inline assembly in pascal.
<ThJ>
and toyed around with stuff like placing asm programs in the 512-byte boot sector of a floppy drive.
cage_ has quit [Quit: Leaving]
<_death>
but CL has been the obsession for more than a decade so :)
<pjb>
Both C and Pascal (and Python) share the defect of having statements. vs. only expressions, like in CL or Ruby.
<pjb>
Having only expressions in the syntax of a language is the first thing that outclasses it.
solyd has joined #lisp
asymptotically has joined #lisp
<pfdietz>
Pascal's big problem, at the start, was treating each program as a closed world. No external linkage. Fine for a teaching language, not so fine for something used for real things.
sjl has quit [Ping timeout: 245 seconds]
solyd has quit [Quit: solyd]
themsay has quit [Ping timeout: 252 seconds]
jmarciano has joined #lisp
<pjb>
pfdietz: that's also was wrong from the start.
<pjb>
units were introduced very fast, and even before that, that is, at the time you programmed pascal using punched cards, you could write in Pascal a pre-processor similar to the C preprocessor to implement an $include directive to use libraries.
<rpg>
I've been doing a lot of Python programming lately (machine learning stuff). One thing that I have found helpful is the type annotations and associated checkers, which help me avoid stupid mistakes. Is there anyone working on gradual, optional typing for CL and associated checkers? Drew McDermott made a typed dialect, but it's wrapped in very idiosyncratic style (and it's own system definition framework).
anamorphic has joined #lisp
solyd has joined #lisp
<pfdietz>
There's nothing stopping any lisp implementation from propagating type declarations and checking them at compile time, when it can. Do you want it to do something more than that?
shrdlu68 has quit [Ping timeout: 268 seconds]
solyd has quit [Remote host closed the connection]
nowhere_man has joined #lisp
<rpg>
pfdietz: That's basically what I want. It seems like SBCL does a bunch of what I want (but I'm not good at using it to do so).
phoe has joined #lisp
<phoe>
Hey hi hello
<phoe>
MOP question: can I execute code whenever a subclass of a given class is defined?
<shka_>
phoe: yes
<rpg>
pfdietz: I really want to catch stupid mistakes earlier. I do enough things that are computationally expensive that it hurts to get a work-losing error. I noticed this very strongly working with python, whose debugger is not that good, making it harder to recover compute results when there's a failure.
<phoe>
shka_: What's the method to achieve that?
<pfdietz>
My suggestion is use strong testing instead of strong typing. If you have tests that cover the code you will find many errors that static type checking would have found, and you will also find other non-type bugs.
<shka_>
i will paste link in a second
sjl has joined #lisp
<pfdietz>
SBCL has a code coverage facility to check your test's coverage; there's also the old COVER package (which has some limitations but is portable.)
<rpg>
pfdietz: That doesn't scratch the same itch. Lots of testing entails writing lots more code, and it doesn't catch the stupid stuff like passing arguments in the wrong order, etc.
<phoe>
rpg: you could try static typing your Lisp code using DECLARE TYPE everywhere.
<shka_>
phoe: anyway, first of you will have to ensure that both superclass and class are instances of your own metaclass
<rpg>
testing is great, but it's not a lint-style tool.
<phoe>
shka_: no problem, I can do that
<shka_>
then there are multiple ways to go forward
<shka_>
i would suggest to start with shared-initialize on instances of your metaclass
<phoe>
oooh - correct
<pfdietz>
rpg: short of formal verification, there's no way to avoid testing if you want any piece of nontrivial code to work.
<shka_>
there you should be able to obtain superclasses list of your instance
<rpg>
phoe: I'm not sure how far that gets me, but I could try. I don't understand SBCL's type propagation well enough to understand what errors it will and won't find (e.g., will it propagate and reason about disjunctive types?)
<shka_>
phoe: let me check my source code, i had something like that i think
<phoe>
rpg: what kind of disjunctive types? you mean AND/OR?
<phoe>
shka_: you'
<phoe>
re right though, SHARED-INITIALIZE on a metaclass will work
<rpg>
pfdietz: I get it, but testing and static analysis are really just two different tools. It's kind of like me saying I want a saw, and you saying you've got a drill. They are both useful, but they aren't the same thing.
dented42 has joined #lisp
<shka_>
phoe: yeah, i had something like this, but i was noob back then and i used initialize-instance
<rpg>
phoe: I mean for, e.g. optional arguments (type x (or null integer))
<shka_>
don't be like me, be smart
<pfdietz>
rpg: it should, although there are some bugs with CONS types and some hairy situations involving SATISFIES types. I've been annoying Stassats with random tests involving that stuff.
<rpg>
pfdietz: Yes, SATISFIES is a bugaboo.
<pfdietz>
Propagation will give up on hairy satisfies types. However, static type checking won't work with those either.
<trittweiler>
rpg: SBCL and declaim the ftype of your "API" related functions (i.e. the exported ones) will go a long way. Offending call sites will be highlighted in Slime.
<rpg>
pfdietz: Sure: *nothing* will work on general SATISFIES types.
<rpg>
trittweiler: Thanks; I'll do some experimenting.
<trittweiler>
that said, I am not sure how well that actually works with CLOS-heavy code though, which is very runtime-y
<rpg>
I worry a little about moving this code to other implementations, where type declarations are interpreted as assertions, rather than claims that can be falsified.
<pfdietz>
So, you're complaining that there exist implementations that don't do compile time type checking?
<trittweiler>
but... wouldn't moving the other way around be more dangerous?
<rpg>
I'd just like to catch the low-hanging fruit, like functions that demand a pathname instead of a pathname-designator, or a string pathname designator instead of a pathname, etc.
HighMemoryDaemon has joined #lisp
<shka_>
rpg: easy
makomo has joined #lisp
<shka_>
eh, or not
<shka_>
rpg: sorry, i don't think i understand
<shka_>
ignore the above
<rpg>
pfdietz: That's one way of thinking about my complaint. An alternative would be to say that I'd like toolage that supports typing for me (i.e. haskell style typing) in addition to typing for the compiler (C-style typing). CL typing is advertised as the latter, not the former. I like it that SBCL (mis)uses it for the former, but that's not what it was designed for.
<trittweiler>
I find that a bold claim. You mean historically declarations were intended to make the implementation omit run-time checks, but declaration-as-assertions add a run-time check in default optimization settings? (Note that while it adds a type-check it uses that information to omit type-checks further down the execution stack, so it seems very much in line and in fact more lisp-y because it's safe by default.)
nowhere_man has quit [Ping timeout: 250 seconds]
<rpg>
trittweiler: Yes, I think it's clear from the discussion that the type declarations were intended to support compiler optimizations, since the spec clearly says that implementations are allowed to trust them and do thins that would be unsafe when the declarations are erroneous.
orivej has joined #lisp
<pfdietz>
But the compiler is also allowed to recognize their failure and generate errors. So while a CL implementation doesn't have to use declarations to do good type checking, it's certainly allowed to.
<rpg>
pfdietz: Yes, that's quite correct.
<trittweiler>
If you have a code base that uses declarations a lot in internal functions, rather than just at a high-level ("API functions" above), yes that may result in a lot of unnecessary type-checks and a slow-down.
<rpg>
It's clear that some aspects of the type system (e.g., SATISFIES) were intended to support run-time type checks, instead of either optimization or static analysis.
<trittweiler>
So I'm with you that the implementation philosophy of declarations has an impact on how a code base can look like, and it may not be trivial to just switch
<rpg>
trittweiler: Or the compiler could trust those declarations and generate very efficient code that would have the weakness of blowing up in odd ways if I was wrong about the declarations.
kushal has quit [Ping timeout: 256 seconds]
wheelsucker has joined #lisp
kushal has joined #lisp
<Bike>
if the type system is expected to at least know that (subtypep (satisfies x) (satisfies x)) => T, subtype on satisfies types can be used as a SAT solver. just a fun fact there
<rpg>
Note that this isn't meant to be a complaint about CL -- the CL spec antedates the kind of expressive compile time type checking that (I think) first really showed up with ML.
Selwyn has joined #lisp
Copenhagen_Bram has quit [Ping timeout: 272 seconds]
<shka_>
i think that beach had idea regarding this
<shka_>
trick was to have multiple entry points for functions?
r0sebush has left #lisp [#lisp]
<shka_>
so the same function depending on call would either check or not check arguments
<rpg>
shka_: E.g., if the calling point can assure that the typing is correct, you can jump into the function, otherwise you need to check the arguments before doing so?
<rpg>
s/check/check and possibly coerce/
<shka_>
something like that from what i understood
<phoe>
yep - more or less (defun foo (a) (check-argument a) (%foo a)) (defun %foo (a) ...)
<python476>
peeps, what are favorite libs of yours ?
Copenhagen_Bram has joined #lisp
<phoe>
except FOO and %FOO are not two different functions but rather two entry points to a single function
<python476>
just out of curiosity, discovery
<phoe>
python476: alexandria
<python476>
funny it was jmercouris that was trying to use it earler IIRC
<python476>
phoe: it's a various utils libs right ?
<gendl>
XachX: so, if we keep the weird reader conditionals as is (handled by zacl currently), but add :zacl to the :depends-on in aserve.asd, can it still not exist in Quicklisp?
<phoe>
shka_: I'm most likely overthinking this
<White_Flame>
hmm, the page on deftype sayd "If a deftype form appears as a top level form, ..." implying that it probably can be non-toplevel as well
<shka_>
phoe: if i understand correctly, you want DECLARE?
<phoe>
White_Flame: I don't want to create the type in the global namespace
<gendl>
that would allow aserve to load standalone, without the need to package zacl with it.
<Josh_2>
phoe: maybe a macro that takes a let form and a list of types in order?
<phoe>
shka_: nope, I want a runtime check
<jackdaniel>
White_Flame: (defun foo () (deftype foo '(or cons number)) is deftype being non-toplevel
<White_Flame>
phoe: I'm saying that if it's not toplevel, it might not be global
<shka_>
phoe: check-type in that case
<phoe>
White_Flame: I don't think so
vlatkoB has quit [Remote host closed the connection]
<White_Flame>
but yeah, it probably does only affect the global namespace; there's nowhere else for it to go
<phoe>
even non-toplevel DEFUNs embed functions in the global namespace
<shka_>
phoe: ok, so why not check-type?
<White_Flame>
one nasty way you could accomplish this via macro body is to gensym the typename in the local body
<jackdaniel>
phoe: second best option is having a type called: lextype
ealfonso has quit [Ping timeout: 252 seconds]
<jackdaniel>
which has 'satisfies' predicate
<jackdaniel>
then typelet could affect result of evaluating this function
<jackdaniel>
then it would be (typelet ((snacks '(or cons number))) (typep bar '(lextype snacks 14)))
<jackdaniel>
or withou 14 of course
meepdeew has quit [Remote host closed the connection]
<phoe>
jackdaniel: gotcha - thanks
<shka_>
heh, i don't understand anything :D
<shka_>
good night
<gendl>
XachX: the only alternative I'm seeing is just to "punt" on ever trying to get to an identical version between franzinc and Quicklisp, and resign myself to maintaining a fork (which hopefully will end up tracking original aserve better than the first portableaserve did...)
* _death
feels eval
razzy has joined #lisp
<rpg>
gendl, XachX: #+(and allegro (version= 10 1)) 'foo gives FOO for me at an Allegro 10.1 REPL
<gendl>
these things don't seem to work as expected in the toplevel (at least not in slime repl)
<gendl>
in my experience i have to try it in a compiled function or at a simple command shell.
<rpg>
gendl: In SLIME repl that gave me BAR, as expected.
<gendl>
rpg: right, but try a version which should skip the next form
<gendl>
like #+(and allegro (version= 9))
<gendl>
see if that returns no values as expected.
<Josh_2>
phoe: if you write something like typelet please show me :D
<rpg>
gendl: But that is just no input to the REPL. It shouldn't echo anything to the REPL>
<phoe>
Josh_2: I won't, I can't portably write such at hing
<phoe>
a thing
<Bike>
typelet would be hard since there's nothing to turn a type specifier into a type (or types as objects at all)
<rpg>
SLIME gives me ; No value
<gendl>
oh yeah - that's working for me too.
<rpg>
gendl: I think you should be ok with this.
<gendl>
So apparently adding the (and allegro ..) at the front of all these things could be a solution
<Josh_2>
aww
<phoe>
types aren't first class, it seems
<gendl>
but i'll have to find something other than allegro which is unique to allegro, because it seems that zacl does make #+allegro be true while it's loading aserve...
<jackdaniel>
phoe: you are very liberal with using terms right now. you claim, that things which can't be defined lexically are not first class objects?
<rpg>
gendl: oh! I didn't get it. Someone *else* pushes :allegro onto *features*? Yuck!
<Bike>
types aren't first class objects because they aren't objects
<Bike>
it's like if you could mess with class names but not classes
<Bike>
nothing to do with lexicalocity
<rpg>
gendl: Putting on my Dr. Evil hat, I would suggest lexically binding *FEATURES* at some point so that :zacl can do whatever it does.
<gendl>
rpg: I think that's what zacl is doing now -- lexically binding *features* so it does have :allegro on it while processing aserve.
<gendl>
It looks like I could use :franz-inc
<gendl>
but it's getting mighty convoluted. This kind of thing is exactly what Xach has been complaining about. And why he's having second thoughts on allowing this current aserve into Quicklisp unless we purge the weird reader conditionals.
<gendl>
... in which case Franz is never going to accept a pull request, and we're stuck maintaining yet another fork into eternity...
<gendl>
I can't in good faith ask Franz to accept any changes which mess with their reader conditionals too much - they are going to great lengths to support their customers all the way back to Allegro 6, and this is how they do that.
shka_ has quit [Ping timeout: 246 seconds]
<rpg>
gendl: OK, if I understand properly, what you're doing is pretending you have the latest allegro when you are running on a non-allegro platform, right?
<gendl>
another thing I could try is just put (and (not zacl) ...) in front of them all...
<rpg>
gendl: That one sounds like a good fix.
<gendl>
yes, that's pretty much right.
<gendl>
rpg: you're familiar with the old portableaserve? It has an :acl-compat layer
<rpg>
gendl: Yes, I think I have at least one co-worker who is still using it.
<gendl>
which makes it look like (some version of) Allegro. then portable aserve gets compile/loaded on top of that.
<gendl>
well the old portableallegroserve has atrophied such that it's now based on an ancient AllegroServe version
<White_Flame>
phoe: what do you think about gensym-named types? as long as they're static, ie not reinstantiating a new type every execution, that would contain a completely private deftype within a lexical scope without leaking
<gendl>
so we decided to make a clean break and make a new compatibility layer, hopefully much thinner than :acl-compat, because it mostly just uses existing Quicklisp libraries like bordeaux-threads etc (the old :acl-compat has its own custom hacks for a lot of things because it predates Quicklisp by a long shot)
<gendl>
the new compatibility layer is :zacl, it lets us run up-to-date Allegroserve, but still with a few modifications
<rpg>
gendl: Oh, I see. Yes, it seems like checking for ZACL would be un-objectionable to Franz.
<gendl>
we're hoping those few modifications will be accepted back by Franz, so we don't have to maintain a fork, but that remains to be seen.
<gendl>
I hope it'll be un-objectionable to Xach as well - still having the weird conditionals after the (and (not zacl) ...)
<gendl>
will the reader stop reading when it sees the (not zacl) ?
<gendl>
or does it still have to read the rest of the thing?
<gendl>
I have to get my logic right for #+ vs #- !
sjl has joined #lisp
<rpg>
gendl: I don't *know*, but I would guess that an implementation would be using the underlying lisp, so if you have (and (not zacl) ...) it would stop evaluating. One couldn't guarantee that it would stop reading the #+ condition, but isn't it benign to read it, as long as you don't interpret it?
<gendl>
I suppose.
<Xach>
zacl's design is along the lines of "make allegroserve code load and run even in the face of portability-hostile (or portability-apathetic) allegroserve code". I think it would be good in a global sense to encourage portability-friendly code in allegroserve, but in the local sense (make gendl work) I don't know what makes the most sense.
<Xach>
oh, another design is "no hack too gross to make it work"
<Bike>
the eclector reader would try to validate feature expressions before executing them and would signal an error on version< conditions in asdf or somewhere
<Bike>
i think that got loosened up, though
<Xach>
I think it would be much better globally to ignore allegroserve and portable allegroserve, as they are not really good examples of anything worth emulating as webservers or web clients.
<gendl>
Xach: the old portableallegroserve is already in Quicklisp, so that horse has already kind of left the barn.
<Xach>
gendl: Sure. I think it's a mistake to use it. But I don't pass judgement on what people ask for in quicklisp.
<Xach>
Does it build? It goes in. (Almost always, anyway.)
<rpg>
We haven't found any web server library that seemed so much better than allegroserve that it was worth the pain of rewriting our servers...
<Xach>
rpg: is it important for your stuff to run on sbcl and clozure cl? do you use portable allegorserve for that?
<gendl>
It's important for our stuff. We want folks to be able to play around with Gendl on the platform of their convenience. If they want a commercial and commercially supported version, we'll sell them Genworks GDL running on Allegro CL.
<gendl>
And we certainly don't want to be selling stuff on Allegro CL and not using the best webserver for Allegro CL, which is aserve.
<rpg>
Xach: portable allegroserve. This stuff is all pretty old.
<rpg>
Some of it is even old enough to use XMLRPC (which we need to get rid of).
<Xach>
rpg: parfait
<gendl>
rpg: would you consider using up-to-date Allegroserve (with zacl) if it's available in quickllisp?
<rpg>
gendl: Yes, I think so. At least I would talk to my colleague who uses it for his web-interface to graph database system.
<gendl>
Thanks.
<gendl>
Anyway, I'm going to make some light-as-possible changes to current AllegroServe - certainly this "will build" on CCL and SBCL - and submit a Quicklisp Project request -- and just see what happens.
<gendl>
I'm hearing a bit of mixed messages from Xach, but the bottom line seems to be "if it builds, it's in..." so that's what I'm going with.
<Xach>
I wish there was a way forward that didn't involve a brutish hack like zacl and didn't break portable allegroserve for anyone using it.
<Xach>
I don't find offers to fix what's broken for individual projects all that encouraging - I feel like there could be silent users with private code who will be affected in ways that aren't seen.
<Xach>
Sometimes that's just the best that can be done under the constraints, I guess.
<gendl>
Well, a way forward could be to leave old portableaserve alone, call the new one zaserve, modify the code to get rid of <= >= conditionals, to eliminate the need for the most brutish of the hacks in zacl.
<gendl>
the only downside to that being that we now have a new fork to maintain, which runs the risk of atrophying vis-a-vis franzinc aserve, just like original portableaserve did.
<gendl>
But if that approach is what will serve the needs of the many, then I suppose I'm willing to go that way.
<gendl>
I'll rescind the merge request I just logged against the old portableallegroserve.
<gendl>
and strip the reader ugliness out of zacl
<gendl>
and strip the conditionals out of what will now be called zaserve (which will :depend-on (:zacl) )
dented42 has joined #lisp
<gendl>
then i'll do one-way merges from franzinc aserve into zaserve, indefinitely.
<gendl>
All so support free people using our stuff, some tiny percentage of which might become paying customers some day... :|
anamorphic has quit [Quit: anamorphic]
<scymtym>
Bike: the change in eclector was to check feature expression incrementally as it evaluates (by default anyway, since clients can customize) so i wouldn't choke on e.g. #+(and allgero (version> …)) when running in e.g. SBCL
<Bike>
yeah that's what's at issue here
python476 has quit [Ping timeout: 252 seconds]
varjag has joined #lisp
<jcowan>
does everybody interested in CL types know about Henry Baker's paper on efficient SUBTYPEP implementation (excluding SATISFIES)?
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<Bike>
yes.
<Bike>
that's where i learned the sat bit, in fact
anamorphic has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
<gendl>
it turns out franzinc aserve already has a bunch of stuff like #+(and allegro version>= 6 3)
razzy has quit [Read error: Connection reset by peer]
<gendl>
and that works on both CCL and SBCL without any special reader hacks.
relaxed has quit [Quit: ⠠⠵]
<gendl>
So now i'm reverting to going that route. And we'll keep the request to change names on old allegroserve for now.
wheelsucker has quit [Quit: ERC (IRC client for Emacs 26.1)]
<gendl>
That code hasn't been maintained in years. If some silent user depends on :aserve from quicklisp, they'll get a clear message from the new one: "This aserve isn't supported on <your-implementation>. The old one has been renamed :paserve. " It's not like they're going to be left completely in the dark.
<gendl>
they make a one-character change to their :depends-on and they'll be on their way.
wheelsucker has joined #lisp
isBEKaml has joined #lisp
m3tti has joined #lisp
m3tti has quit [Remote host closed the connection]
m3tti has joined #lisp
m3tti has quit [Remote host closed the connection]
<slightlycyborg>
Is there a way to redefine *standard-out* to be a stream that writes to 2 streams, one of which was the original *standard-out*
<slightlycyborg>
Is there a permenant reference to *standard-output*
<phoe>
slightlycyborg: nope, you need to make it yourself if you want to keep the original value of the stream while mutating the global binding for *STANDARD-OUTPUT*.
<phoe>
but, you could perhaps retrieve it by using BROADCAST-STREAM-STREAMS
<Bike>
just keep it in a variable or something.
<slightlycyborg>
Ok. That makes me think of the time I traded away my Pikachu in pokemen yellow. Lose a handle on that and an entire game mechanic (pikachu following you in RPG explore mode) is lost forever
<Bike>
you should treat your friends, and initial bindings, better
<slightlycyborg>
Haha. Yes :). Thanks
razzy has joined #lisp
Selwyn has quit [Ping timeout: 252 seconds]
slyrus2 has joined #lisp
shifty has joined #lisp
dented42 has quit [Ping timeout: 252 seconds]
slyrus has quit [Ping timeout: 272 seconds]
slyrus1 is now known as slyrus
slyrus2 is now known as slyrus1
Guest13389 has quit [Ping timeout: 276 seconds]
ski has quit [Ping timeout: 252 seconds]
olopierpa has joined #lisp
Ukari has joined #lisp
Roy_Fokker has joined #lisp
<anamorphic>
In my slime backtrace, I get " 0: ("bogus stack frame")" for the bottom most frame. Any ideas why I get a bogus stack frame? (using SBCL)
Guest13389 has joined #lisp
quazimodo has quit [Ping timeout: 252 seconds]
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<oni-on-ion>
ive seen it before myself.. perhaps it is placeholder ?
charh has quit [Quit: zZzzzZZ]
nly has quit [Ping timeout: 252 seconds]
<gendl>
XachX: Thanks for the patience around all this aserve stuff, which I know doesn't suit your taste anyway.
<gendl>
I think I have a final (short term, at least) plan:
<gendl>
I'll open a Project request for my fork of current aserve, whose system name I'll rename to :zaserve, at least for now.
<gendl>
So it won't break anything for anyone depending on the old :aserve.
<gendl>
Of course I'll update Gendl to depend on zaserve instead of aserve.
rpg has joined #lisp
<gendl>
I'm afraid I'm not going to be able to squash all the = and >= conditionals -- they're working as-is, with zacl's (admitedly ugly, but localized) reader table tricks -- and there's too much logic around them (which actually works, with the reader tricks), which i'm 99.9% sure I would break at some point if I mess about with them too much.
<gendl>
Even with the ADSF system name of :zaserve, Franz might still accept a merge -- because I don't think they use that ASDF file anyway (but that's a different issue from Quicklisp, so no need to dwell on it here).
<anamorphic>
Is there a defacto standard for docstring -> doc generation? Or even a naming practice like `'foo in Emacs?
<Shinmera>
no
<Shinmera>
Some people seem to like what I do, so have a look at Staple.
<dim>
is there an easy way in loop collect to avoid nils? I can always wrap (remove nil (loop ... collect ...)) but I'd like to avoid it if possible...
<Shinmera>
dim: for value = .. when value collect value
<pjb>
^
<dim>
thx!
frodef has quit [Ping timeout: 252 seconds]
drewc has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
Arcaelyx has joined #lisp
jmercouris has joined #lisp
dented42 has joined #lisp
slyrus has quit [Quit: slyrus]
slyrus1 is now known as slyrus
slyrus1 has joined #lisp
slyrus1 has quit [Client Quit]
slyrus1 has joined #lisp
jmercouris has quit [Remote host closed the connection]
<anamorphic>
Thanks, I will check Staples out later. Is it a bit like JavaDoc?
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
Bike has quit [Ping timeout: 256 seconds]
<Shinmera>
Depends on what you feel the important features of JavaDoc are.
mange has joined #lisp
warweasle has joined #lisp
<dim>
is it possible to collect and append in a single loop:
<dim>
?
<anamorphic>
@Shinmera well basically, a clear way to refer to params, return values, and maybe linking between things.
<Shinmera>
you can collect multiple times
<Shinmera>
and you can collect and append to separate variables
<dim>
mmm, ok, thanks
LiamH has quit [Quit: Leaving.]
<Shinmera>
anamorphic: Staple has a very simple standard markup it scans for in docstrings for xrefs. You can extend it to handle markup of your choice though
<anamorphic>
Cool. Sounds like that'll work
DataLinkDroid2 has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
are there any .wav parsers for CL?
<antoszka>
Shinmera: did you ever think of changing the „portacle” project name?
<Shinmera>
there's uiop:getenv that probably has the widest portability
jack_rabbit has joined #lisp
<russellw>
uiop?
<Ober>
external package.
<Shinmera>
part of asdf
<russellw>
okay thanks
sjl has quit [Ping timeout: 268 seconds]
nly has quit [Ping timeout: 272 seconds]
aeth has quit [Read error: Connection reset by peer]
aeth has joined #lisp
<aeth>
This is fun. Where in most languages I would resort to regular expressions to parse a line, I instead wrote a macro to iterate over a line separated by spaces, using #'position to provide start and end points on eitber side of the spaces.
nly has joined #lisp
fikka has joined #lisp
Jesin has quit [Quit: Leaving]
<jasom>
jcowan: the first screenshot is exactly what portacle looks like on startup; most of the text on the screen is comments, which is dim-gray in the default theme that portacle used
fikka has quit [Ping timeout: 245 seconds]
dented42 has joined #lisp
pjb has quit [Ping timeout: 252 seconds]
Essadon has quit [Quit: Qutting]
robotoad has quit [Quit: robotoad]
Ukari has quit [Remote host closed the connection]