aindilis has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
aindilis has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
_whitelogger has joined #lisp
lavaflow has quit [Read error: Connection reset by peer]
pjb has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
dddddd has quit [Remote host closed the connection]
lavaflow has joined #lisp
Guest13389 has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
anamorphic has joined #lisp
epr0xe has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
anamorphic has quit [Quit: anamorphic]
Roy_Fokker has quit [Read error: Connection reset by peer]
Guest13389 has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
Josh_2 has quit [Remote host closed the connection]
rocx has joined #lisp
<LdBeth>
Good evening
dale has joined #lisp
<buffergn0me>
evening
fikka has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
esrse has joined #lisp
fikka has joined #lisp
greenb has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
<greenb>
Is it feasible to look for a job as a Lisp programmer?
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<astronavt>
clojure maybe
<greenb>
astronavt: That seems to be the only one with job listings in any amount.
<astronavt>
i mean, allegro, clozure, and lispworks have both employees and clients. so in theory yes? i know at least a few ppl here are lisp programmers at work
<astronavt>
is there a CL -> wasm compiler yet? that might open things up a bit more
<greenb>
I think so.
<greenb>
No, only to JS at the moment.
<astronavt>
cl -> js is a start
Kundry_Wag has quit [Ping timeout: 245 seconds]
igemnace has quit [Quit: WeeChat 2.3]
<greenb>
There's been a Scheme->WebAssembly compiler for some time now, but IDK if anyone uses Scheme (which is a shame, because it's strictly superior to Python other than in library count AFAICT).
<greenb>
in everything other*
<greenb>
I can't write today.
<astronavt>
scheme isnt going anywhere
<astronavt>
guile is coming back w/ guix
<no-defun-allowed>
that's true
<no-defun-allowed>
meh, guix is still a unixlike
<astronavt>
it has a tight small community and some very fast compilers
<astronavt>
#scheme is active
<greenb>
I can't wait until Guile gets an AOT compiler or tracing JIT in v3.0. It does have an active community, but I meant use in the workplace.
arescorpio has quit [Quit: Leaving.]
<meepdeew>
Are there any cl->js tools that target es6/2015?
fikka has joined #lisp
<astronavt>
greenb whats wrong with any of the other AOT schemes
dented42 has joined #lisp
<greenb>
astronavt: Nothing, just that you can't get a job writing in them. Well, they're not Kernel, but neither is CL.
<greenb>
Just settle for writing in one language at work and another at home?
fikka has quit [Ping timeout: 252 seconds]
cmjones has quit [Ping timeout: 252 seconds]
<astronavt>
i just want a typed lisp, is that so much to ask for
<astronavt>
(is julia a lisp)
Bike has quit [Quit: Lost terminal]
<no-defun-allowed>
typed and lisp don't mix
<astronavt>
i dont fully understand why
<astronavt>
gradually typed is fine
<no-defun-allowed>
CL already does that
<astronavt>
does it?
<LdBeth>
Gradually type does nothing
fikka has joined #lisp
anunnaki has joined #lisp
<astronavt>
why nothin?
<astronavt>
g*
<astronavt>
it works great in cython and julia, for example
<LdBeth>
It’s like you made a fence, and you have to break it frequently to use it
<astronavt>
not sure i understand
<LdBeth>
It can’t guarantee soundness
<greenb>
astronavt: The Racket people found out how to add types to Lisp. See "Type Systems As Macros".
<greenb>
There's also the earlier Typed Racket, but that's a hairy mess of interleaving hygienic macro expansion with runtime evaluation.
<astronavt>
i actually have used typed racket
<astronavt>
it was nice
<astronavt>
it had refinement types, i wrote a tax calculator with it
<astronavt>
im not smart enough to understand this though
<greenb>
However, an analysis of Typed Racket (which is gradually typed) showed that both pure dynamic typing and pure static typing were faster than a mix thereof.
<astronavt>
im not surprised. im also not sure i need dynamic typing, just good enough inference that i dont need to declare types everywhere
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
fikka has quit [Ping timeout: 246 seconds]
<astronavt>
i have to start writing CL again
<greenb>
IDK if this result holds only for the peculiar Typed Racket system. I think "Type Systems As Macros" is applicable to unhygienic macro systems (but don't quote me on that).
<astronavt>
" To implement the type system, programmers write type checking rules resembling traditional judgment syntax. To implement the semantics, they incorporate elaborations into these rules"
<astronavt>
idk what that is, this clearly is not for me
<fiddlerwoaroof>
There's a Strange Loop talk from this year that explains some of the decisions behind it
pjb has quit [Ping timeout: 260 seconds]
anewuser has quit [Ping timeout: 252 seconds]
froggey has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 245 seconds]
froggey has joined #lisp
<no-defun-allowed>
still wouldn't bother tbh
shifty has quit [Ping timeout: 246 seconds]
pierpal has joined #lisp
fikka has joined #lisp
epr0xe has joined #lisp
nly has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
acolarh has quit [Ping timeout: 246 seconds]
pierpal has quit [Ping timeout: 272 seconds]
jasmith has joined #lisp
epr0xe has quit [Quit: epr0xe]
Inline has quit [Remote host closed the connection]
fikka has joined #lisp
acolarh has joined #lisp
fikka has quit [Ping timeout: 244 seconds]
<aeth>
fiddlerwoaroof: I would much rather have an extension to Common Lisp than a separate typed Lisp. Sort of like how Typed Racket can use all of the existing Racket code that's out there instead of starting from 0
<aeth>
(Which is probably why Typed Racket is the go-to example for a typed Lisp atm)
ryan_vw has quit [Ping timeout: 264 seconds]
<aeth>
You would just need to be able to handle typed functions (ftype exists, but is not that useful atm) and have improved non-generic data structures (such as better typed conses)
<LdBeth>
That’s because Scheme is a small core
<LdBeth>
Otherwise you have to start from applicative Lisp, which has significantly less features
<aeth>
LdBeth: You can extend Common Lisp more easily than Scheme because you can do it mostly in Common Lisp
<LdBeth>
It’s not even practical to port many Racket features to other Scheme, doesn’t it?
<aeth>
Anything's possible, but if your Scheme is 90% C that means (probably) writing most of your new features in C.
<aeth>
(usually with the alternative being a major performance hit)
<LdBeth>
Which means: a new lisp implementation
pierpal has joined #lisp
<LdBeth>
You can’t do that without touching implementation details
fikka has joined #lisp
<aeth>
LdBeth: Yes, but it wouldn't be a new implementation. Adding a good static type system to SBCL would be no more involved than adding threads or unicode. (The other implementations might be trickier. SBCL already is half of the way to being a statically typed lisp.)
xkapastel has quit [Quit: Connection closed for inactivity]
<aeth>
I wouldn't be surprised if SBCL has more hiding in its internals already
<jackdaniel>
aeth: that's some weird and inaccuarate claim for a language which is specified to be dynamically typed ;/
<jackdaniel>
if sbcl were statically typed, it wouldn't be common lisp
fikka has quit [Ping timeout: 264 seconds]
<aeth>
jackdaniel: SBCL can be both statically typed and dynamically typed
<jackdaniel>
I'm afraid you mix terms. Gradual typing allows you to have some variables typed, static typing is when all types are known at the compilation time
<aeth>
Everyone has a different definition
<aeth>
Last time I had this argument they argued against "gradual typing" as a term
<jackdaniel>
no, terms in this case are not a matter of opinion, please do not use them inproperly because it only increases the confusion
<jackdaniel>
(regarding SBCL having a support for gradual typing – I have no information on that topic)
<aeth>
jackdaniel: As to how it does gradual typing: Most of SBCL's static type checking is done within one file (or within one with-compilation-unit). It also has sb-ext:*derive-function-types* which defaults to NIL that assumes function types never change (which is NIL because it's non-standard behavior).
<aeth>
It's afaik based on the function metadata, so if it knows at compile time that the x in (sin x) isn't a number it can complain (since functions in the CL package can't be redefined, it always behaves like this for functions in the CL package). e.g. (defun foo () (let ((x "foo")) (sin x)))
<jackdaniel>
I would be inclined to believe, that this one is a matter of type inference which is perfectly fine within dynamic typing paradigm. I need to go now though
<aeth>
jackdaniel: It's not just inferred types, though. It's also declared function types.
fikka has joined #lisp
zfree has joined #lisp
<aeth>
You can DECLAIM FTYPE for the function or DECLARE TYPE for individual input variables to the function and it will use those in the same system. e.g. (with-compilation-unit () (defun foo (x) (declare (integer x)) (sin x)) (defun bar () (foo 42f0)))
pierpal has quit [Ping timeout: 264 seconds]
<aeth>
Imo when it infers the ftype, it's type inference, when it respects the type declaration it's static type checking. (foo 42f0) will work perfectly fine in CLISP and will probably be caught only at runtime in many implementations that do something with type declarations.
fikka has quit [Ping timeout: 252 seconds]
<aeth>
You could also have it catch something like (in case 42f0 is too type inferency): (with-compilation-unit () (defun foo (x) (declare (integer x)) (sin x)) (defun bar (x) (declare (single-float x)) (foo x)))
<aeth>
But, I mean, I'll gladly call this gradual typing as long as I get to keep using it.
dented42 has joined #lisp
<LdBeth>
aeth: Although I agree there will be no necessity distinguish static or dynamic types in foreseen future, and I think I know what you mean, that is not the thing I expected to be well integrated with CL. For example, how will the method dispatch work in such a type system?
<aeth>
What's missing is (1) a way to store non-T (just structs and specialized-arrays and declared/declaimed variables afaik) and (2) a way for you (not the compiler) to do something meaningful with ftypes.
<aeth>
(oh, I forgot that you can declare conses, I think the way it's done requires walking through the list to verify each time? Instead of just having a foo-list that you can just check the first element since its cdr must be foo-cons or nil)
<aeth>
LdBeth: Anyway, I personally think you could (for the most part) add the useful stuff from modern static type systems to an existing Lisp (which would make the result gradually typed! I'll concede that!) and have it just work alongside what's already there, just like they added the useful stuff from modern OOP to existing Lisps in its own, Lispy way.
<astronavt>
this went over my head quickly but im happy it started a good discussion
fikka has joined #lisp
<astronavt>
i just like types because, as a programmer, it means i need to keep less in my brain at once
<astronavt>
and the interpreter/compiler can help prevent me from being stupid
<LdBeth>
Blah, I don’t think there’s any wrong using a existed implementation, but I discourage to actually do it without some common agreements on how would the type system work
<fiddlerwoaroof>
aeth: I got disconnected
<LdBeth>
Otherwise it would probably squandered cause not fitting people’s need
<fiddlerwoaroof>
Hackett isn't a "new lisp", it's built on top of racket
<fiddlerwoaroof>
It's a reimplementation of the "Types as Macros" paper referred to earlier
ryan_vw has joined #lisp
anunnaki has quit [Quit: leaving]
<fiddlerwoaroof>
But, the "types as macros" paper focuses on a DSL for describing the type systems of DSLs while Hackett is trying to be a Ha(skell) built on top of (Ra)cket[t]t
<aeth>
LdBeth: I disagree what you say about gradual typing being useless, btw. Everything has a static type, it's just usually T. You could still do useful things as long as the part of a program that heavily uses types don't have to break out of it. Right now, you would because you basically can, with few exceptions, only store T. Put an integer in a hash table and then take it out in that same function and SBCL will forget it's an integer iirc.
anunnaki has joined #lisp
<aeth>
A lot of a program doesn't really care about the type of something.
fikka has quit [Ping timeout: 240 seconds]
<aeth>
Even when you're doing something that benefits from static types.
<fiddlerwoaroof>
Hackett is interesting because the types are about more than correctness, because it has bidirectional type inference, the types can be used to pick which implementation of your functions to use and are not limited to just checking correctness.
<LdBeth>
If everything is T, having gradually type doesn’t make a difference on optimization or safety
<astronavt>
LdBeth is there a difference between gradual and optional typing
<astronavt>
i see both terms used
<aeth>
LdBeth: As it is right now, SBCL can infer or use the declarations for a lot of things, especially numbers and arrays.
<LdBeth>
So why bother to make the type system explicit
<fiddlerwoaroof>
i.e. in most type systems, if you erase the types, the program still makes sense. With a haskell-style type system, the types can be used as a kind of "global" macro
<aeth>
It would be a very unlispy thing to *force* people into declaring types, though, even if you *could* make a program that was 100% known-at-compile-time types (which you can't really do right now except for numeric code)
mrblack has quit [Remote host closed the connection]
<LdBeth>
astronavt: From my person understanding I don’t think there’s difference
<aeth>
Lisp is about giving you everything and then if you want to have a certain style you discipline yourself into using that style.
anunnaki is now known as cmjones
<aeth>
Forcing people into static type declarations for static type checking would be very unlispy, but optionally permitting everything to have known-at-compile-time types isn't unlispy.
mrblack has joined #lisp
<aeth>
(And Lispers would probably rebel and declare most things T if they had to declare)
<LdBeth>
Why not calculate the type instead of declaring
<astronavt>
LdBeth again, look at languages like Julia
<astronavt>
most types are inferred
<astronavt>
in some cases you can make the program run faster by declaring types, which helps the JIT compiler optimize
<LdBeth>
Doesn’t type inference begin from Lisp?
<fiddlerwoaroof>
I'm not sure if lisp or ML was first
<aeth>
LdBeth: SBCL is basically there right now with inference except (1) the main boundary is the function, (2) the even larger boundary is the file or the compilation-unit, and (3) you'll usually lose type information once you store things into a data structure.
<astronavt>
yeah im not saying Julia did it first. just that its a high quality modern example of it working very well in practice
<aeth>
And types for performance are basically only really necessary when there are generic things like + (works on any number) or map (works on any sequence)
<aeth>
(at least in SBCL)
<fiddlerwoaroof>
LdBeth: I believe type inference (at least Hindley-Milner type influence) was invented by the people that made ML
<aeth>
Otherwise e.g. even though it's T when you call CAR on foo, it's going to be a LIST-or-ERROR so the compiler can still make some assumptions
<astronavt>
is ML polymorphic?
<no-defun-allowed>
yes
<astronavt>
mm i like that feature too
<astronavt>
multiple dispatch is fun
pierpal has joined #lisp
<astronavt>
i imagine you could abuse it pretty badly though, relying on IDE to tell you what's happening
<no-defun-allowed>
stuff like val map = ('a -> 'b) -> a -> 'b iirc
<LdBeth>
a first class type system, where types can be calculated and compose without a special concept of run time and compile time
<LdBeth>
And of course type thing can be striped after fully analysis of program
<LdBeth>
Just like what macros behave
<fiddlerwoaroof>
In the most insteresting type systems, you can't really strip the types
<fiddlerwoaroof>
e.g., in Haskell, the types change the interpretation of your program
<jackdaniel>
LdBeth: that makes no sense. what you call "analysis of program" I call a phase of compilation (just like when macros are expanded)
<LdBeth>
That’s true
<fiddlerwoaroof>
What jackdaniel says too
<aeth>
I agree with jackdaniel
<aeth>
macros are in their own phase because they get you 95% of what you want with the alternative (what are they called? fexprs or something?) but with a ton more performance
lavaflow_ has joined #lisp
[X-Scale] has joined #lisp
<aeth>
One of Common Lisp's main goals is to be performant
<LdBeth>
jackdaniel: Lisp probably lacks fancy industrial level features like formal verification, which is where a sophisticated type system will contribute
<aeth>
(Well, potentially performant. The Common Lisp police aren't going to arrest you for making a slow Common Lisp interpreter.)
dented42_ has joined #lisp
<aeth>
LdBeth: Imo, you can't get perfect verification with Common Lisp because too much of its behavior relies on global *foo*s.
les` has joined #lisp
<LdBeth>
So that’s the point where a restricted subset can be made
sauvin_ has joined #lisp
<LdBeth>
And that’s why Scheme goes a little ahead
fikka has joined #lisp
crypto has joined #lisp
<fiddlerwoaroof>
LdBeth: one of the major formal verification systems uses a subset of common lisp
hvxgr_ has joined #lisp
Demosthe1ex has joined #lisp
<fiddlerwoaroof>
ACL2 was used to formally verify the AMD FPU as well as parts of the JVM
<LdBeth>
fiddlerwoaroof: Applicative Lisp, as I mentioned, even more restricted than Scheme
<aeth>
LdBeth: I guess you could watch the globals to see if anything set them if you don't want to just subset CL.
<aeth>
Some of them are fairly rare
<fiddlerwoaroof>
Yeah, it's total (i.e. every function must produce a value in a finite amount of time) so you don't have to deal with the halting problem
<fiddlerwoaroof>
but it uses a subset of common lisp
<fiddlerwoaroof>
as its core language
<fiddlerwoaroof>
The book "the little prover" is a good introduction to this sort of system.
jxy_ has joined #lisp
<LdBeth>
I was looking it last few month, until Apple breaks my CCL
th1nkpad has joined #lisp
<fiddlerwoaroof>
Yeah, I've been putting off the Mojave upgrade until I'm confident that people have worked out the issues
fikka has quit [Ping timeout: 264 seconds]
dented42 has quit [*.net *.split]
jasmith has quit [*.net *.split]
sauvin has quit [*.net *.split]
lavaflow has quit [*.net *.split]
mfiano has quit [*.net *.split]
buffergn0me has quit [*.net *.split]
Kaisyu7 has quit [*.net *.split]
hvxgr has quit [*.net *.split]
joast has quit [*.net *.split]
ski has quit [*.net *.split]
cyberlard has quit [*.net *.split]
Spooktober has quit [*.net *.split]
d4ryus has quit [*.net *.split]
Oddity has quit [*.net *.split]
z0d has quit [*.net *.split]
X-Scale has quit [*.net *.split]
Ekho has quit [*.net *.split]
APic has quit [*.net *.split]
les has quit [*.net *.split]
emerson has quit [*.net *.split]
Demosthenex has quit [*.net *.split]
phadthai has quit [*.net *.split]
thinkpad has quit [*.net *.split]
jxy has quit [*.net *.split]
luis has quit [*.net *.split]
cmatei has quit [*.net *.split]
th1nkpad is now known as thinkpad
[X-Scale] is now known as X-Scale
<LdBeth>
the latest development snapshot compiles, but sometimes quit under high memory pressure.
shifty has joined #lisp
Spooktober has joined #lisp
Ekho- has joined #lisp
fsmunoz has quit [Ping timeout: 246 seconds]
eminhi has joined #lisp
pjb has joined #lisp
mfiano has joined #lisp
phadthai has joined #lisp
cmatei has joined #lisp
d4ryus has joined #lisp
APic has joined #lisp
cyberlard has joined #lisp
fikka has joined #lisp
pjb has quit [Ping timeout: 260 seconds]
lemoinem has quit [Ping timeout: 272 seconds]
lemoinem has joined #lisp
sauvin_ is now known as Sauvin
holycow has joined #lisp
makomo has joined #lisp
igemnace has joined #lisp
<phoe>
I'm looking for proofreading on this chapter about Alexandria.
<phoe>
beach: especially from you, since you're the only Alexandria maintainer I know.
rumbler31 has quit [Remote host closed the connection]
fikka has joined #lisp
emerson has joined #lisp
epr0xe has quit [Quit: epr0xe]
cylb has joined #lisp
razzy has quit [Ping timeout: 260 seconds]
pierpal has joined #lisp
rocx has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 252 seconds]
dueyfinster has joined #lisp
nicksmaddog has joined #lisp
anamorphic has joined #lisp
pierpal has quit [Ping timeout: 244 seconds]
jochens has quit [Remote host closed the connection]
jochens has joined #lisp
random-nick has joined #lisp
jochens has quit [Remote host closed the connection]
jochens has joined #lisp
nokdoot has quit [Remote host closed the connection]
nokdoot has joined #lisp
cage_ has joined #lisp
SaganMan has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
pjb has joined #lisp
Josh_2 has joined #lisp
joast has joined #lisp
fikka has joined #lisp
atgreen_ has joined #lisp
astronavt has joined #lisp
anamorphic has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 246 seconds]
esrse has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 272 seconds]
astronavt_ has joined #lisp
fikka has joined #lisp
sjl has joined #lisp
astronavt has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 252 seconds]
nowhere_man has quit [Ping timeout: 276 seconds]
heisig has quit [Quit: Leaving]
warweasle has joined #lisp
fikka has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
Josh_2 has joined #lisp
fikka has quit [Ping timeout: 250 seconds]
fikka has joined #lisp
Bike has joined #lisp
fikka has quit [Read error: Connection reset by peer]
pjb has quit [Ping timeout: 252 seconds]
warweasle has quit [Quit: fuck]
dale_ has joined #lisp
dale_ is now known as dale
rippa has joined #lisp
fikka has joined #lisp
ogamita has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
kajo has joined #lisp
moei has joined #lisp
fikka has joined #lisp
nowhere_man has joined #lisp
froggey has quit [Ping timeout: 272 seconds]
fikka has quit [Ping timeout: 260 seconds]
froggey has joined #lisp
orivej has joined #lisp
nicksmaddog has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
hiroaki has joined #lisp
rumbler31 has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
astronavt_ is now known as astronavt
cylb has quit [Remote host closed the connection]
cylb has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
nowhere_man has joined #lisp
dale has quit [Quit: dale]
fikka has joined #lisp
dale has joined #lisp
ogamita has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 252 seconds]
ebzzry has joined #lisp
<knobo>
Is it possible to find out what state the compiler is in when my load fails? (:compile-toplevel or :load-toplevel etc)
<Bike>
you're loading a fasl?
<knobo>
(ql:quickload "my-project")
<Bike>
the backtrace should make it fairly obvious if it's in the middle of the compiler. you can also look whether fasl files have been produced.
<Bike>
what's the error?
fikka has joined #lisp
<knobo>
if i do (defvar *web* (make-instance '<web>)) it works, but if I import *web* from another package, and then do (setf *web* (make-instance '<web>)) it fails.
<Bike>
I meant, what is the error message.
<knobo>
Bike: the make-instance hash a initialize-instance method that is not called before it's too late.
<knobo>
Bike: so later in the code I get There is no applicable method for the generic function #<STANDARD-GENERIC-FUNCTION (COMMON-LISP:SETF NINGLE.APP:ROUTE) (1)> when called with arguments .....
meepdeew has quit [Remote host closed the connection]
<Bike>
so the problem has to do with <web> rather than *web*?
fikka has quit [Ping timeout: 252 seconds]
<knobo>
I don't know.
<knobo>
Ahh... fixed it.
papachan has quit [Quit: WeeChat 2.2]
fikka has joined #lisp
fikka has quit [Read error: Connection reset by peer]
meepdeew has joined #lisp
fikka has joined #lisp
Oddity has joined #lisp
meepdeew has quit [Ping timeout: 246 seconds]
fikka has quit [Ping timeout: 250 seconds]
nicksmaddog has joined #lisp
shka_ has quit [Quit: WeeChat 1.9.1]
fikka has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
aindilis has quit [Remote host closed the connection]
nicksmaddog is now known as Guest82324
Guest82324 has quit [Killed (card.freenode.net (Nickname regained by services))]
<phoe>
All conditions signaled inside FOO are going to be printed, but execution will keep on going.
<phoe>
This way, handlers down the stack can try handling them, too.
<emaczen>
phoe: Thanks
<emaczen>
phoe: I have a hard time keeping track of conditions...
Jesin has quit [Quit: Leaving]
frgo has quit []
frgo has joined #lisp
meepdeew has joined #lisp
meepdeew has quit [Remote host closed the connection]
anamorphic has quit [Quit: anamorphic]
atgreen_ has quit [Ping timeout: 264 seconds]
anamorphic has joined #lisp
meepdeew has joined #lisp
cylb has quit [Ping timeout: 244 seconds]
fsmunoz has joined #lisp
rumbler31 has joined #lisp
earl-ducaine has quit [Ping timeout: 245 seconds]
rumbler31 has quit [Remote host closed the connection]
drduck has joined #lisp
<drduck>
Anyone know of lisp being used in cybersecurity?
<no-defun-allowed>
If they can't read it, they can't crack it -- I mean I haven't heard of it used like that.
sjl_ has joined #lisp
aydio has quit [Quit: WeeChat 2.2]
<drduck>
I meant both on the offensive and defensive side.
frodef has quit [Ping timeout: 240 seconds]
<pjb>
drduck: security by obscurity is no security. There are AI-based malware. You could implement that in lisp. There are AI-based countermeasures. You could implement that in lisp.
<pjb>
drduck: Please don’t assume Lisp is only useful for Animation and Graphics, AI, Bioinformatics, B2B and E-Commerce, Data Mining, EDA/Semiconductor applications, Expert Systems, Finance, Intelligent Agents, Knowledge Management, Mechanical CAD, Modeling and Simulation, Natural Language, Optimization, Research, Risk Analysis, Scheduling, Telecom, and Web Authoring just because these are the only things they happened to list.
sjl has quit [Ping timeout: 252 seconds]
asymptotically has quit [Remote host closed the connection]
asymptotically has joined #lisp
dueyfinster has joined #lisp
<no-defun-allowed>
Please don't assume Lisp is only useful for malware since we infected your computer with it.
anamorphic has quit [Quit: anamorphic]
dueyfinster has quit [Client Quit]
<drduck>
:O
arbv2 has joined #lisp
arbv2 has quit [Client Quit]
asymptotically has quit [Remote host closed the connection]
asymptotically has joined #lisp
eddof13 has quit [Quit: eddof13]
arbv2 has joined #lisp
arbv2 has quit [Client Quit]
arbv has joined #lisp
nirved has quit [Quit: Leaving]
arbv has quit [Client Quit]
rumbler31 has joined #lisp
eddof13 has joined #lisp
Bike has quit [Quit: Page closed]
asymptotically2 has joined #lisp
asymptotically has quit [Disconnected by services]
asymptotically2 is now known as asymptotically
<jcowan>
Actually the Lisp most used by malware authors is Tinyscheme.