anticomputer has quit [Remote host closed the connection]
anticomputer_ has joined #commonlisp
pranav has joined #commonlisp
zaymington has quit [Remote host closed the connection]
amb007 has joined #commonlisp
<paulapatience>
Ah. Well, it is theoretical. They are likely going to implement it in SICL if it is not done so already.
rtypo has quit [Ping timeout: 264 seconds]
amb007 has quit [Ping timeout: 255 seconds]
random-nick has quit [Ping timeout: 255 seconds]
Inline has quit [Quit: Leaving]
msv has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
msv has joined #commonlisp
amb007 has quit [Ping timeout: 255 seconds]
vats has joined #commonlisp
ymir has quit [Ping timeout: 252 seconds]
ebrasca has quit [Remote host closed the connection]
mesuutt has quit [Ping timeout: 260 seconds]
vats has quit [Ping timeout: 240 seconds]
ymir has joined #commonlisp
mrcom has quit [Quit: Leaving]
jonatack has joined #commonlisp
<ymir>
Is it possible to disable wildcarding on a pathname? For instance, I have a pathname that contains square brackets in the pathname-name section and I'm trying to get the namestring of pathname-name but end up with type errors since it's of type SB-IMPL::PATTERN
mesuutt has joined #commonlisp
mrcom has joined #commonlisp
istewart has joined #commonlisp
poplin has quit [Ping timeout: 256 seconds]
poplin has joined #commonlisp
semz has quit [Quit: ZNC 1.8.2+deb2build5 - https://znc.in]
poplin has quit [Read error: Connection reset by peer]
poplin has joined #commonlisp
semz has joined #commonlisp
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 272 seconds]
mesuutt has quit [Ping timeout: 256 seconds]
josrr has quit [Remote host closed the connection]
ymir has quit [Ping timeout: 252 seconds]
reb has joined #commonlisp
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 264 seconds]
igemnace has joined #commonlisp
yottabyte has quit [Quit: Connection closed for inactivity]
jmercouris1 has joined #commonlisp
ymir has joined #commonlisp
decweb has quit [Ping timeout: 272 seconds]
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
amb007 has quit [Ping timeout: 255 seconds]
wacki has joined #commonlisp
tasty has quit [Ping timeout: 260 seconds]
hineios2 has quit [Ping timeout: 256 seconds]
hineios2 has joined #commonlisp
Pixel_Outlaw has joined #commonlisp
notzmv has quit [Ping timeout: 255 seconds]
jmercouris1 has quit [Quit: jmercouris1]
wacki has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 252 seconds]
istewart has quit [Quit: Konversation terminated!]
shka has joined #commonlisp
holycow has joined #commonlisp
ymir has quit [Ping timeout: 260 seconds]
pranav has quit [Read error: Connection reset by peer]
random-jellyfish has quit [Ping timeout: 256 seconds]
danza has joined #commonlisp
amb007 has joined #commonlisp
danza_ has joined #commonlisp
danza has quit [Read error: Connection reset by peer]
synchromesh has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
anticomputer has joined #commonlisp
anticomputer_ has quit [Ping timeout: 260 seconds]
puke has quit [Ping timeout: 255 seconds]
mesuutt has joined #commonlisp
varjag has joined #commonlisp
mesuutt has quit [Ping timeout: 268 seconds]
<Shinmera>
create the pathname without the pattern
<Shinmera>
using things like pathname-utils:parse-native-namestring or uiop's same
varjag has quit [Ping timeout: 255 seconds]
mgl_ has quit [Ping timeout: 255 seconds]
rgherdt has joined #commonlisp
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
Pixel_Outlaw has quit [Quit: Leaving]
donleo has joined #commonlisp
zetef has joined #commonlisp
zetef has quit [Remote host closed the connection]
msavoritias has joined #commonlisp
mesuutt has joined #commonlisp
King_julian has joined #commonlisp
igemnace has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
danza_ has quit [Ping timeout: 260 seconds]
amb007 has quit [Remote host closed the connection]
amb007 has joined #commonlisp
puke has joined #commonlisp
mesuutt has quit [Ping timeout: 268 seconds]
notzmv has joined #commonlisp
mgl_ has joined #commonlisp
beach` has joined #commonlisp
igemnace has joined #commonlisp
beach has quit [Ping timeout: 255 seconds]
vats has joined #commonlisp
beach` is now known as beach
dino_tutter has joined #commonlisp
tok has joined #commonlisp
kenran has joined #commonlisp
attila_lendvai has joined #commonlisp
danse-nr3 has joined #commonlisp
danse-nr3 has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
tertek has quit [Quit: %quit%]
amb007 has joined #commonlisp
mesuutt has joined #commonlisp
tertek has joined #commonlisp
mesuutt has quit [Ping timeout: 272 seconds]
King_julian has quit [Quit: leaving]
King_julian has joined #commonlisp
pve has joined #commonlisp
makomo has joined #commonlisp
msavoritias has quit [Ping timeout: 268 seconds]
kenran has quit [Remote host closed the connection]
<beach>
Function types are still mysterious to me, so I don't know the answer, but I always wonder why someone would want to do that.
streda has quit [Read error: Connection reset by peer]
<aeth>
maybe &allow-other-keys could help, but I've never mixed ftypes with generic functions before
<beach>
I mean, type declarations make the program less safe, so why would one want to do that?
msv has quit [Remote host closed the connection]
<simendsjo>
I tried juggling &allow-other-keys, but still got similar errors. Why does type declarations make it less safe? I like getting some type warnings at compile time when possible.
<beach>
But that's not the purpose of type declarations. They are promises to the compiler, and the compiler is free to trust you. If it does, the minute you violate the promise, your program exhibits undefined behavior.
<beach>
... like if you do (defmethod m (....) (some-function ...)) and some-function returns something other than an integer.
<beach>
So as long as you don't promise anything, the compiler is not allowed to make assumptions (other than the ones allowed by the standard), but when you start making such promises, you must to totally sure to keep your promise, or you program has undefined behavior.
<beach>
*you must be totally sure
<beach>
My guess is that people who stick in type declarations do it because they are used to statically typed languages, where type declarations mean something different.
<aeth>
the only major implementation that in practice is broken in this sense is SBCL with (safety 0) so the problem only comes up in practice when people copy (safety 0) from those microbenchmarks where (safety 0) is basically just used to cheat at benchmarks and produce code less safe than C
<simendsjo>
In this case, I'm sure as I'm creating the contract. `make-enumerator` should always create an `enumerator`. Without this, I cannot state that `filter` returns an `enumerator` either.
<aeth>
I suppose SBCL may inherit this behavior from CMUCL, which would then be two implementations broken in this way
<semarie>
type declaration in programming languages often mean "I want that, tell me if I do something else"
MajorBiscuit has joined #commonlisp
<beach>
semarie: In many languages, they do, but not in Common Lisp.
<beach>
simendsjo: But the question is why you would want to state that, rather than just doing it.
<aeth>
it's underspecified so there are three possible behaviors: ignore (which is fine if you use other implementations), check at compile time when possible and runtime when not, or assume type
<aeth>
however, in practice, CHECK-TYPE has a fatal flaw for compilers: anything is valid up to that point because it's a correctable error
<aeth>
so you can have very complicated code in a file where DECLARE correctly fixes all of your stuff in SBCL as if in a statically typed language, while CHECK-TYPE is absolutely useless
<simendsjo>
beach: Because I'm used to statically typed languages and like certain things there? ;) It's an aid when developing and optimization hints for the compiler. When adding (speed 3) SBCL cries out loud many places.
<beach>
simendsjo: But then you must realize that you are programming in SBCL rather than in portable Common Lisp.
<simendsjo>
If I remove the type declarations from `make-enumerator` and change the return type from `enumerator` to `(values enumerator &optional)`, SBCL doesn't give any warnings.
amb007 has quit [Ping timeout: 272 seconds]
<simendsjo>
beach: But such code should still be valid in other implementations even though they might not take advantage of them?
zetef has joined #commonlisp
<aeth>
simendsjo: the problem, and it's mostly theoretical, is someone could write an Evil Lisp where the code just assumes the declarations are valid and it would be standards conforming even though in practice Evil Lisp is only SBCL at (safety 0) and the solution is to ban by convention (safety 0) outside of LOCALLY
<beach>
If your code is correct, it is conforming, sure. But if you have a bug, you might get undefined behavior including crashes or (worse) just the wrong answer.
<beach>
I personally write all my code with (SAFETY 3) (DEBUG 3) (SPEED 0) and almost all code without type declarations for maximum safety.
<aeth>
(though I should add that you can't really stop other people from using (safety 0) outside of your code in SBCL in a way that your code is compiled with (safety 0) which may break everything)
<beach>
Only if I have a performance problem will I consider violating this principle, and then only in a small part of the code.
<beach>
But usually, it is a much better idea, then, to improve algorithms and data structures.
<beach>
Wanting high low-level performance (like with type declarations) usually pays off a lot less than improving algorithms and data structures.
pranav has joined #commonlisp
<simendsjo>
My main use-case is to get some aid from the compiler when I'm doing something wrong and during refactoring. And it's good for documentation too. But I'm removing all type declarations now and see how that goes.
<aeth>
I personally use type declarations for static type checking in SBCL, which suits the domain (game engine) very well. I can change something in a 2000 line file and it should work if I fix all of the compile time type errors. And I only have to worry about types where it makes sense, and not in large parts of it, such as most of the macros.
<aeth>
(as in, it doesn't make sense in macros, not that it does)
vats has quit [Ping timeout: 268 seconds]
<aeth>
I've tried using CHECK-TYPEs and the compiler just doesn't help me at all when I change a type around. Which matters in thousands of lines. In theory, I could get 100% unit test coverage instead. In theory. Game stuff's hard to unit test.
<aeth>
But... it doesn't really make too much sense for generic functions. Sections of code that use DECLARE/DECLAIM static typing basically have to go all-in on it to make SBCL's checking useful and defmethod is probably runtime-generic enough to break the usefulness of it.
<simendsjo>
CHECK-TYPE lowers to ASSERT and will be in your code at run-time no matter the optimization setting?
<aeth>
CHECK-TYPE will always work at runtime, but it completely breaks static checking in SBCL because (defun foo (x) (check-type x integer) x) is derived to be a function of T not a function of INTEGER (even if an INTEGER is the only useful input in practice) because any input is valid because CHECK-TYPE is correctable.
<aeth>
If you have a file that relies on static type checks in SBCL and has some CHECK-TYPEs in it, the CHECK-TYPE parts will thus make the whole thing nearly pointless, depending on where the CHECK-TYPEs are.
<beach>
These are again low-level performance problems. I maintain that it's a much better idea to concentrate on algorithms and data structures.
<aeth>
That is, if F calls G and is the entry point, using CHECK-TYPE in F is fine, but using CHECK-TYPE in G and DECLARE in F is doing it backwards
<aeth>
beach: This isn't DECLARE for performance. This is DECLARE in a way that the SBCL compiler can detect type errors at compile time rather than runtime in large files. Performance will mostly be comparable to the CHECK-TYPE route because SBCL still has to check the types at runtime, but all of that type information is gone for function interfaces because a function variable X whose type is checked is
<aeth>
inferred to be of type T.
pfdietz has quit [Quit: Client closed]
<aeth>
if you use DISASSEMBLE you may be under the mistaken impression that DECLARE or an FTYPE DECLAIM is doing something for you because the typecheck is hidden from the CL:DISASSEMBLE but is still visable from SB-DISASSEM:DISASSEMBLE-CODE-COMPONENT
<simendsjo>
Oh, that's good to know! I've been using DISASSEMBLE to make sure my code is optimized.
<aeth>
It's probably still very marginally faster because the type error from DECLARE is unspecified and so doesn't need to be correctable. But that's into the realm of tiny microoptimizations.
<aeth>
You can also build with (safety 0) to remove those checks entirely, and many languages' culture encourage this sort of thing (safety only when developing and then build with such checks off), but I still insist that using (safety 0) outside of LOCALLY is a terrible idea. You're not going to gain much, but you'll lose a lot in reliability.
mesuutt has joined #commonlisp
<beach>
simendsjo: You seem to care a lot about low-level performance. What kind of application are you writing?
<aeth>
There are still two issues here with using DECLARE/DECLAIM. One, not every Lisp behaves like this semantically for checking, which is fine as long as you have an SBCL compiler in your CI... it'll still do the static checking. But, two, and this is more critical, a theoretical Evil Lisp can type-assume even when safety =/= 0, which would be horrible. So if you care about having your code work as intended
<aeth>
on such an essentially malicious and afaik entirely hypothetical Lisp, then don't use DECLARE/DECLAIM at all.
<beach>
simendsjo: And since you are writing for SBCL, you might then want to know that generic dispatch in SBCL is not that great, so you might want to avoid generic functions altogether.
<aeth>
This is static type checking in SBCL for DECLARE or FTYPE DECLAIMs. It doesn't matter if your code is used in ECL or CCL. In theory, having an implementation that can statically check at compile time can effectively be another test stage for you.
<aeth>
You're not writing for SBCL.
<aeth>
A robust automated tooling should probably make sure it both compiles in and passes tests in both SBCL and CCL, at a minimum.
mesuutt has quit [Ping timeout: 256 seconds]
<aeth>
The valid issue with this approach is that implementations can type-assume. Implementations that ignore type declarations are (almost) no issue at all.
<aeth>
If this type-assuming possibility didn't exist, then adding type declarations would always be an obvious choice for any code where types are obvious (a lot of code is far, far, far too type-general for this to be useful, especially functions used by macros... but methods seem to me to also be this sort of code?). Because it does exist, it's not always the right choice.
pfdietz has joined #commonlisp
chomwitt has joined #commonlisp
danse-nr3 has quit [Read error: Connection reset by peer]
zetef has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
msavoritias has joined #commonlisp
<aeth>
You could fix this in two small steps without throwing out the gradually typed baby with the unsafety bathwater: (1) do not permit (for a de facto standard, I guess?) type assuming outside of (safety 0) which will satisfy the benchmark microoptimizers who want to make their microoptimizations look C++ fast, but (2) do not by convention ever, ever, EVER use (safety 0) outside of LOCALLY (thus making this
<aeth>
point moot for function types)
<simendsjo>
beach: Right now, I'm writing an enumeration library. As it's a library I want to be able to use it in more performance critical code too. I have both a game and some other code I want to convert to using this rather than list processing. I started it because I wanted more lazy processing of sqlite rows rather than dumping all rows into a list as the library was doing.
mm007emko has quit [Ping timeout: 255 seconds]
<aeth>
simendsjo: As I said in my admittedly too long responses (but this sort of thing seems to be commonly misunderstood in this channel and I wanted to make my dissenting perspective very clear), the main issue people have with this sort of code is that implementations theoretically can (and SBCL at (safety 0) does) assume that the declarations are valid and thus permit horrible things for e.g. (defun foo
<aeth>
(x) (declare (type single-float x)) (+ x x)) when x is not a single-float instead of either erroring at the call to FOO (if it checks the declare) or erroring at the still-generic + (if it ignores the declaration entirely)
<aeth>
So the question becomes is if that potential unreliability matters to you. For a small and very general library (which are very common in CL), nearly everything may be exposed to the user, at which point the user may misuse it. For a very large application, framework, or game engine (not very common in CL), it may be entirely internal and thus may be worth it for you.
<simendsjo>
It's difficult to wrangle my state of mind out of a statically typed world. I don't want to loose all the benefits of static types even though I want to use Common Lisp. Guess Coalton tries to solve this though...
mm007emko has joined #commonlisp
<aeth>
Well, in my opinion, and for some reason this does not seem to be the common view, Common Lisp is "gradually typed" in that it has the potential for "static typing" at compile time (via DECLARE/DECLAIM in some implementations at some compiler settings) in addition the mandatory dynamic typing at runtime. I don't see why this is extremely controversial, but it is. I guess computer science people will
<aeth>
bikeshed argue over categorization and definitions all day. And I definitely take advantage of this gradual typing where it makes sense (and it often doesn't, and some people may spend all of their lives only writing code in areas where it doesn't).
<aeth>
but... you're probably overdoing it if you're doing that with methods.
<pranav>
Could macroexpanded DECLARE forms be a solution to manage implementation specific behaviour regarding type declarations (e.g. using implementation feature flags)?
<simendsjo>
The only method I have is for constructing enumerators so other can add new ones and the users still use the same name for constructing them. `(defmethod make-enumerator ((x some-new-type)) ..)`. It's no big deal though.. The canonical representation is a function returning the next value.
zetef has joined #commonlisp
random-jellyfish has joined #commonlisp
<aeth>
pranav: I've considered it. I actually do nearly all of my function variable declarations or ftype declaims (I only declaim an ftype where mandatory, when there's return type(s) specified, not just input variables' types) through a macro that can either do DECLARE/DECLAIM or CHECK-TYPE, precisely because it's a topic of heated debate and my code can thus with very minimal changes generate either.
waleee has quit [Ping timeout: 246 seconds]
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 252 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<pranav>
aeth: would love to take a look at your macro if it's available online.
<aeth>
It's a several hundred line monster (or at least, I used to consider macros that short to be monsters) that doesn't currently support every DEFUN feature (e.g. &aux, and suppliedp arguments to optionals/keys) and it still has some bugs in less-exercised code paths.
<aeth>
I never even considered adding support for DEFMETHOD because that seems way more niche than e.g. &aux
<aeth>
I mean, mixing generics with declares. Not the presence of DEFMETHOD itself
ronald has joined #commonlisp
<pranav>
Thanks aeth.
mm007emko has quit [Read error: Connection reset by peer]
mm007emko has joined #commonlisp
<aeth>
but it's not quite usable yet... in part because that project is basically just a bunch of random things I've happened to need, of varying degrees of completion and bugginess
awlygj has joined #commonlisp
notzmv has quit [Ping timeout: 255 seconds]
<aeth>
It never crossed my mind to make a variation of it for DEFGENERIC/DEFMETHOD (so I'm not quite sure how DECLARE/DECLAIM interacts with DEFGENERIC/DEFMETHOD) because I kind of see DEFINE-FUNCTION as the "specific" version of DEFMETHOD's "generic". e.g. It mostly matches in syntax (although DEFINE-FUNCTION is on types, not classes, and had to invent syntax for &key and &optional beacuse DEFMETHOD does not
<aeth>
dispatch on those)
<aeth>
I also had to put options in the name, where (FOO &rest options) can replace FOO, taking advantage of the fact that only (setf FOO) is a valid name for a function with a list name and so if you're not defining SETF (which you aren't because it can be package locked) a list means the real name can be the CAR of the list.
<aeth>
Which, yes, means that that was yet another edge case that I had to battletest and add support for that I doubt I had in the first version.
<aeth>
I mean, supporting (setf FOO) names
<pranav>
aeth, What I had in mind was not full blown replacements for DEFUN et al. but macros that expand to appropriate DECLARE forms in-place.
msv has joined #commonlisp
<pranav>
The macros could set/tweak the appropriate optimization levels to make sure that type checking happens for any given implementation.
edgar-rft has quit [Ping timeout: 264 seconds]
random-nick has joined #commonlisp
decweb has joined #commonlisp
<aeth>
pranav: that... kind of requires a macro that expands to a DEFUN to put the right DECLAREs in place because you either have a DECLARE that comes immediately after the binding (such as the start of a DEFUN) or that is top-level and DECLAIM (for things that require an FTYPE... although this technically doesn't need to live with the DEFUN and can be elsewhere in the file as long as it iirc shows up before
<aeth>
the DEFUN)
<aeth>
and then if you want to replace that with CHECK-TYPE on poorly behaved implementations, it absolutely requires a macro that expands into a DEFUN
edgar-rft has joined #commonlisp
<aeth>
The objection beach and others make to never use DECLARE because an CL arbitrary implementation can do anything arbitrarily with DECLARE doesn't apply if you never directly use DECLARE at all! Because now you can, if provided with a name of an actual implementation instead of the merely theoretical objection from what the standards permit, work around that implementation in the DEFUN-replacing macro.
<aeth>
Changing behavior at different optimization levels presents a harder issue, though.
<pranav>
aeth: I've seen people use read time evaluation to insert ad-hoc declarations (e.g. optimization levels) as in #.*declarations* where *declarations* stores a list of declarations. I think it should be possible to decouple a declare replacement from corresponding toplevel forms. e.g. (defun fun (x) (my-declare (type number x)) (+ x x)) would not only assert the given declarations, but also the necessary
<pranav>
optimization parameters (specific to each implementation) that change the implementation's behaviour to enforce the given declarations (or not).
<aeth>
now put a docstring after that my-declare and everything falls apart, but only sometimes.
<pranav>
I understand the simplicity and safety of not using DECLARE provided by the standard. I was suggesting a set of portable declarations that ensure uniform behaviour regarding type-checking across implementations.
<aeth>
docstrings may come before or after DECLARE
<aeth>
Also, you could e.g. force SAFETY to a known value in #+sbcl with OPTIMIZE, but which one? You just want not 0. And what if the user of your macro really wants 0 anyway and understands the consequences?
<aeth>
Though I could buy the argument of needing to set an *i-understand-the-consequences* to T in that case.
<aeth>
(but then when a library does it, everyone gets it?)
<aeth>
I did, a long time ago, add some basic support to messing with OPTIMIZE inside of DEFINE-FUNCTION itself, but I don't use it anymore and probably should remove it, but I can't guarantee that I stopped using it in all of my files (and I hope nobody else is using DEFINE-FUNCTION, but I can't guarantee that, either).
edgar-rft has quit [Quit: don't waste your life by reading this]
<pranav>
I see. I'll have to attempt at writing the macro to understand the issues further I guess.
<aeth>
I ridiculously overthought/overengineered DEFINE-FUNCTION, in part to address extremely obscure criticisms from IRC and in part because the much older and afaik more popular DEFSTAR is GPLv3 and a library, which means I both couldn't use it in my MIT licensed code and wanted to make something far, far, far more robust than it out of spite for wasting my time. Waste my time? Then I'll really waste it by
<aeth>
doing more than what I wanted.
<aeth>
GPLed libraries only work if what you're doing is hard.
<aeth>
Ironically, handling all edge cases (and I doubt DEFUN* does because there are many) actually is hard, but you don't realize it until it's too late.
MajorBiscuit has quit [Ping timeout: 240 seconds]
King_julian has quit [Ping timeout: 268 seconds]
yitzi has joined #commonlisp
danse-nr3 has quit [Ping timeout: 256 seconds]
<flip214>
does alexandria:parse-body help to divide into declarations, code, and docstring?
<aeth>
looks like it might, but only when :documentation t
<aeth>
and when :documentation t, it errors on useless strings that are confused with docstrings, which might not be what you want because it's still afaik valid... looks like SBCL's compiler gives a WARNING for this situation in a DEFUN.
notzmv has joined #commonlisp
triffid has quit [Ping timeout: 260 seconds]
<yitzi>
The UIOP version is identical, btw.
X-Scale has joined #commonlisp
edgar-rft has joined #commonlisp
triffid has joined #commonlisp
green_ has joined #commonlisp
vats has quit [Ping timeout: 255 seconds]
<younder>
I never even considered the ramification of mixing MIT and GPL licences.
<younder>
I just stamp a MIT license on it and use whatever library I want.
<younder>
Perhaps I should reconsider.
<younder>
As long as it's LGPL I guess I'm OK and it is unusual to see a library GPL'ed.
varjag has joined #commonlisp
King_julian has joined #commonlisp
<younder>
Well the 'Stallman approach' when running into problems with Gosling Emacs when running into copyright problems was to simply remove the software and write it from scratch.
<younder>
GPL => Gotta Put in the Labor
vats has joined #commonlisp
nij- has joined #commonlisp
nij- has quit [Remote host closed the connection]
nij- has joined #commonlisp
<nij->
Is there a way to check if both lists are exhausted in the same loop? I could have compared them with length, but I wish to optimize the process a bit. Something like - https://bpa.st/3J2A
<ixelp>
View paste 3J2A
MajorBiscuit has joined #commonlisp
<beach>
I don't think so. That's a tricky problem.
<beach>
I guess if you are sure they are proper lists, you can iterate with for x = .. then (cdr x) for y = .. then (cdr y) and check that both x and y are NIL.
<beach>
,(loop for x = '(a b c) then (cdr x) for y = (1 2 3 4) then (cdr y) until (and (null x y)) collect (cons (car x) (car y)))
<ixelp>
ERROR: While compiling an anonymous function : ↩ In the form (1 2 3 4), 1 is not a symbol or lambda expression.
<beach>
,(loop for x = '(a b c) then (cdr x) for y = '(1 2 3 4) then (cdr y) until (and (null x y)) collect (cons (car x) (car y)))
<ixelp>
ERROR: Too many arguments in call to #<Compiled-function NOT #x14243006>: ↩ 2 arguments provided, at most 1 accepted.
<beach>
*sigh*
<beach>
,(loop for x = '(a b c) then (cdr x) for y = '(1 2 3 4) then (cdr y) until (and (null x) (null y)) collect (cons (car x) (car y)))
<ixelp>
=> ((A . 1) (B . 2) (C . 3) (NIL . 4))
<beach>
YAY.
kevingal has joined #commonlisp
<nij->
Thanks. I never used :then clause before.
random-jellyfish has quit [Ping timeout: 240 seconds]
<ixelp>
Code/Visualiser · main · Applied Language / Utena / Movement Three · GitLab
<younder>
I particular the SSA visualizer using clim
msavoritias has quit [Remote host closed the connection]
<younder>
It uses graphwiz
dra has joined #commonlisp
dra has quit [Changing host]
dra has joined #commonlisp
<beach>
I can't say I have seen it, no.
danse-nr3 has joined #commonlisp
<younder>
Well she sent me this link so I though I had better have a look.
<beach>
Sounds good to me.
danse-nr3 has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
<King_julian>
save
dra has quit [Ping timeout: 256 seconds]
random-jellyfish has joined #commonlisp
random-jellyfish has joined #commonlisp
random-jellyfish has quit [Changing host]
X-Scale has quit [Quit: Client closed]
vats has quit [Ping timeout: 268 seconds]
hayley has quit [Quit: leaving]
edgar-rfx has joined #commonlisp
edgar-rft has quit [Ping timeout: 256 seconds]
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 264 seconds]
cdegroot_ has joined #commonlisp
cdegroot has quit [Ping timeout: 255 seconds]
nij- has quit [Ping timeout: 268 seconds]
bjorkintosh has quit [Ping timeout: 260 seconds]
nij- has joined #commonlisp
edgar-rfx has quit [Ping timeout: 240 seconds]
mesuutt has joined #commonlisp
simendsjo has quit [Ping timeout: 255 seconds]
mesuutt has quit [Ping timeout: 252 seconds]
edgar-rft has joined #commonlisp
semarie has quit [Ping timeout: 260 seconds]
danse-nr3 has quit [Ping timeout: 256 seconds]
danse-nr3 has joined #commonlisp
waleee has joined #commonlisp
semarie has joined #commonlisp
King_julian has quit [Quit: leaving]
King_julian has joined #commonlisp
waleee has quit [Quit: WeeChat 4.1.2]
tasty has joined #commonlisp
tasty has quit [Changing host]
tasty has joined #commonlisp
tasty has quit [Client Quit]
tasty has joined #commonlisp
tasty has quit [Changing host]
tasty has joined #commonlisp
rtypo has quit [Quit: WeeChat 4.2.1]
yitzi has quit [Remote host closed the connection]
mesuutt has joined #commonlisp
chomwitt has quit [Ping timeout: 255 seconds]
mgl_ has quit [Ping timeout: 255 seconds]
mesuutt has quit [Ping timeout: 256 seconds]
emaczen has joined #commonlisp
danse-nr3 has quit [Ping timeout: 264 seconds]
jjnkn has joined #commonlisp
igemnace has quit [Read error: Connection reset by peer]
pfdietz has quit [Quit: Client closed]
zetef has joined #commonlisp
jjnkn has quit [Remote host closed the connection]
King_julian has quit [Quit: leaving]
jjnkn has joined #commonlisp
King_julian has joined #commonlisp
MajorBiscuit has quit [Quit: WeeChat 4.2.1]
King_julian has quit [Client Quit]
King_julian has joined #commonlisp
igemnace has joined #commonlisp
cage has joined #commonlisp
pfdietz has joined #commonlisp
mesuutt has joined #commonlisp
nij- has left #commonlisp [Using Circe, the loveliest of all IRC clients]
mesuutt has quit [Ping timeout: 260 seconds]
random-jellyfish has quit [Ping timeout: 260 seconds]
mgl_ has joined #commonlisp
NotThatRPG has quit [Remote host closed the connection]
NotThatRPG has joined #commonlisp
King_julian has quit [Ping timeout: 246 seconds]
josrr has joined #commonlisp
varjag has quit [Quit: ERC (IRC client for Emacs 27.1)]
NotThatRPG has quit [Ping timeout: 252 seconds]
<younder>
(asdf:load-system :sicl-boot) gives Component #:SICL-ENVIRONMENT not found, required by #<SYSTEM "sicl-boot-base">
<beach>
sicl-boot is obsolete. I am working on a system temporarily called sicl-new-boot.
<beach>
I haven't made the effort to update all the documentation, for which I apologize.
<beach>
Basically, there is no point in trying to boot SICL at this point.
<younder>
well I'll get back to it later
<beach>
younder: What is it that you want to do?
simendsjo has joined #commonlisp
<younder>
Just seeing if I could get it to boot
<beach>
Well, "later" is probably months away at the current work pace.
amb007 has joined #commonlisp
reb has quit [Remote host closed the connection]
<beach>
If you want to see where I am at the moment, you can do (asdf:load-system "sicl-new-boot-backtrace-inspector) then (asdf:load-system "sicl-new-boot") then (in-package #:sicl-new-boot) then (time (boot)).
<beach>
It will take a bit more than 2 minutes, depending on your computer.
<beach>
You will need tons of external libraries.
<beach>
In fact, you may not have access to those, so I say just drop it.
<younder>
Yeah it bombs on a missing :common-boost-ast-evaluator
<beach>
We use a lot of external libraries these days, and I haven't documented how to download them (yet).
simendsjo has quit [Ping timeout: 255 seconds]
danse-nr3 has joined #commonlisp
danse-nr3 has quit [Remote host closed the connection]
danse-nr3 has joined #commonlisp
zetef has quit [Read error: Connection reset by peer]
zetef has joined #commonlisp
mesuutt has joined #commonlisp
amb007 has quit [Ping timeout: 256 seconds]
danse-nr3 has quit [Ping timeout: 272 seconds]
mesuutt has quit [Ping timeout: 256 seconds]
King_julian has joined #commonlisp
alcor has joined #commonlisp
kztx has joined #commonlisp
wacki has joined #commonlisp
Inline has joined #commonlisp
dra has joined #commonlisp
NotThatRPG has joined #commonlisp
chomwitt has joined #commonlisp
b00p has joined #commonlisp
zetef has quit [Remote host closed the connection]
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 260 seconds]
ymir has joined #commonlisp
amb007 has joined #commonlisp
b00p has quit [Quit: b00p]
chomwitt has quit [Ping timeout: 260 seconds]
pfdietz has quit [Quit: Client closed]
ymir has quit [Ping timeout: 268 seconds]
wacki has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
jmercouris1 has joined #commonlisp
jmercouris1 has quit [Client Quit]
King_julian has quit [Quit: leaving]
King_julian has joined #commonlisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
jmercouris1 has joined #commonlisp
simendsjo has joined #commonlisp
jmercouris1 has quit [Client Quit]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
wacki has joined #commonlisp
awlygj has quit [Quit: leaving]
mesuutt has joined #commonlisp
decweb has quit [Ping timeout: 260 seconds]
decweb has joined #commonlisp
mesuutt has quit [Ping timeout: 256 seconds]
ymir has joined #commonlisp
igemnace has quit [Quit: WeeChat 4.2.2]
yitzi has joined #commonlisp
synchromesh has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
King_julian has quit [Ping timeout: 272 seconds]
waleee has joined #commonlisp
jjnkn has quit [Remote host closed the connection]
mgl_ has quit [Ping timeout: 260 seconds]
random-jellyfish has joined #commonlisp
random-jellyfish has joined #commonlisp
ymir has quit [Ping timeout: 256 seconds]
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 260 seconds]
younder has quit [Remote host closed the connection]
younder has joined #commonlisp
mgl_ has joined #commonlisp
varjag has joined #commonlisp
random-jellyfish has quit [Ping timeout: 268 seconds]
mgl_ has quit [Ping timeout: 272 seconds]
dra has quit [Ping timeout: 256 seconds]
kevingal has quit [Ping timeout: 256 seconds]
ymir has joined #commonlisp
random-jellyfish has joined #commonlisp
chomwitt has joined #commonlisp
attila_lendvai_ has joined #commonlisp
jmiven has quit [Quit: reboot]
attila_lendvai has quit [Ping timeout: 255 seconds]
jmiven has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 29.2]
pranav has quit [Remote host closed the connection]
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 272 seconds]
random-jellyfish has quit [Ping timeout: 255 seconds]
edgar-rft has quit [Ping timeout: 252 seconds]
random-jellyfish has joined #commonlisp
kztx has quit [Remote host closed the connection]
pfdietz has joined #commonlisp
reb has joined #commonlisp
jonatack has quit [Ping timeout: 264 seconds]
jonatack has joined #commonlisp
poplin has quit [Ping timeout: 260 seconds]
poplin has joined #commonlisp
simendsjo has quit [Ping timeout: 272 seconds]
mesuutt has joined #commonlisp
<mrcom>
nij: Use :ON instead of :IN, then :FINALLY check both are nil
<mrcom>
,(loop :for d :on '(0 1 2) :for e :on '(0 1 2 3) :do (pprint (list (first d) (first e))) :finally (assert (not (or d (rest e))) () "Nope nope nope d: ~A e: ~A" d (rest e)))
<ixelp>
ERROR: Nope nope nope d: NIL e: (3)
poplin has quit [Ping timeout: 268 seconds]
poplin has joined #commonlisp
<mrcom>
nij: The assertion needs to check for D and (rest E) because D gets processed first each loop (guarenteed by spec), and loop terminates as soon as it sees D is nil.
mesuutt has quit [Ping timeout: 255 seconds]
amb007 has quit [Ping timeout: 246 seconds]
tok has quit [Remote host closed the connection]
nij- has joined #commonlisp
<nij->
1. How does quicklisp handle dependency issue? Say A.v1 and B.v1 both depend on C.v1, and say A needs to upgrade to A.v2, which depends on C.v2?
<nij->
2. If quicklisp must compile all systems successfully, what if C.v1 must upgrade to C.v2 which breaks A.v1 and A.v2? Does quicklisp ask for A and B to upgrade as well, or does it simply doesn't use C.v2? What if the situation is crucial, and C must be upgraded? How does quicklisp decide which side to favor?
<nij->
3. How many CL-implementations*versions do quicklisp test on each complete build? I've had more than 3 experiences where a different version of sbcl does not compile some CL system successfully. So I guess this happens more than rarely.
dra has joined #commonlisp
<nij->
mrcom Thanks!
tfeb has joined #commonlisp
tfeb has quit [Client Quit]
shka has quit [Ping timeout: 252 seconds]
waleee has quit [Quit: WeeChat 4.1.2]
wacki has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
nij- has quit [Ping timeout: 256 seconds]
tfeb has joined #commonlisp
msv has quit [Ping timeout: 256 seconds]
tfeb has quit [Client Quit]
random-jellyfish has quit [Remote host closed the connection]
random-jellyfish has joined #commonlisp
mesuutt has joined #commonlisp
mesuutt has quit [Ping timeout: 256 seconds]
nij- has joined #commonlisp
amb007 has joined #commonlisp
akoana has joined #commonlisp
amb007 has quit [Ping timeout: 272 seconds]
n8n has quit [Quit: WeeChat 4.2.2]
<mrcom>
nij: quicklisp is a monolithic release, one version per library. If two dependants need conflicting versions of a dependency then *something* will be removed from the repository (or maybe just not updated?.
<nij->
Yes. How does it decide which one to favor, and which one to drop?
<mrcom>
Which you were asking how that's decided... don't know if Zach has spelled it out.
<nij->
There are so manyl libs.. I imagine it a hard problem to assign importance fairly.
<mrcom>
I suspect it's ad-hoc. The CL ecosystem doesn't exactly move at lightspeed, so it's probably not a killer.
<phoe>
history question: why does MULTIPLE-VALUE-PROG1 even exist? why wasn't it folded into PROG1 during standardization?
<nij->
Oh hi phoe :-)
<mrcom>
My guess would be the triage is something like "Does it break with latest Alexendria? It's out."
<phoe>
but that only answers a part of my question, the less satisfying one
<gilberth>
phoe: I guess for historic reasons. There are other things that lack MV support. OR comes to mind e.g.
<mrcom>
nij: Which libs have you seen broken?
<nij->
mrcom You mean broken with sbcl?
<nij->
I have to recall.. hmm..
<mrcom>
Inconsistent w/ whatever release of Quicklisp you were using.
younder has quit [Ping timeout: 255 seconds]
<gilberth>
CL isn't very consistent. Why does #'(setf foo) work, but ((setf foo) ...) does not?
<gilberth>
phoe: But to answer your question: I think they just want to leave PROG1 as it is. Reluctance to change anything existing. Which IMHO isn't that bad a thing.
<mrcom>
gilberth: becuase (setf foo) would evaluate to the new value of foo (NIL, if single-operand call was allowed), not the (setf foo) function designator.
<gilberth>
In this regard it must be puzzling to a newbie. Look at ASSOC, GETF, and GETHASH. All have a totally different interface. Argument order is the wrong way for GETHASH. ASSOC gets you pait and NIL for "undefined". GETF solves this undefined by a default value, GETHASH has both a default value and a secondary win indicator. Yet all implement the same functionallity: Look something up in some form of dictionary.
<gilberth>
mrcom: I'm not evaluating (setf foo). I'm calling it.
<bike>
yeah, i don't see any reason that allowing setf function names there wouldn't work.
<gilberth>
I mean for every symbol S (funcall #'S ...) is the very same as (S ...) why not for (SETF FOO)?
<bike>
that doesn't work because the first element of a call form is not evaluated
<gilberth>
I see #'.. as an escape from value space into function space. At times I miss the reverse operator to get from function space to value space.
<bike>
which is a more serious difference
<mrcom>
bike: Yeah, just a natural... impurity... of CL.
<bike>
what i mean is that the setf thing is way easier
<bike>
standards revision wise, it would just be changing like one sentence
<gilberth>
mrcom: Common Lisp is a Lisp-2. functions and values are in different name spaces. This is why your ((if ..) ..) isn't working.
<mrcom>
gilberth: What would `((setf foo 42) 'blah)` do in your world?
<bike>
(setf foo 42) is an invalid function name, so error
<bike>
i don't think you understand what gilberth is talking about here
<mrcom>
bike: Yes, that's the point.
<bike>
in ((setf foo) bar), (setf foo) is not evaluated. ((setf foo) bar) = (funcall #'(setf foo) bar). it's not very involved
n8n has joined #commonlisp
<mrcom>
gilberth: Yep, I'm aware of L1 vs. L2. L2 is a blaster, L1 is a lightsaber for a more civilized age. Know which one I'd grab first, though...
<gilberth>
Yes. Also like ((lambda ...) ...) = (funcall #'(lambda ...) ...)
dino_tutter has quit [Ping timeout: 255 seconds]
<gilberth>
SETF is the exception here. I view #'.. as getting the function that I would get as <fun> in a form like (<fun> ...). Works with symbols, works with lambda, doesn't with (SETF FOO). Makes no sense.
<mrcom>
bike: Only ((setf foo) bar) doesn't work. Which is to be expected.
<gilberth>
Why is that expected?
<mrcom>
Because function calls aren't totally orthogonal. The first argument is unevaluated.
<mrcom>
(first argument == function designator)
<bike>
but we're not talking about evaluating it, we're talking about treating it as a function name
<gilberth>
Yes, and (SETF FOO) is a function designator.
<mrcom>
Is it?
<bike>
it's a function name
<gilberth>
Yes, it is. Or why would #'(setf foo) be happy?
<bike>
strictly speaking, a function designator is a function or a symbol naming a function
<gilberth>
Or FDEFINITION for that matter.
<bike>
but "function name" is the appropriate thing here, since (#.(fdefinition 'foo) ...) would be pretty weird
pve has quit [Quit: leaving]
<gilberth>
Note that (SETF FOO) is a function name. It doesn't need to be a symbol.
NotThatRPG has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<gilberth>
bike: Yes, they call that an extended function designator what I thought would be a function designator. A function name is not a function designator, but an extended function designator. Confusing, eh?
<bike>
a bit, yes. it also means that (funcall '(setf foo) ...) is illegal
<bike>
even though (funcall #'(setf foo) ...) and (funcall (fdefinition '(setf foo)) ...) are hunky dory
<gilberth>
Oh, indeed.
<gilberth>
Illustrates my point. This must be confusing and surprising to newbies.
<bike>
it is a straightforward example of inconsistency, yes
<bike>
i think "extended function designator" is only used for disassemble
synchromesh has quit [Read error: Connection reset by peer]
synchromesh has joined #commonlisp
<gilberth>
bike: There are so many definitions, I haven't internalized any. There must be one for the argument of FUNCTION and one for the first element in a form.
<gilberth>
I still propose to have the reverse. #, is free now, so let's make (#,X Y) = (funcall X Y).
josrr has quit [Remote host closed the connection]
<bike>
i don't think the set of things that the first element of a form can be actually has a glossary term
<phoe>
gilberth: thanks
nij- has quit [Ping timeout: 246 seconds]
<mrcom>
The short version of the story is that function calls, in code, involve some reader magic. That's why you need APPLY and FUNCALL.
<gilberth>
There is no reader magic.
<phoe>
not really reader magic
<phoe>
just the way the language is defined
<mrcom>
When the reader sees a top-level (FOO 1 2 3), it treats it differently than, say, (DEFVAR x (list #'foo 1 2 3)).
<phoe>
no
<phoe>
the reader just returns lists
<phoe>
it doesn't care what these lists contain
<gilberth>
Yes, and the language is defined in terms of those lists.
<phoe>
it's the job of the evaluator and/or compiler to tell FOO and DEFVAR apart
<phoe>
or rather, to tell the four-element list (FOO 1 2 3) and the five-element list (LIST (FUNCTION FOO) 1 2 3) apart
<bike>
you can do (eval (cons 'foo (list 1 2 3))) perfectly well
<phoe>
and then also the fact that the latter is wrapped in a DEFVAR
mesuutt has joined #commonlisp
<mrcom>
OK, corrected.
<phoe>
the reader is just a function that eats text and pops out Lisp data, with the exception of #. where it can drop into the evaluator
josrr has joined #commonlisp
<gilberth>
Or you can say ,(eval (cdr '(foo + 1 2)))
<ixelp>
(eval (cdr '(foo + 1 2))) => 3
<gilberth>
This + symbol as the second list element of '(foo + 1 2) is as fit as a function as if it would have been the first. EVAL just sees ,(cdr '(foo + 1 2))
<ixelp>
(cdr '(foo + 1 2)) => (+ 1 2)
<gilberth>
It then ponders: Oh, a list, let's look at the CAR. It doesn't look special? Must be a function to invoke, lets apply #'+ to 1 and 2.
<gilberth>
No matter how this list (+ 1 2) was made.
<gilberth>
Same: ,(eval (list '+ 1 2))
<ixelp>
(eval (list '+ 1 2)) => 3
mesuutt has quit [Ping timeout: 260 seconds]
donleo has quit [Ping timeout: 256 seconds]
mesuutt has joined #commonlisp
jmercouris1 has joined #commonlisp
yitzi has quit [Remote host closed the connection]
attila_lendvai_ has quit [Ping timeout: 268 seconds]
mesuutt has quit [Ping timeout: 252 seconds]
chomwitt has quit [Ping timeout: 256 seconds]
jmercouris1 has quit [Quit: jmercouris1]
pranav has joined #commonlisp
varjag has quit [Ping timeout: 252 seconds]
<mrcom>
To add to the list of inconsistencies, the EVAL car must be a symbol or lambda. Can't be a function, so car isn't a function designator or extended FD.
rgherdt has quit [Remote host closed the connection]
<gilberth>
That's imho not particular inconsistent imho. FUNCTION doesn't work with functions either ,(values #'#.#'car) doesn't work either.
<ixelp>
(values #'#.#'car) ERROR: While compiling an anonymous function : ↩ #<Compiled-function CAR #x14021F6E> is not a valid lambda expression.
NotThatRPG has joined #commonlisp
<mrcom>
Hmm. Off-topic.. I wonder how long a string you can feed the bot. Could you, for example, feed it the source for ELIZA?
<gilberth>
The IRC protocol sets the limit.
<mrcom>
,(make-instance 'eliza :snark 0.7)
<ixelp>
ERROR: Class named ELIZA not found.
<gilberth>
The total length of an IRC message (including everything not just the text) is 512 octets.
<gilberth>
* the limit ;I'm tired.
<gilberth>
Someone turned colour off here. This bot is more colorful.
pfdietz has quit [Quit: Client closed]
<gilberth>
Besides the bot has Alzheimer's. Even you when you managed to feed it ELIZA, the next message it will have forgotten all about it.
alcor has quit [Ping timeout: 260 seconds]
<mrcom>
Which one is it? Lispbot?
<gilberth>
I was talking about ixelp.
dra has quit [Remote host closed the connection]
<mrcom>
Yeah, thought that was just a nick. Don't see anything doing a web search.
josrr has quit [Remote host closed the connection]
<gilberth>
It's one of its kind.
<mrcom>
Hah! Google does bring up an irclog with you discussing it:)
<mrcom>
Just a one-liner, 'it checks that the stuff after the comma at least parses'
<mrcom>
You wrote it? How is the Alzheimer's achieved? Reloading the image each time?
<gilberth>
Yes, a fresh copy started with each request.
vats has joined #commonlisp
<gilberth>
Otherwise people would play pranks.
josrr has joined #commonlisp
<mrcom>
I looked at input-safeing CL instances, and concluded it was a *lot* harder than it looked.
<gilberth>
ixelp has no access to the internet that limits the damage that it could do.
nij- has joined #commonlisp
<mrcom>
I think you basically need SICL first-class environments. Or re-boot.
<gilberth>
To begin with Lisp is not a safe language.
jamesmartinez has joined #commonlisp
<gilberth>
With (safety 0) you can do about anything. And ixelp's very purpose to eval whatever you say.
<mrcom>
No, no it's not. Not foot-gun like C++, but no bade guards either.
<mrcom>
s/bade/blade/
<gilberth>
Still, I ponder how to make ixelp safe. I figured by not plugging a network cable into the machine that it runs on would be the only way that I could have sound sleep.
<gilberth>
And with (SAFETY 0) all bets are off. You can easily peek and poke around at whatever you want.
luca_ has joined #commonlisp
luca_ is now known as OwlWizard
<mrcom>
I'm torn between "don't be the guy who is why we can't have nice things" and "I wonder if he thought of...".
<mrcom>
I mean, technically, ixelp *does* have Internet access... it's just through IRC.
<gilberth>
It doesn't have any network access.
kevingal has joined #commonlisp
<mrcom>
I mean the text gets to it somehow, and the results come back. Not general IP connection.
mesuutt has joined #commonlisp
<bike>
does ccl have something like sbcl's restrict-compiler-policy? you could take care of safety 0 that way
<gilberth>
Yes, but that's the only channel that you have. And all you get is one form to evaluate.
<mrcom>
gilberth: Yessss........ (smiles)
<gilberth>
bike: I won't rely on anything like that.
<gilberth>
Otherwise you could have that with any Lisp. Just unintern CL:SAFETY, then nobody can mess with it.
<gilberth>
Or CL:OPTIMIZE.
<mrcom>
bike: I don't think just restricting the compiler would do that. The problem is protecting global state.
<mrcom>
Global state including things like reading and writing streams.
<gilberth>
Well, for a bot there is more. You want to chroot and you want to set ulimits so that nobody could send a fork bomb.
<gilberth>
As ixelp was new, people tried to break ixelp. A fork bomb was the obvious choice. Or just plain (LOOP).
<mrcom>
Bah... boring.
mesuutt has quit [Ping timeout: 264 seconds]
<mrcom>
But I guess you got to start somewhere.
<gilberth>
Well, I'm not an expert in those things, but thinking that I haven't thought about those attempts was a bit insulting.
<mrcom>
I'd be looking more at tapping into *standard-input*.
<gilberth>
Still, even when you manage to hijack it, the damage is limited with no network at all.
<bike>
how does it communicate with IRC?
<gilberth>
RS232
<mrcom>
Good enough.
<bike>
ah.
<bike>
guess that's one way to do it
<gilberth>
There is a bot which talks IRC and it sends requests to a Pi over RS232.