freenode/#lisp - IRC Chatlog
Search
23:00:21
jcowan
_death: Google Translate says Boolescher Wert, which I assume is pronounced "buhlscher"
23:02:56
Bike
this paper uses algol notation, which i don't understand, in order to explain the Plankalkül notation i also don't understand. pretty nice
23:07:48
jcowan
so a perfect hybrid of English root pronounced Englishly and German affix pronounced Germanwise
23:10:54
aeth
Is there a CLobol Cobol-in-CL and if not, why did they miss the opportunity to use that name?
23:27:55
aeth
If we're going to go down that route we might as well shut everything down except for ##javascript
23:52:29
jcowan
I don't see any CL-to-JS that's even close to complete in "language features" as opposed to "library features"
23:55:01
aeth
You can't really have something that's both efficient and a conforming CL in JS because the languages are just too different.
23:58:42
jasom
the biggest one being that you can't just dynamically generate assembly and then call it (which most traditional lisps do)
23:58:49
Bike
i think t hey still haven't implemented exceptions and it looks like they've decided to go with C++ style ones, which I can tell you from experience are an enormous pain in the ass to reconcile with lisp nonlocal control flow.
0:17:49
no-defun-allowed
All I know of is cl-javascript, which might be a bit dead, and doesn't run as fast as the JITting implementations.
1:31:18
matzy_
i can set up the acceptor just fine, and even give it a document root, but i can't figure out how to hit even the simplest route
1:36:17
matzy_
should be super simple, a GET route at localhost:4444 (port i set it to in the acceptor), 127.0.0.1:4444/foo?a=Bob
1:38:08
no-defun-allowed
And did you start Hunchentoot with an instance of easy-routes:routes-acceptor?
1:38:46
matzy_
(defvar *my-acceptor* (make-instance 'easy-routes:easy-routes-acceptor :port 4444 :document-root #p"www/"))
1:40:44
matzy_
like i feel i'm just missing something here. i work with APIs written in (far less interesting) languages everyday
2:01:56
pjb
White_Flame: (loop for test in '( nil (f o o) ) collect (format nil "(~{~A~^ ~})" test)) #| --> ("()" "(f o o)") |#
6:25:11
flip214
jdz: thanks, sent an email yesterday, too.... in the meantime I opened https://github.com/quicklisp/quicklisp-projects/issues/1825 to use your repo instead ;)
7:02:53
jdz
flip214: Cool. I have not run into the OOM issue, so I'm glad I've fixed it unknowingly.
7:04:13
jdz
The main issue I was fixing was out-of-bounds array access, which was not very nice since there were (safety 0) declarations.
7:12:27
flip214
didn't spend any time looking for the reason.... allocating 2GB for a NIL sounds interesting
7:16:16
flip214
hmmm, replicating the (declare (string input) (optimize ... (safety 0))) isn't enough, I get a type error
7:21:08
flip214
aeth: that's why https://github.com/jdz/cl-base64/commit/f495809807a9311747c84fcb9520105ed663a971
7:31:32
aeth
to be fair, (safety 0) wouldn't be less safe than C if SBCL didn't also stop doing most static checking when (safety 0) not just runtime checking
7:33:01
aeth
Compare (safety 0) to (safety 1) here: (with-compilation-unit () (defun hi () "hi") (defun foo () (declare (optimize (safety 0))) (+ 0 (hi))))
7:35:05
aeth
beach: The C compiler will tell you it's bad, as will SBCL with (safety 1). Compiler, not runtime. Of course, this is not quite a good example because GENERIC-+ will still typecheck so it won't mess up at runtime. This is UB because it's a non-generic +: (with-compilation-unit () (defun hi () "hi") (defun foo () (declare (optimize (safety 0))) (+ 0 (the fixnum (hi)))))
7:35:39
aeth
THE, of course, is portably speaking dangerous, but only because it permits behavior like what's happening here with SBCL, but only when SBCL has (safety 0)
7:36:18
adlai
beach: thanks; so it's probably for a specific project? since specbot is in #sbcl too, there's even a usual suspect :)
7:37:11
aeth
My example is also bad in one other way... (+ 0 ...) won't mess things up, but any other number probably will
7:38:12
aeth
to be fair, (safety 0) does have its use in removing bounds checks in arrays in a LOCALLY if you really know what you're doing...
7:38:42
aeth
Just never do it at the function level because then it won't check the inputs, e.g. you could pass in too many or too few arguments
7:38:56
jdz
aeth: One does not need (safety 0) if the compiler can figure out the bounds checks don't have to be checked on every iteration.
7:39:24
aeth
There definitely are cases where you know it can't go out of bounds but SBCL does not (yet) know this
7:41:41
aeth
I generally use fixed-size arrays when I want performance, though. Then there's no need to play any games around bounds checking.
7:44:40
aeth
Anyway for anyone following along later, my final, corrected version of messing up your SBCL with (safety 0) that will otherwise be caught at compile time is: (with-compilation-unit () (defun hi () "hi") (defun foo () (declare (optimize (safety 0))) (+ 2 (the fixnum (hi)))))