phoe changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language | <> <> <> <> | SBCL 1.4.16, CMUCL 21b, ECL 16.1.3, CCL 1.11.5, ABCL 1.5.0
random-nick has quit [Read error: Connection reset by peer]
metallicus has joined #lisp
LiamH has quit [Quit: Leaving.]
keep_learning has joined #lisp
<no-defun-allowed> i got some code compiled with my llvm IR library
sjl has joined #lisp
keep_learning has quit [Client Quit]
Bike has joined #lisp
keep_learning has joined #lisp
quazimodo has joined #lisp
ckonstanski has quit [Remote host closed the connection]
CCDelivery has joined #lisp
robdog has quit [Ping timeout: 268 seconds]
matijja has quit [Ping timeout: 245 seconds]
sjl has quit [Ping timeout: 245 seconds]
ebrasca has joined #lisp
holycow has quit [Quit: Lost terminal]
CCDelivery has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
metallicus has quit [Quit: WeeChat 2.3]
akoana has joined #lisp
akoana has left #lisp [#lisp]
ah_ has joined #lisp
ah_ is now known as akoana
akoana has left #lisp [#lisp]
CCDelivery has joined #lisp
<Xach> what i do??
<no-defun-allowed> do a barrel roll!
markoong has quit [Read error: Connection reset by peer]
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
X-Scale` is now known as X-Scale
ntbre has quit [Quit: ntbre]
ntbre has joined #lisp
akoana has joined #lisp
jeosol has joined #lisp
amerlyq has quit [Quit: amerlyq]
nydel has quit [Quit: WeeChat 2.1]
aindilis has quit [Read error: Connection reset by peer]
aindilis has joined #lisp
<jeosol> morning guys
xkapastel has quit [Quit: Connection closed for inactivity]
dddddd has quit [Remote host closed the connection]
jeosol has quit [Quit: Page closed]
jeosol has joined #lisp
<jeosol> morning
smokeink has joined #lisp
zmv has joined #lisp
eschatologist has quit [Ping timeout: 240 seconds]
eschatologist has joined #lisp
smokeink has quit [Remote host closed the connection]
igemnace has joined #lisp
ntbre has quit [Quit: ntbre]
orivej has joined #lisp
ntbre has joined #lisp
ntbre has quit [Client Quit]
ebrasca has quit [Remote host closed the connection]
orivej has quit [Ping timeout: 245 seconds]
orivej has joined #lisp
ntbre has joined #lisp
<LdBeth> GG
ntbre has quit [Quit: ntbre]
jeosol has quit [Ping timeout: 256 seconds]
ntbre has joined #lisp
volkov has joined #lisp
CCDelivery has quit [Remote host closed the connection]
akater has quit [Quit: WeeChat 2.3]
akater has joined #lisp
<beach> Good morning everyone!
<margaritamike> does fare still do common lisp or is he on to something else now?
<akater> SBCL creates instances of a certain class with slot values that clearly outdated. There is a PLIST slot in sbcl's class implementation where I found some traces of old definitions. Can anyone offer any advice on this?
<no-defun-allowed> beach: my teacher said that it would be possible to work on the double entry bookeeping system
<akater> (I wish I could fix this without restarting sbcl)
<beach> no-defun-allowed: Great!
<beach> akater: I am not sure what you mean. Do you mean "outdated", as in some code lingers on and should have been removed years ago? Or do you mean that it wasn't updated properly when it should have been? Or something else?
<beach> akater: What was the nature of these "old definitions", and how did you discover them?
milanj has quit [Quit: This computer has gone to sleep]
<akater> The definition of a class had long been modified but some slots are still initialized as if it were not.
<beach> It may have to do with the requirement on CLOS to be able to update old instances.
<beach> I don't know the details of what SBCL does, but in SICL, every instance has a slot containing a list of all the effective slot definitions of the class, as it was when the instance was created.
<beach> So if you modify a class that has existing instances, there will be instances with slot definitions on that list that no longer exist in the corresponding class. And that is not just normal, it is a requirement.
<beach> However, it would be hard to see those slot definitions, because the instance gets updated whenever it is an argument to some generic function that specializes on its class, which is why I asked how you discovered those old definitions.
<beach> no-defun-allowed: So what's the plan now? You still have time to think it over, right?
<akater> I'm having issues with *fresh* instances, returned by make-instance or allocate-instance. closer-mop:slot-definition-initform of class slots look like they should but some of them don't seem to have an effect
charh has quit [Ping timeout: 246 seconds]
<beach> akater: Sounds like a case for #sbcl.
<volkov> ((((hey guys))))
<beach> Hello volkov.
<volkov> (((how goes it)))
nowhere_man has joined #lisp
<beach> volkov: You must be new here.
<LdBeth> T
<LdBeth> NIL
<volkov> I'll be reading SICP today.
<volkov> beach: beach
<LdBeth> BECAUSE WE DON’t trolling like this
<beach> volkov: Then you should know that SICP uses the Scheme programming language, whereas this channel is dedicated to Common Lisp.
<beach> volkov: So if you have questions about the language used in the book, then this channel is not the right place.
<volkov> hmm let me check
<aeth> #scheme will probably help you with SICP better
dale_ is now known as dale
<volkov> turn out it true
<volkov> Scheme dialect of Lisp
<volkov> sry for troll
<aeth> as for trolling the only trolling we do here is diss other languages for not having Lisp machines. /s
<LdBeth> beach: is it supposed to update an old instance explicitly when that class is redefined?
<beach> volkov: It is not widely agreed upon what languages are "dialects of Lisp", which is why this channel is dedicated to a language with a precise definition, to avoid discussions about what is Lisp and what is not.
<beach> LdBeth: The spec says it does it at some point before it is used.
<aeth> ##lisp is for the lisp family
<verisimilitude> On that topic, Peter Norvig is wrong.
<beach> LdBeth: No implementation I know would do it immediately, because that would require keeping a pointer to every instance.
<akater> I find RJ's arguments (on code sharing, in particular) convincing when he argues that Scheme or Clojure are not Lisps.
<loli> oh, what are his arguments?
<LdBeth> I understand it will be easy to defer unnecessary computation
<beach> Like I said, those are futile discussions that don't belong here.
<beach> ... about what languages are Lisp dialects I mean.
<verisimilitude> I think we can all agree Python isn't Lisp, beach.
<beach> verisimilitude: I think we should avoid discussing the topic.
<verisimilitude> Well, I can't discuss it by myself, or rather I won't.
<verisimilitude> So, alright.
<beach> LdBeth: Yes, not only that, you wouldn't want to keep instances alive unnecessarily, so you would need weak pointers, etc.
<verisimilitude> There's another technique, beach.
<volkov> beach: i will leave educated discussions about Lisp to u guys. im just a guy with some experience in slicing Python lists. i just want to deep my knowledge reading SICP. bye i will go to #scheme
<volkov> yeah, beach!
<verisimilitude> The Lisp implementation is already keeping track of every object; it could simply traverse the entire object list to update instances.
<beach> verisimilitude: Sure, if you want something even worse, you could do that.
<verisimilitude> How is that worse?
<beach> It would take time.
<beach> It would be equivalent to a full GC.
<verisimilitude> Well, I'm particularly interested in eventually developing a Common Lisp that focuses on size without regard for speed, so this is a valid strategy for me. It's just a thought.
<verisimilitude> Every time something consumes extra space, there's some thinking that can be done to eliminate that. Why store something in multiple lists when you can store it in one and all of that.
<beach> LdBeth: If you want to know how PCL does it, it is documented in the paper about it. SICL assigns a unique number to each class and propagates it to its instances. When a class is updated, it gets a new number, and generic functions that use the old number are "invalidated".
<beach> So when an old instance is used in some generic function, it is automatically detected, and the instance is updated.
<verisimilitude> If you only update instances when they're used, you'd need to store the necessary changes in some way, somewhere.
<no-defun-allowed> beach: my teacher did suggest it would be a very good task, so I probably will stick to it.
<beach> no-defun-allowed: Oh, excellent! No protests with respect to the programming language being used?
<no-defun-allowed> No problems with that.
<verisimilitude> Oh, so you'll be working on a bookkeeping system for your school, no-defun-allowed?
<no-defun-allowed> It's expected schools will teach one language, but students can use any object-oriented language they choose for most tasks.
<no-defun-allowed> verisimilitude: Well, I'll be working on a double-entry bookeeping system, and the "client" is beach.
<verisimilitude> Oh, so this isn't going to see use in a ``real'' environment?
<volkov> sudo pacman -S clisp
<LdBeth> Then you must use a no warranty license:D
<verisimilitude> By ``real'', I mean an environment where it's actually depended on for some purpose and all of that.
<no-defun-allowed> I don't know. My teacher said it didn't have to, as long as there was a good program created.
<no-defun-allowed> volkov: sudo pacman -Rsc clisp; sudo pacman -S sbcl emacs
<verisimilitude> Well, that seems like it could be fun, then.
<no-defun-allowed> The only other constraint was there was some processing involved, a graphical interface, and some type of storage.
<verisimilitude> I'd litter the program with restarts and whatnot so the interactive debugger could be expected to be used by someone other than me, then.
<no-defun-allowed> I assume the REPL shouldn't be touched from the constraints, and that anything should be doable from McCLIM.
<beach> volkov: Another strategy that some people use is to read SICP, but solve the problems in Common Lisp instead. That way they get better help, because #lisp is much more helpful than #scheme (more participants at more hours).
charh has joined #lisp
<no-defun-allowed> I don't remember, does McCLIM have debugger hooks?
<fiddlerwoaroof> no-defun-allowed: there's Clouseau
<beach> no-defun-allowed: It does.
<fiddlerwoaroof> I believe I saw some conversation about a new debugger for McCLIM too
<verisimilitude> Well, the pieces are there to construct a restricted interactive debugger. It's just a thought, though.
<volkov> no-defun-allowed: thanks
<no-defun-allowed> Nice. That sounds quite useful.
<fiddlerwoaroof> I'd be interested in a *debugger-hook* designed for non-programmers
<beach> fiddlerwoaroof: You did. scymtym has written an inspector that is much more competent than the current Clouseau.
iovec has joined #lisp
<verisimilitude> Now, there's an idea for a library, actually: providing a debugger intended for use by non-programmers, so effectively providing a nicer and sanded interface over restarts.
<beach> volkov: Yet another strategy is to give up on SICP, since it is teaching some strange object-oriented techniques, and go for PCL, PAIP, etc. instead.
<verisimilitude> Most people would foam at the mouth if their machines asked them to do anything while a scary number such as 0x1AB97381 were on the screen.
<beach> no-defun-allowed: There are some cute tricks that I often use in my McCLIM applications. I often include an application command that starts the inspector on some aspect of the application contents.
<LdBeth> Well, Common Lisp is already tons friendlier than other programming languages
<verisimilitude> I'm talking about people that don't even read error messages, LdBeth. It's the kind of person who can't follow any instructions whatsoever and usually has someone competent do anything requiring more than scrolling and sharing a dog video do it for them.
charh has quit [Ping timeout: 240 seconds]
<fiddlerwoaroof> It's not just that, it would be useful to have things like some way to specify lists of values for the use-value restarts, etc.
<fiddlerwoaroof> So, instead of having to type the new value in free-form, you select one from a list of pre-vetted values
<beach> Sounds like a job for CLIM presentations and completion.
<fiddlerwoaroof> Yeah, I've been fitfully working on making CLIM usable in my normal computer environment
<beach> Great!
<LdBeth> I think several months ago someone presented typing Math equations with McCLIM,but I forgot where I can find it
<beach> LdBeth: That would be loke with Climaxima.
<LdBeth> Thank you, beach
<beach> I think Climaxima could very well be a very important application for showing the power of Common Lisp and CLIM.
Bike has quit [Quit: Lost terminal]
nikkal has joined #lisp
ntbre has quit [Quit: ntbre]
<akater> Last time I tried to use Maxima (for Android) to solve an ODE, it produced something bizarre for a trivial 2nd order one (constant coefficients)
<loke> akater: Do you have an example?
charh has joined #lisp
<loke> If the solvers cannot produce a full solution kit sometimes gives you a partial solution instea of giving yu an error.
<loke> That may be what you sa?
<loke> saw
<akater> It was a long time ago during a trip, I don't have a record in my journals unfortunately. loke It was a linear ODE with constant coeffs.
<loke> akater: OK, I'm sure there is an explanation :-)
<loke> But yeah, partial solutions for ODE's is common if it can't be solved fully.
<akater> Overall, I found the only Lisp CAS to be sane, is Weyl. Maxima tries to introduce a mainstream syntax, this is an ostruction to programming in it. I wish a Lisp CAS was more like Mathematica.
<akater> It's fairly hard to write properly in this client in a terminal, sorry in advance.
nikkal has quit [Ping timeout: 240 seconds]
<akater> Mathematica introduces infix syntax by means of presentations, essentially. So the regular structure of expressions is never lost.
<loke> akater: Maxima also does the same thing
<loke> I uses a Lisp syntax internally
<akater> (+ 2 3) would give `incorrect syntax')
<loke> akater: Try :lisp (+ 1 2)
<loke> actually, the form is: ((MPLUS) 2 3)
<volkov> beach: thanks. i just googled "what is PCL PAIP etc" and was led to this 11 years old reddit thread
<volkov> now i know the names of the books! i will acquire them and start scouring
<akater> I'm aware there is a way to feed lisp forms to it. But making them somewhat second-class like this is a bad decision. In Mathematica, it's much more smooth. Also, it offers proper expansion which means you never have to learn precedence rules for its infix as long as you use it.
<akater> On Android, I found mangled TeX output. And e.g. :lisp (describe 'integrate) doesn't work.
<loke> akater: The android version is a bit of a mess. It's usabel, not not great
steiner has joined #lisp
<loke> I recommend you try Climaxima instead
rozenglass has joined #lisp
<akater> Anyway, I wish one day I could implement something more appropriate with representations in McCLIM.
<borodust> LdBet
<LdBeth> What you might need is a structured formula editor
<LdBeth> WTH
<loke> akater: So you would prefer to input and display the Sexp forms instead of maths equations?
<borodust> LdBeth fiddlerwoaroof: thanks! i'll look into the issue
<akater> But of course, the fact that Maxima on Android works at all, utilizing codebase with history like this, is amazing and makes Sage look unattractive for me anyway.
<borodust> although would be a bit harder w/o access to the hardware
dale has quit [Quit: dale]
<fiddlerwoaroof> loke: it's probably a pretty niche view, but I generally prefer math in sexp form
<fiddlerwoaroof> For one thing, it means I don't have to think about operator precedence and associativity
<akater> loke: For starters, what I have in mind could display general sexps, not just mathematical expressions. Something arong the lines of (row-box "cons" ("a" "b"))
<akater> ^ that's basically exactly how mathematica does it. It has `box'es of various kinds, incl. those that display in 2D neatly.
<loke> Climaxima can actually do that, to a limited extent. The framework is in place to extend it past the Maxima sexp forms.
<loke> ... Climaxima does the same.
<akater> Good to know!
<loke> Each box is a subexpression. It just arranges those boxes in a maths-kinda way so that the result is standard maths equation syntax
<loke> I don't have a recent video (it works ebtter now) but the general idea is shown here
<akater> I'm still wondering if this interface could be better than purely text-based one. It *should be* but Emacs' pure text way is also impressive. I don't want to lose the ability to jump to text in arbitrary forms on screen.
<fiddlerwoaroof> loke: is climaxima on quicklisp?
<loke> fiddlerwoaroof: No. Mainly because Maxima isn't.
<loke> There are a bunch of dependencies needed as well, so I recommend using the appimage
<fiddlerwoaroof> I'd have to use my linux box for that :)
<loke> fiddlerwoaroof: Sorry for having to drag you away from Windows.
<loke> (not really)
<akater> While Mathematica does presentations right (drew a ton of inspiration from Lisp for sure), its editing capabilities are mediocre. SLIME almost has it all when it comes to presentations, without compromising the convenience of navigation.
<loke> I've never used Mathamatics
<loke> but please tell me what can be improved when it comes to the Climaxima way of doin git.
* fiddlerwoaroof wants someone tom implement a CLIM-like interface for sending text from Lisp to an emacs buffer
<loke> fiddlerwoaroof: Doesn't SLIME already implement that?
<fiddlerwoaroof> For the repl buffer
<fiddlerwoaroof> I've just added a swank-buffer-streams package to swank that implements the beginnings of something like CAPI's collector-panes or CLIM's app pane
<loke> fiddlerwoaroof: Yes. SLIME exploses some functions on the Lisp side that results in an Elisp function being called in Emacs.
volkov has quit [Quit: volkov]
<akater> Some day, I will have time for Climaxima. But for now, I need some tools in CL that I'm missing, and building them will take time.
<fiddlerwoaroof> loke: I'm talking about things like inks and colors and widgets/gadgets
<fiddlerwoaroof> Slime has the building-blocks for such things
<LdBeth> Worth to notice that Sly takes advantages of more modern Emacs features though
<loke> LdBeth: sly also doesn't support presentations, so it's lost kinda half its value there
<fiddlerwoaroof> I'm not really a fan of splitting effort, though
<akater> Sly froze my Emacs almost immediately when I tried flexi-search, or whatever it called. Almost led to data loss. When it happened the 2nd time, I uninstalled it until better times.
akoana has left #lisp ["Leaving"]
<akater> Also, its printer has some ridiculous default settings when it comes to printing in org src blocks.
akoana has joined #lisp
moei has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
<LdBeth> Hard to say if it’s the fault of Emacs, when CCL running in inferior lisp
<LdBeth> crashes the Emacs also crashes
zigpaw has joined #lisp
pierpal has quit [Remote host closed the connection]
anewuser has joined #lisp
<fiddlerwoaroof> LdBeth: interesting, I don't think I've ever seen something like that happen
karlosz has joined #lisp
<LdBeth> the initial story is Apple break something in Mojave
sauvin has joined #lisp
Patternmaster has quit [Ping timeout: 268 seconds]
quazimodo has quit [Ping timeout: 246 seconds]
shrdlu68 has joined #lisp
d4ryus has quit [Quit: WeeChat 2.3]
d4ryus has joined #lisp
schjetne has joined #lisp
zmv has quit [Ping timeout: 246 seconds]
ggole has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
Guest928 has joined #lisp
pierpal has joined #lisp
Guest928 has quit [Ping timeout: 250 seconds]
iovec has joined #lisp
akoana has left #lisp ["Leaving"]
steiner has quit [Ping timeout: 244 seconds]
scymtym has quit [Ping timeout: 240 seconds]
shka_ has joined #lisp
Inline has quit [Quit: Leaving]
themsay has quit [Ping timeout: 246 seconds]
phoe has joined #lisp
<fiddlerwoaroof> Ah, I haven't switched my laptop to Mojave yet :)
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
<LdBeth> Then it's wise to just keep it
<flip214> luis: thanks, will try.
<LdBeth> good night
nullheroes has quit [Quit: WeeChat 1.9.1]
<splittist> good morning
<beach> Hello splittist.
JamesDabron has quit [Ping timeout: 246 seconds]
<flip214> will ELS submissions end today? Then I could start reviewing papers -- last time new versions got in after I had read initial versions...
<beach> It should end today, but I think the authors have the right to upload modified versions later.
jprajzne has joined #lisp
xkapastel has joined #lisp
varjag has joined #lisp
scymtym has joined #lisp
stardiviner has joined #lisp
milanj has joined #lisp
shka_ has quit [Quit: Konversation terminated!]
nullheroes has joined #lisp
angavrilov has joined #lisp
Zaab1t has joined #lisp
akoana has joined #lisp
arpunk has quit [Ping timeout: 268 seconds]
wigust- has joined #lisp
X-Scale` has joined #lisp
wigust has quit [Ping timeout: 272 seconds]
X-Scale has quit [Ping timeout: 246 seconds]
X-Scale` is now known as X-Scale
Kaisyu has joined #lisp
volkov has joined #lisp
arpunk has joined #lisp
hhdave_ has joined #lisp
rozenglass has quit [Ping timeout: 246 seconds]
Arcaelyx has quit [Ping timeout: 244 seconds]
zotan has quit [Ping timeout: 252 seconds]
zotan has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
holycow has joined #lisp
orivej has joined #lisp
karlosz has quit [Quit: karlosz]
volkov has quit [Ping timeout: 256 seconds]
karlosz has joined #lisp
karlosz has quit [Client Quit]
robdog has joined #lisp
akoana has left #lisp ["Leaving"]
xkapastel has quit [Quit: Connection closed for inactivity]
prite has joined #lisp
zaquest has joined #lisp
Essadon has joined #lisp
Essadon has quit [Max SendQ exceeded]
shka_ has joined #lisp
markoong has joined #lisp
igemnace has quit [Quit: WeeChat 2.3]
akoana has joined #lisp
m00natic has joined #lisp
random-nick has joined #lisp
Essadon has joined #lisp
Kaisyu has quit [Quit: Connection closed for inactivity]
varjag has quit [Ping timeout: 268 seconds]
stardiviner has quit [Quit: WeeChat 2.3]
dddddd has joined #lisp
status402 has joined #lisp
q9929t has joined #lisp
refpga has joined #lisp
status402 has quit [Quit: status402]
status402 has joined #lisp
gxt has quit [Ping timeout: 246 seconds]
Lord_of_Life has quit [Ping timeout: 268 seconds]
marvin2 has joined #lisp
Lord_of_Life has joined #lisp
<margaritamike> Does common lisp come with a sandbox environment?
<splittist> margaritamike: not really, no. This is one of the benefits of First-Class Global Environments that is (kinda) part of the SICL project.
<splittist> Depending on what you mean by sandbox, of course.
<margaritamike> In the security sense
<splittist> Trusted and un-trusted code in the same image?
<margaritamike> If that's the proper CL scenario, then yes
<margaritamike> Can you elaborate more, splittist
Younder has quit [Quit: Leaving]
<splittist> The wikipedia definition seems to make clear that this is an OS concern (where the jvm and clr and os-a-likes).
schjetne has quit [Ping timeout: 240 seconds]
<splittist> s/and/are/
<margaritamike> I don't like that the quickdocs page doesn't use https
<margaritamike> Looks like this is a thing, though
varjag has joined #lisp
<margaritamike> ehh maybe this isn't what i was looking for
<splittist> margaritamike: I think it goes like this. A CL image contains an evaluator and a compiler (EVAL and COMPILE). The compiler is necessary for important parts of the system - like CLOS - to operate, so you can't just rip it out. If the untrusted user has access to the compiler, then they can (eventually) do anything, regardless of what you have taken out of the environment to begin with.
<splittist> Having multiple First Class Global Environments would allow the system to have access to COMPILE (and co) - via one environment - while not allowing the untrusted user to have access - via another environment.
<phoe> tl;dr it's impossible with the current implementations, but beach is working on it
<margaritamike> You can't do something like say this lisp program can't write to file or use sockets in a security file?
<margaritamike> Something like java's security manager
<splittist> As I said - that's an OS thing. Perhaps ABCL would work with the the java stuff. Otherwise, use a vast network of containers like everyone does for everything these days (:
<margaritamike> Ehh
<margaritamike> Is that what they do?
<margaritamike> Say you've set your restrictions in Java and you add in a dependency that uses whereas that was previously restricted
<margaritamike> It would be good to catch that with a security policy before it has a change to execute during runtime or whatever
<margaritamike> How does a container help with that?
<margaritamike> Help a noob understand
<splittist> I have no idea. It also seems a bit far from lisp.
Denommus has joined #lisp
Denommus has quit [Remote host closed the connection]
gxt has joined #lisp
<margaritamike> You have a lisp library you bring in from ql:quickload. Unknowingly, it does something malicious
<margaritamike> You don't have the time, and probably not the skill either, to read and understand every line of code from the library
<margaritamike> How do you deal with this? Are you pretty much in the dark?
<margaritamike> Until you read every line of the library's code or notice something strange one day?
kleinie has joined #lisp
<splittist> How could it be any other way? You are including source code. You are basically asking someone else to type your program.
<dim> you need capabilities for this kind of security, and you give capabilities to programs, with a very restricted default set
<splittist> I can imagine an OS-based capability
<dim> also read this famous “Trusting Trust” paper from Thompson from back in the days, still relevant today
<splittist> and what dim said
<dim> anyway, have to run AFK for awhile, have fun
<splittist> Common Lisp the language obviously can't do this, since it is a systems issue. Secure Common Lisp, which keeps track of which code comes from which set of source files and provides fine-grained access control to OS and other program resources based on this tracking.
<splittist> Of course, that would require you to write Secure Common Lisp (:
<margaritamike> Java has this
<splittist> The JVM has it. Different thing.
nowhere_man has joined #lisp
status402 has quit [Quit: status402]
status402 has joined #lisp
q9929t has quit [Quit: q9929t]
pillton has quit [Read error: Connection reset by peer]
<shka_> ability to sandbox parts of the program is very rare
<shka_> racket can do it and it is pretty awesome
orivej has quit [Ping timeout: 264 seconds]
eagleflo has quit [Ping timeout: 250 seconds]
plathrop has quit [Ping timeout: 246 seconds]
edcragg has quit [Ping timeout: 264 seconds]
plathrop has joined #lisp
edcragg has joined #lisp
rippa has joined #lisp
holycow has quit [Quit: Lost terminal]
eagleflo has joined #lisp
<Jachy> I wish for everyone who read the "trusting trust" paer they'd also read the newer "fully countering trusting trust through diverse double-compiling" paper.
ebrasca has joined #lisp
<lieven> nowadays you also need to worry about the backdoors to the CPU and the motherboard chipset
zmv has joined #lisp
zmv is now known as notzmv
<shka_> and OS
refpga has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 268 seconds]
<Jachy> And the surveillance van outside.
<lieven> and the government's rubber hose cryptographers
kleinie has quit [Remote host closed the connection]
<ebrasca> What about Talos II? ( I think it is save with no backdoors )
scymtym has quit [Ping timeout: 268 seconds]
<beach> ebrasca: What kind of back doors do other systems have that Talos II does not?
guicho has joined #lisp
<lieven> ebrasca: it's hard to prove anything backdoor free without checking the cpu wafer with an electron microscope to see if it conforms to the chip design and then verify your way up :)
<lieven> and I guess, pace trusting trust, you would have to verify the working of the electron miscroscope too
xsperry has joined #lisp
<xsperry> hi
<xsperry> how can I get natural sort order in cl? is there a built-in for this, or do I have to write it myself?
<beach> What is "natural sort order"?
<xsperry> a2 should come before a10
<nirved> xsperry: is a2 a symbol?
<xsperry> a string
<nirved> what is the "natural order" when there are things like a2b3?
<beach> xsperry: You probably need to write it yourself. It doesn't look very "natural" to me.
LiamH has joined #lisp
<_death> it's also known as "human-friendly sort"
<xsperry> beach, that's the actual name.
<beach> I believe you. I just never heard it before.
Bike has joined #lisp
<xsperry> more efficient to search and ask in parallel :P
<nirved> the search took 10 seconds
<xsperry> sometimes it takes 10 seconds. other times, you can't find what you want in 10 hours
<xsperry> 10 second searches often don't lead to correct code, btw. for all I knew, maybe alexandria or similar library already has battle tested version
<_death> as a compromise, you can write it yourself in 10 minutes
prite has quit [Read error: Connection reset by peer]
xsperry has quit [Quit: CGI:IRC]
jonh has joined #lisp
status402 has quit [Quit: status402]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
Achylles has joined #lisp
edcragg has quit [Remote host closed the connection]
edcragg has joined #lisp
hiroaki has quit [Read error: Connection reset by peer]
akoana has left #lisp ["Leaving"]
hiroaki has joined #lisp
<ebrasca> lieven: I think you can't do anything with some trust in someone.
m0w has joined #lisp
askatasuna has left #lisp ["WeeChat 2.3"]
m0w has quit [Read error: Connection reset by peer]
nanoz has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
igemnace has joined #lisp
Denommus has joined #lisp
<flip214> minion: memo for xsperry: perhaps you're looking for something like version sort?
<minion> Remembered. I'll tell xsperry when he/she/it next speaks.
amerlyq has joined #lisp
jonh has quit [Quit: WeeChat 1.9.1]
guicho has quit [Read error: Connection reset by peer]
trafaret1 has joined #lisp
<trafaret1> hi there
<trafaret1> what is prototyping? can anybody shortly explain me?
<dlowe> Prototyping is when you create a test for an idea with the idea that you will throw it away once it answers your question.
pfdietz has joined #lisp
<pfdietz> And then management says "don't throw that away, turn it into a shipping product. How hard could that be?" And the pain starts.
<dlowe> It's true
<flip214> so it's a good idea to prototype in Lisp, so that turning it into a products isn't as painful as in other Languages[sic] ;)
<trafaret1> there is reason why I ask that question
<LdBeth> Good morning everyone
<trafaret1> how can it be helpfull for PLC programming?
<trafaret1> I mean control algorithm prototypeing
<dlowe> It's just a helpful development practice.
Achylles has quit [Remote host closed the connection]
<LdBeth> Once it gets a repl and debugger (maybe no debugger at all) and that’s it
<trafaret1> Are there peple who develop lisp programm which automatically write code on another languages?
<pfdietz> yes
<pfdietz> Althoughthere's a larger market for reverse engineering. For foward engineering, there's barriers to adding unproven and immature tools to the build process.
gareppa has joined #lisp
trafaret1 has quit [Ping timeout: 240 seconds]
pritambaral has joined #lisp
jpsa has joined #lisp
surya123 has joined #lisp
anewuser has quit [Ping timeout: 246 seconds]
<beach> pfdietz: Am I understanding it correctly that you are referring to some hypothetical Lisp program as such an unproven and immature tool?
Inline has joined #lisp
<ebrasca> Do you have some recomendation for reading and writing structures from arrays?
<beach> ebrasca: What seems to be the problem?
<verisimilitude> To address what you wrote, margaritamike, I do audit libraries before I use them. I consider anything else foolhardy.
<beach> ebrasca: I would think AREF would be the way to go.
gxt has quit [Ping timeout: 244 seconds]
<ebrasca> beach: I like to find some better method of reading and writing FS structures.
<beach> What is an FS structure, and what is wrong with AREF?
gxt has joined #lisp
Necktwi has joined #lisp
<ebrasca> beach: superblock is 1 FS structure.
orivej has joined #lisp
<ebrasca> beach: Now I need to write structure , read-structure and write-structure.
<ebrasca> beach: I like some better method to write less code.
<dlowe> ebrasca: lisp arrays are pretty bad for this. Have you tried using alien structure definitions over a mmaped block?
<shka_> something like that?
<shka_> maybe?
<pfdietz> beach: referring to experience there.
charh has quit [Ping timeout: 240 seconds]
<beach> pfdietz: I can very well imagine.
<pfdietz> code generation is bad if the generated code has to be maintained by itself, and is at all obfuscated.
<beach> Indeed.
<pfdietz> If the code generator is kept as part of a build process it has to be integrated with it, which is expensive.
<beach> I agree, yes.
<ebrasca> shka_: It say it is for files , I am before files.
<shka_> ebrasca: that's cool, i just wanted just to suggest this as a model of the approach
jpsa has quit [Quit: Leaving.]
xkapastel has joined #lisp
<ebrasca> shka_: Do you know someting about ?
surya123 has quit [Ping timeout: 244 seconds]
<shka_> not really
<shka_> but nick looks like lisper
ntbre has joined #lisp
* easye struggles with ACM categories for a putative 2019 ELS submission.
<Bike> If a class has a slot with an initform, there's no way to specify in the definition of a subclass that its version of that slot shouldn't have an initform (i.e. should be left unbound), is there?
<Bike> based on the inheritance rules it looks like there isn't
<beach> I think that's true.
<easye> For Minecraft, I guess I can go with one of the History categories since it involves summarizing a fair amount of oral culture around decompiling the "open" server jar.
gareppa has quit [Quit: Leaving]
sjl has joined #lisp
nikkal has joined #lisp
<pfdietz> You can write initialization methods that blow up if the initarg is there.
ntbre has quit [Quit: ntbre]
ntbre has joined #lisp
<pfdietz> hmm, misunderstood the question.
<pfdietz> The initilization method would make the slot unbound, not blow up.
<pfdietz> if there was no initarg
hhdave_ has quit [Ping timeout: 246 seconds]
<fiddlerwoaroof> Bike: wouldn't that violate the expectation that a subclass can be used anywhere a superclass can?
<fiddlerwoaroof> i.e. now code that would never throw a slot-unbound error with the base class now will throw one
m00natic has quit [Remote host closed the connection]
ggole has quit [Quit: Leaving]
<fiddlerwoaroof> I don't know if anoyone else needs this, but I've been working on a protocol for interacting with event loops
<fiddlerwoaroof> I had a slackbot I wrote with cl-async but I was having issues running it on my deployment target because it was too much trouble to get the C dependencies working
sjl has quit [Ping timeout: 250 seconds]
karlosz has joined #lisp
karlosz has quit [Client Quit]
orivej has quit [Ping timeout: 250 seconds]
gxt has quit [Ping timeout: 246 seconds]
ntbre has quit [Quit: ntbre]
ntbre has joined #lisp
sjl has joined #lisp
karlosz has joined #lisp
<Bike> fiddlerwoaroof: that's violated anyway, e.g. if a subclass has a tighter type restriction for a slot.
<Bike> also an instance of the parent class could still be slot-makunbounded, etc.
<fiddlerwoaroof> I feel that using things like slot-makunbound is one of those situations where, if something breaks, you get to keep both pieces.
<fiddlerwoaroof> point taken, though
<Bike> well i just mean that having an initform doesn't mean that a slot is necessarily always bound.
makomo has joined #lisp
Arcaelyx has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
gxt has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
karlosz has quit [Quit: karlosz]
xkapastel has quit [Quit: Connection closed for inactivity]
akoana has joined #lisp
nirved has quit [Killed ( (Nickname regained by services))]
nirved has joined #lisp
sauvin has quit [Remote host closed the connection]
akoana has left #lisp ["Leaving"]
karlosz has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
sjl has quit [Ping timeout: 244 seconds]
pierpal has joined #lisp
karlosz has quit [Quit: karlosz]
sjl has joined #lisp
random-nick has joined #lisp
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
imjacobclark has joined #lisp
<imjacobclark> Could somebody point me in the right direction onto how I can send data back from sb-bsd-sockets:socket-make-stream (e.g a string of html)? I have this code but when I try to use socket-send I get a socket closed error -
sodastabs has joined #lisp
sodastabs has left #lisp ["Leaving"]
<dlowe> imjacobclark: you really don't want to loop via recursion in event-loop
<dlowe> it may not matter now, but you will blow your control stack
<aeth> Well, it depends on the implementation and the optimization level
<aeth> Unless it's not tail recursion
<imjacobclark> Would you suggest a regular loop?
<dlowe> imjacobclark: also, it works fine for me
<dlowe> imjacobclark: yes, a regular loop, like you've commented out, will work fine
<imjacobclark> in event-loop ive commented the stream path out
<imjacobclark> as it works if i dont stream it
<dlowe> aeth: you have to meet people where they are
<dlowe> ohhh. right
<dlowe> imjacobclark: you're trying to get a stream out of the listener, looks lke
<dlowe> not an accepted socket
<imjacobclark> yes, id like to look at the http header, essentially - then eventually do a cond and return a different response for different requests
<imjacobclark> for now though, i guess just printing the headers and returning a single response would beok
<dlowe> imjacobclark: you can't read from a listener socket.
<imjacobclark> So, the code in the gist right now allows me to accept a connection (via a browser) and it prints " ET / HTTP/1.1
<imjacobclark> however in the browser i get "ERR_EMPTY_RESPONSE"
<imjacobclark> there is a very high chance im misunderstanding or missing something - ive strung what i have together by searching github - a lot for examples and some sbcl docs
<dlowe> imjacobclark: so I uncommented your loop and it looks like it works okay
<imjacobclark> does it return anything to the client thats hitting the IP and Port though?
<imjacobclark> it does indeed return the http headers, thats fine - but i want to understand how to send a response back to the client
<dlowe> no but you're just (print (read-line stream))
<imjacobclark> yep - how would i send data back?
<dlowe> You print back on the stream
ntbre has quit [Quit: ntbre]
<dlowe> (print (read-line stream) stream) will echo what you received
<imjacobclark> and that would return back to the browser?
* imjacobclark tries it
<dlowe> remember to use finish-output to wait for output to complete
<imjacobclark> So should this work (inside event-stream)
<imjacobclark> (loop (with-open-stream (stream (stream-connection socket)) (print (read-line stream))))
ntbre has joined #lisp
<imjacobclark> actually no theres an issue there
<dlowe> no, PRINT prints to *standard-output* by default
<dlowe> try putting in there:
<dlowe> (write-string *response* stream) (finish-output stream)
ym has quit [Remote host closed the connection]
<imjacobclark> i see
<imjacobclark> okay, so " (loop (with-open-stream (stream (stream-connection socket)) (write-string "test" stream) (finish-output stream)))"
orivej has joined #lisp
<aeth> The alternative style is to rebind *standard-output* to your destination stream. I prefer explicitly passing the stream, though.
shka_ has quit [Ping timeout: 244 seconds]
<imjacobclark> Hmm okay
<imjacobclark> So ive updated the code
<imjacobclark> I tried it out
<imjacobclark> [clarkj84:~/Desktop/cl-server]$ curl localhost:8080 (master✱) curl: (52) Empty reply from server
<nirved> imjacobclark: maybe you want to use nc for lower level testing
<imjacobclark> yeah, nc connects to the server and I get "Connection to localhost port 8080 [udp/http-alt] succeeded!" - but no response - im expecting it to return "test"
<imjacobclark> nc -u localhost 8080 -v
makomo has quit [Quit: WeeChat 2.2]
<imjacobclark> actually
<imjacobclark> i was using nc wrong!
<imjacobclark> [clarkj84:~/Desktop/cl-server]$ nc localhost 8080 (master) test%
<imjacobclark> woo!
<imjacobclark> i guess all i need to do next is format that response to something curl or chrome can understand
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<imjacobclark> thanks all, happy lisping :)
varjag has joined #lisp
karlosz has joined #lisp
random-nick has quit [Read error: error:1408F10B:SSL routines:ssl3_get_record:wrong version number]
random-nick has joined #lisp
Denommus has quit [Remote host closed the connection]
karlosz has quit [Quit: karlosz]
imjacobclark has quit [Ping timeout: 256 seconds]
jprajzne has quit [Quit: jprajzne]
trafaret1 has joined #lisp
<trafaret1> o/
jprajzne has joined #lisp
<trafaret1> need your help
<trafaret1> I'm trying to bind qt to common lisp via CommonQT
<trafaret1> I did just like it on
<trafaret1> but I can't compile it in emacs with slime mode
<trafaret1> I have tons of errors
<trafaret1> sadly I just even can't normally decode it
<trafaret1> can anyboyd help me?
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
<LdBeth> trafaret1: please dump your buffer outputs to pastebin and post the link here
<trafaret1> LdBeth: just a moment :)
<trafaret1> LdBeth:
nikkal has quit [Ping timeout: 250 seconds]
<Bike> these are strange errors
imjacobclark has joined #lisp
<Bike> well, notes
<Bike> did you perhaps not load this freshly?
<imjacobclark> i have another question, about streams - im reading a socket stream line by line, it works fine, but the while in my loop never seems to trigger, hanging the entire program - what could that be?
<Bike> also, you'll have to load this (C-c C-l), not compile
<Duns_Scrotus> is there a preferred way to convert a list to a vector?
<Duns_Scrotus> is there anything wrong with apply #'vector
<no-defun-allowed> (coerce list 'vector) might be better
<Bike> might not work or be inefficient for long lists. i'd use the coerce
<no-defun-allowed> Implementations could only allow for a fairly small apply list. I forgot the number though, maybe it was around 50.
<Duns_Scrotus> i guess the internal ABI doesn't want an actual linked list of arguments?
trafaret1 has quit [Read error: No route to host]
<no-defun-allowed> That's true, the &rest list is passed as plain conses so it could optimise for that.
<Duns_Scrotus> i mean if its just passing a literal list how would it even limit the number of arguments
<Bike> clhs call-arguments-limit
<no-defun-allowed> An implementation might not be so clever.
amerlyq has quit [Quit: amerlyq]
<no-defun-allowed> A very naive intepreter would take the argument list, eval every item in the list, then find the function, destructure the list and evaluate the lambda body with the xestructured values.
ntbre has quit [Quit: ntbre]
<no-defun-allowed> *destructured. This is truly the worst case, and this could have been an issue in the 80s with very expensive memory.
nanoz has quit [Ping timeout: 272 seconds]
Lycurgus has joined #lisp
ym has joined #lisp
mrcom has quit [Quit: This computer has gone to sleep]
mrcom has joined #lisp
nikkal has joined #lisp
Bike has quit []
<LdBeth> That’s why Racket is so dammn slow
fiveop has joined #lisp
fiveop has quit [Client Quit]
<no-defun-allowed> I don't think so. Racket has a JIT to my knowledge.
<aeth> I thought Racket was moving to a JIT? Or is it just moving to a better JIT?
<no-defun-allowed> They are also moving to chez scheme, which is faster than their C backend iirc.
ntbre has joined #lisp
ntbre has quit [Client Quit]
imjacobclark has quit [Ping timeout: 256 seconds]
pfdietz has quit [Ping timeout: 246 seconds]
ealfonso has quit [Disconnected by services]
ntbre has joined #lisp
ntbre has quit [Client Quit]
Lycurgus has quit [Quit: Exeunt]
karlosz has joined #lisp
karlosz has quit [Quit: karlosz]
matijja has joined #lisp
robdog has quit [Ping timeout: 240 seconds]
<LdBeth> #'no-defun-allowed: with JIT it still slower than ruby in benchmark
<no-defun-allowed> Oh dear ):
<LdBeth> well defined behavior, fast compiler, fast object code, choose either two
Bike has joined #lisp
<Duns_Scrotus> is it really slwoer than ruby?
<Duns_Scrotus> at what
iovec has quit [Quit: Connection closed for inactivity]
<aeth> LdBeth: Ruby's the slowest here, and Racket is comparable to Julia, a bit slower. SBCL is, of course, faster, but its relative position seems to have been slipping. It might slip off of the bottom graph soon, like Haskell has.
<Duns_Scrotus> the benchmarks game is pretty awful
<aeth> Oh, sorry, it has two Ruby's now and one of them isn't the slowest, but is still pretty slow.
<aeth> Duns_Scrotus: The benchmarks game is awful for specific numbers, but it does imo help suggest "performance classes" of languages
<aeth> Intuitively, Ruby's main implementation is going to be slower than SBCL (or even Racket) just based on how they're written.
dmiles has quit [Ping timeout: 245 seconds]
logicmoo has joined #lisp
elem6 has joined #lisp
<LdBeth> Here’s something interesting
atgreen has joined #lisp
nikkal has quit [Ping timeout: 268 seconds]
<Duns_Scrotus> a brainfuck interpreter
charh has joined #lisp
<Duns_Scrotus> his racket brainfuck interpreter grows the array by allocating a new array exactly one bigger
LiamH has quit [Quit: Leaving.]
<Duns_Scrotus> and then copying
<Duns_Scrotus> so bad
<aeth> Brainfuck itself isn't particularly designed to be efficient. It's designed to be easy to implement. And in some languages the easy route is going to be slower than others.
<Duns_Scrotus> The racket brainfuck interpreter is pretty fast for benchmark.b
<Duns_Scrotus> but for mandel.b, which presumably grows the tape a lot, it is indeed very slow
<aeth> I mean, clearly the solution is to implement it in the hardware with a Brainfuck Machine.
karlosz has joined #lisp
Arcaelyx has quit [Read error: Connection reset by peer]
Arcaelyx has joined #lisp
<Duns_Scrotus> why did he write it like this
verisimilitude has quit [Remote host closed the connection]
verisimilitude has joined #lisp
emaczen has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
<emaczen> I'm trying to cffi:foreign-funcall a function that was defined as "static inline", but am always told that this function is undefined. What are easy ways around this?
<emaczen> obviously I could just copy and paste the function, remove the static inline, compile and then load this foreign library
<emaczen> but is there a better solution?
akoana has joined #lisp
Lord_of_Life_ has joined #lisp
<no-defun-allowed> by the sounds of it, the function isn't in the binary, just inlined wherever
random-nick has quit [Ping timeout: 246 seconds]
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
matijja has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 240 seconds]
<Bike> a function declared static has file scope, so with inline it probably won't exist in the binary.
<Bike> so no, there's not really a better solution. 's how C works.