phoe changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language | <> <> <> <> | SBCL 1.4.14, CMUCL 21b, ECL 16.1.3, CCL 1.11.5, ABCL 1.5.0
<p_l> Isn't Clasp project at least partially involved with CL-jupyter?
<djeis[m]> They seem to be making use of some variant of it, at the very least.
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
amerlyq has joined #lisp
pierpal has joined #lisp
nowhere_man has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
xkapastel has joined #lisp
_whitelogger has joined #lisp
m0w has quit [Ping timeout: 252 seconds]
Kundry_Wag has joined #lisp
kajo has quit [Ping timeout: 252 seconds]
kajo has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
keep_learning_M has joined #lisp
nitrix is now known as nitrix-mas
meepdeew has joined #lisp
meepdeew has quit [Ping timeout: 250 seconds]
robotoad has quit [Quit: robotoad]
amerlyq has quit [Quit: amerlyq]
khisanth_ has quit [Ping timeout: 250 seconds]
notzmv has quit [Ping timeout: 272 seconds]
Essadon has quit [Quit: Qutting]
robotoad has joined #lisp
notzmv has joined #lisp
pierpal has joined #lisp
iovec has quit [Quit: Connection closed for inactivity]
khisanth_ has joined #lisp
pierpal has quit [Ping timeout: 250 seconds]
kajo has quit [Ping timeout: 250 seconds]
kajo has joined #lisp
akoana has left #lisp ["Leaving"]
orivej has quit [Ping timeout: 240 seconds]
themsay has joined #lisp
themsay has quit [Ping timeout: 246 seconds]
notzmv has quit [Ping timeout: 272 seconds]
notzmv has joined #lisp
Lord_of_Life has quit [Ping timeout: 244 seconds]
Lord_of_Life has joined #lisp
notzmv has quit [Ping timeout: 250 seconds]
dale has joined #lisp
pierpal has joined #lisp
notzmv has joined #lisp
<beach> Good morning everyone!
<beach> phoe: I may be able to help you out with the CLOS and MOP questions in case you still have some.
asarch has joined #lisp
tejr is now known as terja_claus
buffergn0me has quit [Ping timeout: 252 seconds]
gravicappa has joined #lisp
torbo has joined #lisp
torbo has left #lisp [#lisp]
buffergn0me has joined #lisp
rumbler31 has joined #lisp
_crow has joined #lisp
bitch has quit [Ping timeout: 245 seconds]
anamorphic has quit [Ping timeout: 250 seconds]
permagreen has quit [Remote host closed the connection]
bitch has joined #lisp
rippa has joined #lisp
meepdeew has joined #lisp
asarch has quit [Quit: Leaving]
meepdeew has quit [Ping timeout: 268 seconds]
cranes has quit [Ping timeout: 268 seconds]
buffergn0me has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
cranes has joined #lisp
buffergn0me has joined #lisp
dddddd has quit [Remote host closed the connection]
_whitelogger has joined #lisp
vlatkoB has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
Lycurgus has joined #lisp
atgreen has quit [Remote host closed the connection]
atgreen has joined #lisp
iovec has joined #lisp
rumbler31 has quit [Remote host closed the connection]
nowhere_man has quit [Read error: Connection reset by peer]
nowhere_man has joined #lisp
Lycurgus has quit [Quit: Exeunt]
<phoe> beach: good morning, and thanks.
meepdeew has joined #lisp
rumbler31 has joined #lisp
seok has joined #lisp
meepdeew has quit [Ping timeout: 250 seconds]
rumbler31 has quit [Remote host closed the connection]
<beach> Oh, I'll look at SPLIT-SEQUENCE now, I guess.
<beach> Wait, is this a pull request?
<beach> And you are asking me because I am listed among the maintainers?
themsay has joined #lisp
<phoe> beach: yes, it's a pull request, except the code was completely overhauled.
<phoe> And I'm asking you because I want your opinion - I didn't even know if you are one of its maintainers.
<beach> I see.
themsay has quit [Read error: Connection reset by peer]
themsay has joined #lisp
<beach> OK.
<beach> What do you do in case of :from-end being true for a list?
<phoe> beach: I and operate on its reverse, then nreverse the results.
<phoe> s/and//
<beach> So you allocate O(n) additional memory?
<beach> You might consider using the technique from our paper.
<phoe> Yes. I need to allocate memory nonetheless - subsequencing a list requires consing up new sublists.
<beach> Oh, you reuse the CONS cells that you allocated in the reverse?
themsay has quit [Ping timeout: 250 seconds]
<phoe> Yes, that's my attempt.
<beach> That's good.
<beach> OK, I am confused.
<phoe> I think I originally wrote the code like that, but then sjl rewrote my code to be more readable but cons a little bit more.
<beach> I see several files with green code check-bounds and split-sequence.
<beach> Is that normal?
<phoe> One second
<phoe> You could perhaps review this. It should be clearer to read in a non-PR-view mode.
<beach> OK.
<phoe> beach: please link me your paper though. I'll want to take a look at it.
<beach> You mix simple errors and non-simple errors. Is that normal.
<beach> ?
<phoe> beach: Hm. I don't know, to be honest.
<phoe> I might wnat to fix that.
<phoe> s/wnat/want/
<beach> I would signal specific errors in all cases, and document those. But that's just me and that might be a project for later.
<phoe> Noted.
<beach> Is it possible to split a list from the end while having vectors returned?
* beach has not read the documentation enough.
<beach> ... i.e. is it possible to specify return type?
<phoe> Nope
<beach> OK.
<phoe> The return type is the same as the type of the input sequence.
<beach> Got it.
<phoe> pjb suggested that previously, but I did not want to change the original API for the time being.
<beach> Sure.
<beach> I would have LOOP keywords either be Common Lisp keywords consistently, or not. But not a mixture.
<beach> It looks like you are using WHEN in a context that requires a value.
<beach> That's contrary to the recommendations by Norvig and Pitman.
<beach> And you are using COUNT as a Boolean. Idem.
<phoe> Noted.
<beach> In the .asd file, I always put (cl:in-package #:asdf-user) so that I get completion and other SLIME features.
atgreen has quit [Ping timeout: 268 seconds]
<beach> Aside from those things, the code looks nice. If you tested it properly, and it passes, I see no reason why it shouldn't be merged.
terja_claus is now known as tejr
<phoe> beach: thanks. I'll fix these later today.
<beach> Great!
<phoe> I added a bunch of new tests there and bumped the number of all test cases from seven to fifty-something, and added a random tester.
<phoe> s/test cases/unit test cases/
<beach> Yes, I read that. Good.
<phoe> So I think I can risk saying that it is tested properly.
<beach> Yeah.
<beach> Aren't you celebrating the holidays?
<phoe> This is now I celebrate the holidays!
<beach> Heh.
<phoe> I finally have some time to sit down and write Lisp. (:
<phoe> Can't think of a better gift for myself.
<beach> I see, yes.
<phoe> Are EQL-specializers always more specific than classes?
<beach> Yes.
<phoe> Thanks.
<beach> phoe: In SICL, I have a generic function called DEFAULT-SUPERCLASSES that returns a list of default superclasses, given a class.
<beach> So it returns the list of STANDARD-OBJECT for STANDARD-CLASS, the list of FUNCALLABLE-STANDARD-OBJECT for FUNCALLABLE-STANDARD-CLASS and the empty list by default (for, say BUILT-IN-CLASS).
<beach> It is called by an :AROUND method on SHARED-INITIALIZE when the list of direct superclasses given is empty.
milanj has joined #lisp
<phoe> beach: thanks.
<beach> phoe: Also, in SICL, I can use DEFCLASS for built-in classes like (defclass t () () (:metaclass built-in-class)) or (defclass symbol (t) () (:metaclass built-in-class)))
<beach> So what heisig said is not quite true, i.e. that it would be hard to avoid creating a standard object.
<beach> s/hard/a lot of work/
<beach> Er, the symbol has slots, of course.
jcowan has quit [Quit: Connection closed for inactivity]
<phoe> I see
<beach> That way, I can use the MOP machinery for defining built-in stuff, and I avoid having a separate mechanism for that.
<beach> Just saying. Not important.
<phoe> Sure, I understand that.
<beach> But, yeah, the circular aspect of the MOP confuses me every day.
dale has quit [Quit: dale]
<phoe> Glad to hear I'm not alone.
<beach> So you want everyone to be as defective as you are? :)
* phoe sighs. (:
mrcom has quit [Read error: Connection reset by peer]
robdog has joined #lisp
mrcom has joined #lisp
<phoe> Is it okay to say that the class precedence list is an ordered list of all superclasses of a given class, and that it is used e.g. for computing the specific method that will be called when a generic function is invoked?
<beach> Sounds right.
themsay has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
<phoe> Is it safe to say that a class prototype is the first instance of that class ever created and that it serves as a "stencil" for creating new ones?
rozenglass has joined #lisp
<phoe> Or is the prototype not actually used in instantiation?
<beach> It is not used.
<beach> And it might not be the first instance.
<beach> It could be created lazily when asked for, for instance.
<phoe> I see.
<beach> ALLOCATE-INSTANCE looks at the CLASS-SLOTS of the class to determine how to allocate the instance.
<beach> mop class-slots
<phoe> What is the prototype used or useful for, then? The only use case I know is accessing class-allocated slots.
<beach> Whenever you have a method that dispatches on a particular class but you only use it to select the applicable method, you can use the class prototype to avoid allocating an instance.
<beach> mop make-method-lambda
<phoe> I see.
<beach> This function is passed class prototypes.
<phoe> In other words: what *is* a class prototype?
<phoe> A MOP-internal instance used for creating method lambdas?
<beach> It is an uninitialized object that has returns the right class when used with CLASS-OF.
<phoe> I see.
<beach> Basically what ALLOCATE-INSTANCE returns without calling initialize-instance etc.
<beach> If you think of an instance in terms of the pair header/rack used in SICL, a clas prototype is such a pair where the CLASS slot of the header points to the right class, but the rack may contain anything.
<beach> ... or nearly so.
<beach> In SICL, it contains the "stamp" and the class-slots of the class as they were when the prototype was created.
<beach> But no initialized user-visible data.
<beach> clhs 4.3.5
<specbot> Determining the Class Precedence List:
<beach> Will have the Common Lisp HyperSpec wording for a class precedence list.
cranes has quit [Remote host closed the connection]
cranes has joined #lisp
ebrasca has joined #lisp
<phoe> Thanks.
<beach> Anytime.
<phoe> Is it possible to finalize a class multiple times?
<phoe> Or is it a once-only process?
<beach> It would be pointless. It is likely that the finalization checks whether it is already finalized.
<beach> ... and then does nothing.
<beach> When a class or one of its superclasses is modified, the class gets un-finalized.
<beach> So that next time you call ALLOCATE-INSTANCE, it will first trigger finalization.
<phoe> I see.
<phoe> So when a class or one of its superclasses... yes, I see.
<phoe> Weird.
<beach> Why?
<phoe> (defclass foo () ()) (defclass bar (foo) ()) (make-instance 'bar) (defclass foo () (x)) (c2mop:class-finalized-p (find-class 'bar))
<phoe> ;=> T, on my implementation
<phoe> But (c2mop:class-finalized-p (find-class 'foo)) ;=> NIL
<beach> It is possible to do the finalization as soon as the class is modified.
<phoe> So BAR was not "de"finalized.
<beach> But only if no FORWARD-REFERENCED-CLASSes are involved.
<phoe> Even though FOO was.
<beach> That looks strange.
<phoe> Sure, but this case doesn't seem to match what you are saying now. FOO is not finalized even though BAR is.
<beach> Maybe it is just class-finalized-p that is not reporting the right thing.
<phoe> Could you point me towards the MOP part that states this process?
<phoe> This does not seem to mention what happens in the case we're discussing now.
<beach> The first paragraph says that a class must be finalized in order for its slots to be known.
<phoe> In particular, this doesn't mention classes becoming "definalized".
<phoe> Oh. Hmmm.
<phoe> Oh wait
<beach> It is possible that it was finalized when FOO was modified but FOO was de-finalized. But that would be a strange implementation of it.
<phoe> (defclass foo () ()) (defclass bar (foo) ()) (make-instance 'bar) (c2mop:class-finalized-p (find-class 'foo)) ;=> NIL
<beach> Try the above experiment, then allocate a BAR then check whether FOO is finalized.
<phoe> FOO was never finalized.
<phoe> That's from a clean REPL.
<phoe> BAR is finalized, but FOO was not.
<phoe> Is that expected?
<beach> So they finalized BAR when FOO was modified, but not BAR.
<beach> Very strange.
<phoe> No, not really.
<beach> I think that requires a very strange way of implementing it.
<phoe> I don't modify FOO here.
<phoe> I define a class, I define a subclass, and make an instance of the subclass.
<beach> Yes, I get it.
<phoe> The subclass is now finalized, but the class is not.
<beach> I understand.
<beach> It is certainly possible to do it that way.
<phoe> Okay - I understand it now.
<beach> But it is strange, because to finalize BAR, you basically already have to do all the steps in order to finalize FOO.
<phoe> Well, that's SBCL.
<beach> It could be PCL.
<phoe> Yep.
gravicappa has quit [Ping timeout: 246 seconds]
<phoe> Should I raise an issue on their bugtracker?
<beach> No, they are allowed to do it that way.
<beach> The MOP doesn't specify exactly when things are finalized. Only that a class has to be finalized for it to be possible to allocate instances of it.
kajo has quit [Ping timeout: 252 seconds]
<phoe> OK.
<beach> Here is an interesting experiment: Define FOO and BAR as before. Then redefine FOO to take a superclass that does not exist.
<beach> Then check whether BAR is finalized.
kajo has joined #lisp
<beach> It complains when you redefine FOO.
<beach> So that suggests that they try to finalize BAR at the time FOO is modified.
<phoe> I see.
<beach> I suspect they feel they have to finalize a class that has instances, which they probably detect by checking whether it was finalized before the modification to its superclass.
<beach> I don't remember the technique they use for detecting obsolete instances.
<phoe> Are class-direct-slots declared at class definition time?
<phoe> And are class-slots computed at finalization time?
<beach> Yes and yes.
shka_ has joined #lisp
<beach> What is returned by CLASS-SLOTS is called the list of "effective slots".
<beach> mop class-slots
varjag has joined #lisp
<phoe> Thanks.
simendsjo has joined #lisp
Zaab1t has joined #lisp
orivej has joined #lisp
tejr has left #lisp [#lisp]
<flip214> when exporting a few symbols via DEFPACKAGE, but then functions a build and exported via a macro as well, on reloading I get "Warning: ... also exports the following symbols: ..."
<flip214> is there some LOCALLY that's compatible across all implementations, or something else I can do?
heisig has joined #lisp
<phoe> flip214: UIOP:DEFINE-PATCKAGE
<phoe> Note that this macro silently unexports all symbols that are missing from the form, so you will need to export them again. But, hey, at least it compiles.
<flip214> phoe: thanks, will try
<phoe> flip214: it also has a few other options that DEFPACKAGE does not have, for example a handy :MIX option.
<phoe> (:mix :closer-mop :cl) automatically resolves all import conflicts between CLOSER-MOP and CL in favor of the first one, for example.
<phoe> It's insanely useful because I no longer need to (:shadowing-import-from :closer-mop ...) all the symbols that are conflicting.
<flip214> phoe: I just read the description, thanks!
simendsjo has quit [Ping timeout: 268 seconds]
wanz has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
Arcaelyx has quit [Ping timeout: 246 seconds]
isBEKaml has joined #lisp
AroPar has joined #lisp
razzy has quit [Ping timeout: 245 seconds]
robotoad has quit [Quit: robotoad]
razzy has joined #lisp
MichaelRaskin has joined #lisp
<gxt> Hi, I'm new to lisp and was just trying out some of the examples in in the SBCL REPL, and when running (loop (print (read))) I get an odd behavior that differs from the one described in the article; After I enter the first line (e.g. "(a b c)"), I get nothing printed, then after I enter the next line, I get whatever I entered before as output, i.e. the
<gxt> output is always one loop "late" at least in my naive and incomplete understanding. Can someone explain why this happens and what I'd have to do to fix it?
<_death> the stream is buffered, so you need to add a (finish-output) after the print form
AroPar has quit [Remote host closed the connection]
<gxt> _death: Thank you, that works.
<beach> And you probably forgot EVAL in there. :)
* beach is joking.
<gxt> beach: It's one of the first examples, I'm trying to understand every step on its own better :)
lavaflow has quit [Ping timeout: 272 seconds]
<beach> Sure. Good luck!
<beach> Ask here or in #clschool if you get stuck.
<gxt> beach: Thanks, I didn't know about #clschool yet.
larryba has joined #lisp
<larryba> hi
<larryba> has anyone tried to calculate Easter date? there are so many algorithms in here I'm kind of lost which one to use.
<larryba> nice, easy to follow
<larryba> thanks
<larryba> actually, orthodox is easy to follow. non-orthodox is very convoluted, but I guess that is on the algorithm
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<phoe> "By usurping the normal slot lookup protocol..."
pierpal has joined #lisp
<phoe> Where is that protocol defined? What generic functions are skipped that way?
zotan has joined #lisp
pierpal has quit [Ping timeout: 246 seconds]
cranes has quit [Ping timeout: 240 seconds]
cranes has joined #lisp
<shka_> phoe: wow, never seen this before
<phoe> shka_: (:
<shka_> phoe: i thought that slot-value-using-class is just as deep as it gets
<shka_> phoe: i am really not sure why this exists, but it looks like performance consideration to me
pierpal has joined #lisp
<shka_> but from description i think that this sits below slot-value-using-class which sits below slot-value which sits below accessors
<shka_> since this is a function, and not a generic one, i would imagine that when implementing your own specialization of slot-value-using-class you can do stuff you need in there, and THEN call standard-instance-access instead of (call-next-method)
vlatkoB_ has joined #lisp
<shka_> i never needed to do that though
<phoe> Yes. I want to know what is the "slot lookup protocol" this describes.
zotan has quit [Ping timeout: 240 seconds]
<shka_> i think that this is refering to slot-value and slot-value-using-class
<shka_> and i suspect that the description is somewhat misleading
vlatkoB has quit [Ping timeout: 244 seconds]
<phoe> I see.
zotan has joined #lisp
<phoe> The "argument" location seems to be the key here.
pierpal has quit [Ping timeout: 244 seconds]
<shka_> phoe: i would think that this thing is supposed to grant access like slot-value but works ONLY on standard-instances
<phoe> If I understand correctly, the directly accessible slots are stored in a vector of sorts, and this function basically calls AREF on that vector.
<phoe> This means that SLOT-VALUE-USING-CLASS is not called.
<shka_> yes
<shka_> that's what i imagine
<shka_> but again, i never seen this function, let alone used it before
isBEKaml has quit [Quit: WeeChat 2.3]
Kundry_Wag has joined #lisp
<shka_> and if such optimization really matters in application, i think that using structs is overall a better call then this
<shka_> because you are one indirection closer to data no matter what
<beach> phoe: In SICL, that function basically accesses the rack directly. Think of it as being the end of the call chain.
Kundry_Wag has quit [Ping timeout: 250 seconds]
<phoe> beach: I see.
<phoe> I think I understand it now.
pierpal has joined #lisp
<shka_> so my guess was on point
<shka_> but this description is not great
<phoe> How can I state whether a slot is directly accessible or not?
<beach> I guess you can use SLOT-LOCATION.
<beach> mop slot-location
<specbot> Couldn't find anything for slot-location.
<beach> bah.
<beach> mop slot-definition-location
<beach> there
<phoe> No no, my question is different.
<phoe> Let's assume that I define a slot whose storage is in a hash-table.
<phoe> I don't want the slot value to be located in the rack, as you called it.
<phoe> How can I ensure that storage for it does not get allocated in the rack?
<beach> By defining a new slot-definition class.
<beach> And computing the location the way you want when you do the class finalization.
<beach> I guess you need a new class class as well.
<phoe> Yes, I'll need a new metaclass.
<beach> mop compute-effective-slot-definition
robdog has quit [Remote host closed the connection]
<beach> You need to write a method on that generic function.
<beach> And you return an instance of your own effective-slot-definition class.
<phoe> So FINALIZE-INHERITANCE would be where the storage allocation happens, based on the results of COMPUTE-EFFECTIVE-SLOT-DEFINITION called for every direct slot definition.
<phoe> Is that correct?
milanj has quit [Quit: This computer has gone to sleep]
<beach> Yes, it says so.
<beach> "The behavior of compute-slots is itself layered, consisting of calls to effective-slot-definition-class and compute-effective-slot-definition. "
SeasonsGreetings has quit [Quit: How much does Santa pay for parking? Nothing. It's on the house.]
<phoe> I see.
grumble has joined #lisp
<beach> Aren't you glad I created that site? :)
<phoe> So, if I were to generate a class that uses a hash table instead of a vector for storage, then FINALIZE-INHERITANCE would be where MAKE-HASH-TABLE would be called. Is that right?
<phoe> beach: yes, I am. (:
mrcom has quit [Read error: Connection reset by peer]
<shka_> phoe: make-hash-table?
<phoe> shka_: yes.
<shka_> phoe: that would belong to shared-initialize of instance i think
<shka_> not the class itself
<phoe> Oh wait
<phoe> Yes, I confused things
<phoe> FINALIZE-INHERITANCE is for metaobjects and not for objects.
<phoe> Sigh, MOP is hard.
<shka_> not that hard
<shka_> it is just load of new concepts
<phoe> But tricky.
<shka_> but those concepts form well structured system
<shka_> slightly big system, but reasonable
mrcom has joined #lisp
seok_ has joined #lisp
<seok_> How would you go about javascript web scraping?
<phoe> seok_: javascript? What do you mean?
<seok_> there are 2 libraries for selenium but they are a bit out of date
<phoe> you mean scraping dynamic websites using Lisp?
<seok_> well, if I request with dexador or drakma I cannot fetch any javascript generated content
<trn> Ho ho ho!!
<shka_> seok_: you will need headless web browser
<phoe> Yep, that is correct - you need to interface with a web browser to do that. I don't know anything about the Selenium libraries though - I've never used them
<seok_> I have a messy solution with cl-selenium
<seok_> Any ideas on how?
<shka_> i can't help, sorry
<phoe> No ideas other than grabbing the library, patching it, and publishing your patches upstream.
<shka_> well, there is a next browser, maybe you could do something with that
<seok_> Can I communicate with next browser from repl?
<shka_> dunno
<seok_> maybe I need to setup a pipe
<shka_> this project was rewritten like three times at this point
<shka_> seok_: next browser is written in CL
<phoe> seok_: ask jmercouris
<phoe> he tends to hang around here sometime
<seok_> how do I call him :))
<seok_> O it seems Next can be controlled from SLIME
<seok_> I'lll try that and let you know
<phoe> Please do! I'm curious about how it works.
<shka_> seok_: cool :-)
cyraxjoe has quit [Ping timeout: 250 seconds]
<phoe> Can a slot definition be both direct and effective?
<shka_> phoe: those are separate things
<phoe> Yes, I thought so.
<shka_> existing on different levels
cyraxjoe has joined #lisp
<shka_> but for convenience you often have shared parts of both slot-classes in the same common mixin
<phoe> Yes, I see
larryba has quit [Quit: CGI:IRC]
larryba has joined #lisp
<larryba> (week-day-diff tuesday monday) returns 1. what would you expect (week-day-diff monday sunday) to return?
makomo has joined #lisp
<shka_> 6
<shka_> but i suspect -1 :]
<larryba> I'm writing the function, and I'm not quite sure if it should return 6, -1 or 1
<shka_> 6
<shka_> i don't see why you would anything else
<larryba> 2018-12-24 was monday, 2018-12-23 was sunday. difference is 1 day
<seok_> What are the applications of the function?
<shka_> there is excellent library called local time
<shka_> it has decent api, you can take your model from there
pierpal has quit [Ping timeout: 268 seconds]
<ebrasca> Hi
<phoe> hey ebrasca
<ebrasca> How to deal with diferent structure versions?
<ebrasca> Like superblock from ext2 and ext4.
<larryba> seok_ I am expanding a general purpose time library. I need this to calculate certain holidays that don't fall on the same date every year, but I want to think beyond that and define this function the way it would make most sense
<ebrasca> phoe: How are you doing?
pierpal has joined #lisp
<Inline> i'm doin fuzzy
<Inline> lol
<_death> larryba: I would expect it to return 1.. since here weeks begin on Sunday ;)
<larryba> is this country-related, or is it commonly accepted that week begins on sunday?
<larryba> and in that case, difference between sunday and saturday would be 6?
<_death> it's locale related
<larryba> oh
<seok_> why not just do 2nd date - 1st date and use in accordance with context?
<seok_> I'm sure there will be different situations where you would like one or the other
<seok_> So sunday - monday gives 6 but monday - sunday gives 1
<larryba> well, there's no date. this data only contains weekday name
<larryba> how about this? first argument refers to hypothetical today, and second argument to N-days after today. then it doesn't matter what day in the week comes first
<larryba> then you can switch the meaning by swapping the arguments, and/or adding -
<seok_> yes
<seok_> that will work
<phoe> ebrasca: well. You?
<phoe> ebrasca: structure versions? If they are somewhat sane, then there is a version field somewhere in the beginning of the structure. Read it, and act accordingly.
<makomo> hello, merry christmas! :-)
yvy has joined #lisp
<beach> larryba: According to ISO8601, the week begins on a Monday.
<beach> ... which is unfortunate in Vietnamese because the name of Monday is Vietnamese is "day 2".
pfdietz has quit [Ping timeout: 250 seconds]
<makomo> hah, interesting
<larryba> beach, interesting. I have no idea what day is considered first around here, but, again, I think it makes more sense that weekdayDifference doesn't care on what day week begins
<beach> True.
<beach> Where is "around here"?
<larryba> spain
<beach> Ah.
<beach> We should lobby for the EU to follow ISO8601, one of the best standards ever published.
<larryba> if I had to guess I'd say it is sunday
<larryba> which do you think makes more sense? (defun weekday-diff (later earlier) .. ) or (defun weekday-diff (earlier later) ..)
<_death> beach: not just in Vietnamese..
<beach> _death: I can imagine.
<beach> _death: That's just the one I happen to know.
<beach> larryba: The first one, just like subtraction.
pfdietz has joined #lisp
dddddd_ has joined #lisp
rumbler31 has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
<_death> the ordering of the days should actually be Wed, Fri, Thu, Tue, Sun, Mon, Sat :)
<phoe> they should be day 1, day 2, day 3, day 4, day 5, day 6, and day 0
<phoe> the 0th being the last precisely to annoy the programmers
rumbler31 has quit [Ping timeout: 250 seconds]
dddddd_ is now known as dddddd
<pjb> (fri mon sat sun thu tue wed)
<pjb> obviously.
<ebrasca> phoe: I am fine.
<pjb> With the added advantange, that weekday order is locale-dependent: (dim jeu lun mar mer sam ven).
<ebrasca> phoe: I have hard time with diferent version of same FS. For now I have 1 structure for all versions.
pierpal has joined #lisp
<_death> also, maybe Wed should repeat three times
<phoe> ebrasca: I see. This might not be viable.
pierpal has quit [Read error: Connection reset by peer]
<phoe> (defclass foo () () (:metaclass bar)) means that (find-class 'foo) returns an instance of BAR. Is that correct?
<pjb> Yes.
<pjb> (setf (find-class 'foo) (make-instance 'bar)) happened.
<beach> Correct.
<ebrasca> I have never use metaclass.
Kundry_Wag has joined #lisp
<ebrasca> phoe: What todo if some slot change name from ext2 to ext4?
<shka_> then it is not the same slot
<phoe> I am trying to digest the VALIDATE-SUPERCLASS message.
<phoe> "The class #<STANDARD-CLASS COMMON-LISP:STANDARD-OBJECT> wasspecified as a superclass of the class#<BAR COMMON-LISP-USER::FOO {1005892DD3}>, but the metaclasses#<STANDARD-CLASS COMMON-LISP:STANDARD-CLASS> and#<STANDARD-CLASS COMMON-LISP-USER::BAR> are incompatible."
<phoe> STANDARD-OBJECT also comes into play here.
<phoe> STANDARD-OBJECT is the default superclass if no superclasses are provided.
<shka_> phoe: inherit standard-class for bar
<beach> Yes, for standard classes it is.
<phoe> So, basically, I am trying to create a class FOO with metaclass BAR and superclass STANDARD-OBJECT.
<phoe> shka_: I already did.
<phoe> Note that BAR already is a STANDARD-CLASS in the error message.
<shka_> hmmm
<phoe> And the error message states that the metaclasses are not compatible.
<shka_> aaah i know
<shka_> it is not about metaclasses
<phoe> So VALIDATE-SUPERCLASS returned NIL somewhere.
<beach> I think you need to validate the relation between STANDARD-CLASS and BAR.
<shka_> phoe: validate-superclass is there to help establish relation between metaclass and base-class that pops up commonly
Kundry_Wag has quit [Ping timeout: 246 seconds]
<shka_> by default, it will return nil if you messed up with that, so you will have to add specialization for it as well
<phoe> I think I know why I am confused.
<phoe> (validate-superclass class superclass) <- that is the lambda list of that function.
<phoe> But the arguments, as far as I understand it, are the *metaclass* and the superclass of the class I want to define.
<phoe> Not the class itself.
<shka_> yes
<phoe> That's how I understand it right now.
pierpal has joined #lisp
<phoe> In VALIDDATE-SUPERCLASS, are all superclasses checked against the metaclass, or just the first one?
<phoe> The latter doesn't make sense for me.
<phoe> I mean direct superclasses.
pierpal has quit [Ping timeout: 268 seconds]
<larryba> (weekday-from-to earlier later) earlier = monday. later = monday. should the result be 0 or 7?
pierpal has joined #lisp
<Xach> god jul
<_death> context-dependent.. it's better to have a use case in mind before trying to come up with abstractions
<phoe> Actually, wait.
<phoe> Does VALIDATE-SUPERCLASS validate the metaclass of the class against the metaclass of the superclass?
atgreen has joined #lisp
<shka_> phoe: no
<shka_> validate-superclass validates superclass against metaclass
<shka_> as names suggest
<shka_> it should be called validate-superclass-using-class
<phoe> If that is true, then I do not know why the error messages states that it is the metaclasses that are incompatible.
<phoe> Not "metaclass and superclass", but "metaclasses".
<phoe> I assume that the other metaclass is accessed using (class-of superclass), but, in the end, it's the metaclasses that are declared compatible or not. This is my current understanding.
<shka_> eh, maybe i am wrong, let me check docs
<Xach> i have to research why all my bitbucket pulls are failing
<shka_> This generic function is called to determine whether the class superclass is suitable for use as a superclass of class.
<larryba> weekdayFromTo(earlier, later) earlier = monday. later = monday. should the result be 0 or 7?
<shka_> phoe: actually, i don't know
<phoe> Yes, it is called to determine that. And the determination is done by comparing their superclasses.
<phoe> Uh, not comparing.
<phoe> Doing something with them.
FreeBirdLjj has joined #lisp
koowgnojeel has joined #lisp
razzy has quit [Ping timeout: 272 seconds]
SaganMan has joined #lisp
<phoe> I think I got it.
<koowgnojeel> Hi
<phoe> Hey koowgnojeel
<koowgnojeel> Hi phoe
seok_ has quit [Quit: Page closed]
<phoe> (defmethod validate-superclass (class (superclass (eql (find-class 'foo)))) nil)
<phoe> Is this enough to prevent a class from being subclassed at all?
<shka_> no
ebrasca has quit [Remote host closed the connection]
<shka_> because validate-superclass specialized on class goes before over your specialization on superclass
<phoe> Oh right
Lycurgus has joined #lisp
<phoe> s/class/(class class)
<koowgnojeel> I don't know LISP at all. Can I stay here?
<Lycurgus> sure, why not? did you plan to do something stupid?
<phoe> koowgnojeel: sure, why not?
<phoe> if you want to learn it, there's #clschool; if you want to hang out in general, there's #lispcafe; if you want to stay a while and listen, there's all of these channels
<koowgnojeel> Thanks.
<Lycurgus> there are other lisp beginner channels though, and another major dialect of lisp, this channel probably should be called #common-lisp
<Lycurgus> s/other//
seok has quit [Quit: Page closed]
Kundry_Wag has joined #lisp
didoerpl has joined #lisp
<didoerpl> can an OS kernel be written in Lisp?
<didoerpl> as Lisp is fast enough compiler sbcl. ?
<shka_> didoerpl: it was already done, multiple times
Kundry_Wag has quit [Ping timeout: 250 seconds]
<phoe> didoerpl: see Mezzano for the most recent example
<didoerpl> I am talking about a general purpose operating system. Are there any
<koowgnojeel> Suggest me one please between `clisp` and `sbcl` ?
yvy has quit [Read error: Connection reset by peer]
<didoerpl> clisp = sbcl koowgnojeel
<koowgnojeel> Thanks
<didoerpl> just change the compiler code will remain the same lol
<didoerpl> it's like saying pypy vs Cpython ...
<phoe> koowgnojeel: for the basics, it doesn't really matter if you use SBCL, CCL, or CLISP.
<koowgnojeel> $ sudo aptitude install clisp -> No candidate version found for clis
<shka_> didoerpl: mezzano is pretty much general purpose OS
<shka_> you can play quake on it
<phoe> A good pre-configured Emacs bundle is Portacle,
<shka_> it has irc client
<shka_> and stuff
<koowgnojeel> clisp*
<phoe> It bundles Emacs, SBCL, Quicklisp, and Git - everything that you need to start hacking in Common Lisp.
<phoe> Grab that, and a copy of PCL, and you should be good to go.
<koowgnojeel> Git has LISP too ?
<phoe> minion: tell koowgnojeel about pcl
<minion> koowgnojeel: please see pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at and in dead-tree form from Apress (as of 11 April 2005).
<phoe> Well, Git is useful when you want to pull some projects from the Internet.
<koowgnojeel> Thanks.
<phoe> Okay. I know why I was so confused.
<phoe> The SBCL error message is at fault, here, too.
<phoe> "The class #<STANDARD-CLASS COMMON-LISP-USER::SUPERCLASS-1> was specified as a superclass of the class #<STANDARD-CLASS COMMON-LISP-USER::SUBCLASS-2 {1005372693}>, but the metaclasses #1=#<STANDARD-CLASS COMMON-LISP:STANDARD-CLASS> and #1# are incompatible."
<phoe> Look, according to this error message, I made STANDARD-CLASS incompatible with itself.
Essadon has joined #lisp
<koowgnojeel> phoe: Do you know Graphviz library for CLISP?
<pjb> koowgnojeel: several.
<pjb> koowgnojeel: but why do you want it specifically for clisp?
<koowgnojeel> To learn CLISP :)
<koowgnojeel> with fun.
makomo has quit [Ping timeout: 246 seconds]
<pjb> Why do you want to learn clisp, instead of Common Lisp?
<pjb> koowgnojeel:
<pjb> koowgnojeel: That said I'd encourage you to learn clisp and to help maintain it.
<pjb> But first you'd have to learn Common Lisp.
pfdietz has quit [Ping timeout: 268 seconds]
Lord_of_Life_ has joined #lisp
<koowgnojeel> I meant Comment LISP :) (I thought they are both the same.)
<koowgnojeel> Common*
Lord_of_Life has quit [Ping timeout: 246 seconds]
<didoerpl> whatis alll this clisp vs common lisp?
koowgnojeel is now known as New2LISP
<phoe> CLISP is an implementation, Common Lisp is a language.
<phoe> It's the same as in, GCC is an implementation, C is a language.
<didoerpl> exactly! you read my heart. but he said ...
Lord_of_Life_ is now known as Lord_of_Life
<didoerpl> <pjb> Why do you want to learn clisp, instead of Common Lisp?
<didoerpl> my question : is lisp more safe to write safe code than C . I know neither C nor Lisp. Hence the question.
<didoerpl> with C I can make easily mistakes to buffer overflows and memory errors, but with lisp ... what's the situation
<didoerpl> in terms of writing secure code
<phoe> Lisp is a memory safe language.
<phoe> You do not have direct access to raw memory unless you explicitly ask for it.
rumbler31 has joined #lisp
<didoerpl> yup. Also fortran is slow for kernel stuff, but fast for numerical computing... so with lisp what's the deal being fast in kernel ? how fast/slow is it with respect to low level code when compared to C
<didoerpl> also could bitcoin be written in Lisp,
<beach> didoerpl: Perhaps by "general purpose operating system" you meant a UNIX-like operating system. It would be a shame to use such a good language as Common Lisp to write a clone of such a crappy system.
<pjb> didoerpl: it's likke C vs. gcc; who would ask about libraries for gcc or to learn gcc?
<phoe> bitcoin can be written in any programming language; there are multiple implementations of it in multiple languages already.
<pjb> didoerpl: of course, you can learn gcc; you can read the gcc user manual to know what options to use, you can read the sources of gcc to help debug and improve it.
<pjb> didoerpl: but a newbie should learn C, not gcc or icc or clang.
wigust- has quit [Ping timeout: 240 seconds]
wigust has joined #lisp
jcowan has joined #lisp
<didoerpl> phoe: in which languages.
<didoerpl> beach: UNIX-like openbsd/Linux is crappy.. why would you say that?
<didoerpl> so you use mezzano ? really ? over bsd/linux ?
<pjb> didoerpl: I would advise you to use gcc 7 or 8, and gcc -fsanitize=address -fsanitize=null -fsanitize=bounds -fsanitize=vla-bound -fsanitize=object-size -fsanitize=unreachable -fsanitize=return -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fsanitize=nonnull-attribute -fsanitize=returns-nonnull-attribute -fsanitize=bool -fsanitize=enum -fsanitize=vptr -fsanitize-address-use-after-scope
<pjb> -fsanitize-undefined-trap-on-error -fstack-check -Werror -Wall to compile or C programs.
<didoerpl> beach: saying is easy openbsd is the best quality code you got outthere, I feel. don't know why would you call it crappy.
<pjb> (always, including in production).
isBEKaml has joined #lisp
wanz has quit [Quit: wanz]
<phoe> didoerpl: the Internet tells me C++, C#, Go, ECMAscript.
<didoerpl> in what way lisp OS is different ?
<phoe> didoerpl: it's not about the code itself, it's about the language being very limited in abstraction and provoking errors because of that. No matter what you do in C, you are always tweaking raw memory.
<didoerpl> when was mozzeno written
<pjb> didoerpl: have a look at
<pjb> didoerpl: recently.
<pjb> and it's mezzano
<didoerpl> So you hate unix-like OS, and think lisp based os is the future because of less low level tweaking and more abstractions?
<New2LISP> It looks fun.
<phoe> didoerpl: not really hate, and I don't think it's the future
<didoerpl> ok. why?
<New2LISP> Thanks all. I'll practise Common-LISP with this example.
<pjb> The problem is not so much love of hate, but inadequacy or misuse of tools.
<pjb> For example, using C to write an application is dumb. C is designed to write unix kernels.
<phoe> Unix is simply ugly, but a Lisp OS likely has too little manpower to take off to the point of rivaling the already established OSes.
<pjb> Using a unix kernel as a multi-user operating system in a network is dumb.
<didoerpl> but since I don't know mezzano - do you "think" lisp is as fast as C for low level stuff. Or is C still the king when it comes to speed.
wanz has joined #lisp
<pjb> didoerpl: first have a look at:
<pjb> didoerpl: then try to ask again.
<beach> didoerpl: I recommend "The UNIX haters handbook". It was written by some very smart and very knowledgeable people who know that UNIX is not as great as what was before, nor as great as what could be if we liberated ourselves from thinking that UNIX is the best thing ever.
<didoerpl> how is Lisp based OS , beautifyl? What's the "new" design approach and paradigm.
New2LISP is now known as koowgnojeel
<pjb> didoerpl: also, you may want to read some references from
<koowgnojeel> See you all next time. Merry Christmas everyone.
<pjb> didoerpl: new is not beautiful.
<didoerpl> I am talking about the design paradigm.
<beach> didoerpl: Lisp operating system are very likely NOT the future. Just better than what we have. Worse-is-better has won.
wanz has quit [Client Quit]
<pjb> didoerpl: this is new: this is old:
<pjb> didoerpl: Your brains don't seem to be functionning correctly. Are you sure learning about lisp should be your priority?
<beach> didoerpl: You might get inspiration from this article:
FreeBirdLjj has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
FreeBirdLjj has joined #lisp
<beach> didoerpl: Chapter 1 of this specification: (of a system that does not exist yet, it is not Mezzano) will give you an idea of everything that is wrong with current operating systems.
<shka_> pjb: lol, what the heck is that?
Kundry_Wag has quit [Ping timeout: 250 seconds]
<shka_> and where is it placed?
<pjb> In the middle of the Palace of Versailles
<pjb> And there's worse in the gardens.
<shka_> wow
<pjb> CIA's done a good job. Complete victory.
FreeBirdLjj has quit [Ping timeout: 268 seconds]
<didoerpl> I do think C is too hard to write and introduce buggy code in kernel. ...
<shka_> pjb: verschlimmbessern
<pjb> Not really, it's done on purpose to destroy countries.
<pjb> It has been done.
<pjb> It's so completely over, that by the FOIA they already disclosed everything.
<shka_> didoerpl: it is true, but given inertia of whole industry and general lack of innovation in the mainstay OS this days don't count on having anything then unix or windows (windows is in many ways unix btw) to become even remotely popular
<pjb> Well, more precisely, Windows (WNT) is VMS.
<shka_> pjb: yeah
<shka_> also, C has become THE sole language to implement OS level stuff
koowgnojeel has quit [Remote host closed the connection]
themsay has quit [Ping timeout: 246 seconds]
<pjb> Wrong. People are writing OSes in all kinds of languages nowadays.
<shka_> which to be honest: sucks
<shka_> pjb: where are the devices running those OSes?
<pjb> I said OS, not drivers.
<shka_> heh
<pjb> People don't have the resources to write the drivers.
<shka_> true
<shka_> anyway, this shows how difficult it is to actually make difference in the industry
<shka_> but mezzano is quite impressive
<shka_> it will be just a hobby project, but it is impressive anyway
themsay has joined #lisp
themsay has quit [Ping timeout: 245 seconds]
drichards has joined #lisp
FreeBirdLjj has joined #lisp
<didoerpl> windows is UNIX
<didoerpl> hmmm
atgreen has quit [Ping timeout: 244 seconds]
<shka_> didoerpl: has many characteristics of unix
<didoerpl> I see lisp world people are very different that C/Unix world.
<beach> Indeed.
<beach> didoerpl: As I understand it, #lisp is one of the most helpful channels around.
<didoerpl> shka_: If you would say that on linux they would laugh at you. Although I love lisp,lisp OS.
mrcom has quit [Read error: Connection reset by peer]
<shka_> didoerpl: actually windows is officially posix system
<didoerpl> how come ?
<beach> didoerpl: It is a sad fact that UNIX and C has managed to brainwash several generations of users and programmers.
<shka_> while linux is not ;]
<Lycurgus> why sad?
<didoerpl> beach: I think you may know more than me, but why do lisp people know all this thing that C/Unix is limited... and not non-lispers
<shka_> Lycurgus: brain is terrible thing to wash!
<Lycurgus> shka_, i c
<beach> didoerpl: Very simple. Lisp people are generally more experienced, better educated, and also on the average older.
<Lycurgus> i would say if not unix/c, then what?
<didoerpl> beach: is it "practically" possible to write such an OS, ... will it be functionable ? Why hasnt such imaginary OS as closos been not created yet.
<beach> Lycurgus: You have missed years of discussion here, it looks like.
<didoerpl> beach: me too.
<shka_> didoerpl: it is possible, it was done multiple times
<beach> didoerpl: Because the psychological barriers are huge, and industry and teaching institutions are brainwashed as well.
<Lycurgus> personally I would have preferred that the burroughs architecture could have filled that niche; I've been here since c. '02
<shka_> but it is not and probably will be not mainstream
<phoe> didoerpl: the Unix philosophy that everything is a file is dumb
<Lycurgus> (not necessarily as Lycurgus)
<phoe> Some abstractions very poorly fit the model of "a stream of bytes that may return data, block, or return EOF".
<beach> didoerpl: But look into Genera.
<didoerpl> ok where are those other projects...all of them failed? phoe why ? what do you mean? that what is smart, -- everything is a file..
<Lycurgus> but ultimately burroughs was a proprietary dead end, and unix/c was the opposite of that
<phoe> In particular, anything object-oriented needs to be parsed to text and unparsed from text before it is processable again.
<didoerpl> I can access hard disk low level using /dev/sda file!!
<didoerpl> which would not be possible without it...
<phoe> Sure, but you cannot pass an object through a Unix pipe.
<phoe> Low-level access is possible, higher-level abstractions aren't.
<shka_> didoerpl: why not?
<Lycurgus> you mean phoe
<shka_> no
<shka_> i mean didoerpl
<phoe> Also, /dev/sda is just a thing created by Unix. In reality, when there's no Unix, there's no /dev/sda.
<Lycurgus> no i c that now, both maybe
<shka_> why you need a file?
<didoerpl> shka_: ok so how do you access the hard disk on a lisp - based OS ?
<Lycurgus> serialized objects can flow thru channels
atgreen has joined #lisp
<didoerpl> without the file system...low level- you know that kind of stuff like dd
<shka_> didoerpl: i would expect function called (access-storage) or something
<beach> didoerpl: If you are interested in operating systems, you need to do what the UNIX brainwashed crowd has failed to do, namely read up on computing history. In particular about Tops-20, Multics, and Genera.
<beach> didoerpl: Then you can see what you are missing with UNIX.
<didoerpl> But multics = multix = unix
themsay has joined #lisp
<phoe> didoerpl: the same way Unix accesses it
<beach> didoerpl: You have got to be kidding.
<shka_> didoerpl: nooooo
<beach> didoerpl: But we could do even better today now that we have 64-bit machines.
<phoe> How does Unix implement /dev/sda?
<didoerpl> phoe: don't know.
Lycurgus has left #lisp ["Deus Ex"]
<phoe> didoerpl: then read up. That is the way that is also used by a Lisp ODS.
<phoe> OS.*
<beach> didoerpl: I agree with phoe. You need to read up now.
<didoerpl> do you use one?
<beach> didoerpl: The only reasonable OS available to me today is sadly GNU/Linux.
<didoerpl> hah
<beach> didoerpl: And it will likely remain that way, because there is no funding for creating anything better.
rjid has joined #lisp
<beach> didoerpl: You should read (yes, more reading) the slides by Rob Pike:
atgreen has quit [Ping timeout: 250 seconds]
themsay has quit [Ping timeout: 272 seconds]
<MichaelRaskin> Re: availability of any sane OS. Tesla was asked to comply with GPL and provide sources. They tried. Guess how many iterations did Tesla need to force Nvidia to comply with GPL and provide working sources for the board support code?
<MichaelRaskin> And it was Tesla
<beach> Wow.
<MichaelRaskin> And iterations are truly iterations: each iteration produced some code which was strictly better than the previous time
<beach> didoerpl: All that reading material we have given you is known to many Lispers, but sadly completely unknown to the brainwashed UNIX/C crowd. So you have some reading to do if you want to become smarter, or at least more knowledgeable.
rjid has left #lisp [#lisp]
<phoe> I'd like to ask you folks for a review of an article I just wrote -
FreeBirdLjj has quit [Remote host closed the connection]
<phoe> It's an attempt to cure my personal confusion about VALIDATE-SUPERCLASS.
FreeBirdLjj has joined #lisp
<beach> phoe: I have to decline. I have been up working for way too long today already, and my brain is fried.
<phoe> beach: no problem!
<beach> phoe: Educating didoerpl is the most complex task I can imagine doing right now. :)
<didoerpl> The design and features of Multics greatly influenced the Unix operating system, which was originally written by two Multics programmers, Ken Thompson and Dennis Ritchie. It always gave any sane man the person multics = unix
<shka_> didoerpl: Ken Thompson decided to put OS on minicomputer and that became Unix
<shka_> so unix was designed around limited hardware
<shka_> and was designed by limited team
<shka_> also implemented
<didoerpl> I'd love to use closos!
<beach> Me too. :)
<shka_> beach: you need to relax, grab some book or something
FreeBirdLjj has quit [Remote host closed the connection]
<shka_> make yourself a tea
<didoerpl> educating me? I came from the C/unix crowd
<didoerpl> I know C partially.
<didoerpl> but preferred python as it's more useful
FreeBirdLjj has joined #lisp
<beach> shka_: Yes, I know. Thanks.
<shka_> beach: enjoy your evening :-)
anamorphic has joined #lisp
<jcowan> For the record, C was not written in order to write the Unix kernel in it. The kernel remained in assembly language for some time after C was born from B.
pierpal has quit [Ping timeout: 244 seconds]
<didoerpl> But I cannot take UNIX haters book seriously. do you?
<beach> It is very serious.
<beach> I didn't read it for the longest time, because I thought it was written by ignorant people.
<didoerpl> Are you kidding ... like which "concept" don't say things like rm * .os oppps it's the fault of the system, or something stupid like that
<beach> But these are very smart and very knowledgeable people who know that better things existed before and better things can be had.
FreeBirdLjj has quit [Ping timeout: 272 seconds]
<beach> You need to concentrate on the global picture. Not the small details.
<verisimilitude> All I want for Christmas is UNIX-likes to die.
<didoerpl> I saw no global picture, I thought that book is a joke
<beach> It is definitely not a joke.
<beach> Perhaps your knowledge of computing history is lacking.
<_death> the book was shipped with a barf bag.. I wonder how many were put to use
<shka_> hehe
<didoerpl> verisimilitude: you "should" want a good OS to supersede it, not unix to die, just like you 'd want bitcoin to overtake the idiotic dollar
<verisimilitude> If implementing an OS in Lisp seems silly and C seems natural, take a look at Ada, didoerpl, for another perspective.
<verisimilitude> It's my understanding bitcoin lacks the anonymity of the dollar, so I wouldn't want it to overtake it, really.
<shka_> didoerpl: essentially UNIX has outgrow it's usefulness
<beach> shka_: I did manage to write some documentation today, for the packing algorithm of the AST visualizer I am working on:
<verisimilitude> Think of it like this, didoerpl: the ``file-based operating system'' has no file-locking mechanism that actually works.
<verisimilitude> There are actually several facilities for ``cooperative locking'', however.
<shka_> beach: so that is algorithm
<beach> shka_: It's the layout algorithm for the AST visualizer.
<beach> Or part of it, rather.
<shka_> for packing as much stuff as possible on the screen i presume
larryba has quit [Quit: CGI:IRC (Ping timeout)]
<beach> Yeah.
<beach> Without making it unreadable.
anamorphic has quit [Ping timeout: 245 seconds]
<shka_> sounds like general purpose stuff, not AST visualizer specific
<beach> That might very well be so.
<beach> But I want this thing done, so I am not trying to do research in packing profiles.
<beach> I just want a tool so that I can inspect my ASTs.
<shka_> i see that
marvin2 has quit [Ping timeout: 250 seconds]
<beach> If you look at you can see that an AST node and its arguments pretty much correspond to a profile in that documentation.
<shka_> you want to improve this further?
<shka_> it looks fine to me
<beach> The png is not packed enough. Hence the algorithm.
<shka_> ok
<shka_> so essentially those things like l-t-v below call would be placed higher up
<shka_> and whole tree would shrink as a result
<beach> Exactly.
pierpal has joined #lisp
<pjb> If not unix/c, ask yourself what kind of OS is used in LtCmdr Data, or in the Enterprise computer systems… ;-)
<pjb> didoerpl: do fishes know there's water? Non-fish do know water and air better than fishes.
Arcaelyx has joined #lisp
anamorphic has joined #lisp
<pjb> phoe: actually, there's one kind of object that can be passed thru a unix pipe in (some) unix systems: file descriptors!
<phoe> pjewww
<didoerpl> sbcl is written in which language ? is clisp 100% lisp written.
<pjb> And since in unix, all everything's a file!
<shka_> didoerpl: some C, mostly lisp
<pjb> sbcl is written half in C half in lisp.
<beach> didoerpl: SBCL is mostly in SBCL.
<pjb> clisp too.
<pjb> but not the same halves :-)
<pjb> sicl is written in 100% CL.
<pjb> beach: not in LOC.
<didoerpl> sbcl is the implementation sbcl source code is the language.
<didoerpl> so sbcl cannot be in sbcl
sjl has quit [Ping timeout: 268 seconds]
<didoerpl> just like gcc cannot be in gcc
<beach> didoerpl: It can and it is.
<pjb> Oops, sorry, it's 10% C 90% lisp for sbcl: 47023 Lines of C, 546496 lines of lisp.
<beach> Both SBCL and gcc.
<pjb> didoerpl: it's not that it cannot. It can. It's that it's easier to use the libc to interface with the unix kernels, rather than write a liblisp targetting each unix kernel.
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
ebrasca has joined #lisp
parjanya has joined #lisp
<beach> didoerpl: Most of SBCL is written in standard Common Lisp, so it can be bootstrapped from a different Common Lisp implementation, but there is no particular reason to use a Common Lisp implementation other than SBCL to bootstrap it.
<pjb> didoerpl: multics is not unix, it's the opposite. unix did everything opposite to mutics. multics was a multi-user OS. unix was a single user OS. multics was complex, unix was simple. multics ran on big iron, unix on minicomputers. multics had sophisticated file formats and file system, unix has a simple sequence of byte file format and file system. multics had all kinds of objects (in OO terms), unix has only files.
<didoerpl> pjb: how did you count the lines how did you know that
<phoe> didoerpl: there's a utility called kloc.
makomo has joined #lisp
<beach> didoerpl: I gave the reference to Xof's paper about it.
<beach> page 3
<phoe> oh wait, cloc.
<pjb> didoerpl: git clone ; cd sbcl ; find . -name \*.lisp -exec cat {} + | wc -l ; find . -name \*.[hc] -exec cat {} + | wc -l
meiji11 has joined #lisp
<pjb> didoerpl: you don't seem to know anything but misconceptions. If you can't imagine and give this command, you don't know unix.
<pjb> didoerpl: so, my advice would be 1- ask a refund for your educa$ion, 2- start to learn anew.
<anamorphic> Hi, Is there something like Smalltalk's Seaside web framework, but for Lisp?
<pjb> anamorphic: there are web frameworks for lisp.
atgreen has joined #lisp
<pjb> anamorphic: ask in #lispweb
<anamorphic> Ah ok thanks. Had no idea lispweb existed
<verisimilitude> It's disgusting that the notion of a ``kernel panic'' even exists in a modern operating system; you don't know the history of this phrase, do you, didoerpl?
<didoerpl> verisimilitude: no
marvin2 has joined #lisp
<pjb> For example, how unix blocks on I/O failures.
parjanya has quit [Remote host closed the connection]
<didoerpl> nope
<pjb> macOS still crashes during sleep because of USB devices!
<pjb> in 2018!
<verisimilitude> Multics had real error handling; UNIX had a routine called panic when anything went wrong. The history is a Multics programmer discussing how easily half the code he wrote was error handling code and Ritchie I believe remarks to the effect of they have this nice routine panic they call whenever something goes wrong and then yell down the hallway to restart it.
<verisimilitude> Now, people think it's natural for an operating system to fail sometimes.
<_death> everything fails, always
<didoerpl> yes, I experience kernel panic - so I think it's natural due to bad coode
<verisimilitude> Not everything must fail and, even if it did, it could certainly fail less often than it does.
atgreen has quit [Ping timeout: 246 seconds]
SaganMan has quit [Read error: Connection reset by peer]
<beach> didoerpl: Another example: Multics erased the difference between primary and secondary memory, so we knew how to do that in the 1970s. Since UNIX came along, that technology has been forgotten.
<_death> the tradition of Lisp is about robustness in the face of (some) failures
<verisimilitude> Oh, another; a program asked things of Multics by jumping to normal routines; UNIX has traps and special instructions and whatnot.
drichards has quit []
SaganMan has joined #lisp
sjl has joined #lisp
<pjb> and still, there are unix signals.
<verisimilitude> Yes; imagine signals as in CL provided by the operating system.
<verisimilitude> As with many things, UNIX provides a ``simpler'' and partial mechanism that can't be used to get the more advanced functionality.
mrcom has joined #lisp
<didoerpl> why you need OOP and the concept of an object in closos? UNIX has no concept of an object.. I don't think about it .. and passing objects to pipes , you lost me.
<beach> didoerpl: Right, UNIX has no concept of objects. That's one reason why it's so primitive. It also has the concept of separate address spaces for each process, so you can't pass a pointer from one process to the other.
pierpal has quit [Quit: Poof]
<pjb> didoerpl: unix is perfectly OO.
pierpal has joined #lisp
josemanuel has joined #lisp
<phoe> Because UNIX forces all data structures to be dumbed down to streams of bytes to even pass it from process to process.
<pjb> didoerpl: it has open to create a fd, then methods read, write, close.
<beach> Heh.
anamorphic has quit [Ping timeout: 250 seconds]
<pjb> There are subclasses of file, such as socket pipe directory.
<phoe> So there you go, simple inter-process message-passing already requires serializing and deserializing.
<pjb> and of course, when you send a write message to a file, it doesn't do the same as when you send it to a socket.
<pjb> beach: and as mentionned above, you can send object references (file descriptors) thru pipes too.
<beach> Sure.
<_death> in unix tradition, every program tends to define its own ad hoc text serialization, usually meant for a human's eyes.. if you want your programs to work together, for example by using the pipe, you usually have to munge the text so that the next program will be able to parse and process it.. since the ad hoc format may change from time to time, things will break from time to time. all this is acceptable in the world of unix.
<beach> They just don't mean the same thing on the other side.
<phoe> Somebody should just link the Unix Haters Handbook.
<phoe> As satirical as it is, it's also true.
<pjb> I did above.
<verisimilitude> I haven't been able to find an amusing Usenet post describing the life of UNIX, where UNIX was a poor, quiet child because his family could only afford a single roll of teletype paper a year and UNIX had to use its file system for inter-process communication. As you can imagine, it gets much worse when UNIX starts doing drugs at Berkeley.
<pjb> :-)
<pjb> You'll have to rewrite it.
rumbler31 has quit [Remote host closed the connection]
<_death> there are many variants of unix and its tools, and each contains its own slightly different format.. so you have portability problems.. sometimes details are missing, so you have to work around that.. since the text munging is also ad hoc and makes use of fragile and cryptic features like regular expressions, it's not unheard of for it to have its own bugs... if big Lisp systems are big balls of mud, unix systems are many particles of
<_death> glass and glue
heisig has quit [Ping timeout: 250 seconds]
nanoz has joined #lisp
<phoe> and the glass is sharp
<_death> since ad hoc formats are so fun, each program also has one for its configuration
<phoe> and the glue makes you high
<beach> I heard from a friend who worked in Wellington when I lived in Auckland, that the bank he was working for used regular expressions and Excel spreadsheets to pass important data about customer accounts to other staff members.
<didoerpl> I will just stick to python as For AI,ML it's good all libraries available.
<didoerpl> I think I will get very little advantage with lisp , and I am more interested in theory of lisp . by reading the John Maccarthy's lisp paper , rather than practice
<beach> Good luck. I hear Python is 50-200 times slower than a good Common Lisp implementation.
<_death> didoerpl: too bad these libraries are not written in python..
<didoerpl> which libs are NOT in python?
<_death> didoerpl: they have python bindings or higher-level layers
<_death> didoerpl: but they are usually written in C++..
<didoerpl> oh why would any lib be written in python. it's for python , say tensorflow. It's madness to written high performant libs in python.
<_death> didoerpl: right
<didoerpl> I am more into science and math and neural networks.
<_death> and so you have integration issues, incl. issues of portability, deployment, stability, ease of understanding, etc.
<didoerpl> I am also interested in automated stuff on OS, I am happy with python . It does everything I need. No I am not into job. - so I don't have a boss. Are you taking about job projects... uh.
<_death> all because the powers that be chose a language that's not amenable for performance
<White_Flame> (I'm quite happy reading this backlog of unix bashing. i'm usually the lone voice saying that single heirarchy filesystem and byte-streams as the fundamental abstractions is sorely lacking)
dale has joined #lisp
<didoerpl> I am happy with my current language - Python .
<beach> Good luck then.
<_death> and we're happy with our current language as well :)
<didoerpl> It's can be used to do automated trading even to make money.
<_death> at least some of us..
<didoerpl> No apis and interfacing in Lisp they have- all support python.
<White_Flame> all the backing C libraries that drive the python libs are importable into other languages, too
<White_Flame> in fact, many started off as their C variant before the Python wrapper layer was created
<_death> White_Flame: many are C++ libraries with tons of python-specific C++
themsay has joined #lisp
<White_Flame> _death: yeah, that's sad kludge territory
<didoerpl> Why is Lisp not suitable for ML and other high level AI stuff - non - systems related you know. Obviously that's why I hate C++, it's not for learning ML.
<_death> there was that Professional Automated Trading book that used Lisp.. on my list
<pjb> didoerpl: nothing is suitable for current ML. Current ML is done on GPUs.
<pjb> didoerpl: on the other hand, there's cl-cuda, and CL is highly suitable to generate code, including cuda code.
<didoerpl> I see python is the future as it's growing , and will completely overtake the field not just AI, web programming, but *any* non-kernel programming... Just see the curve in terms of adoption- Oh my god, by 2027- python takeover will be complete.
<pjb> Better than python or anything else.
<didoerpl> real ML is done on neural chips.
<pjb> didoerpl: yep python is the future, like thousands of programming languages that have been invented since 1958, and that have not survived. lisp is the second oldest surviving programming language. I bet on it for survival in 100 years.
<pjb> didoerpl: of course, in 100 years, singularituy will have happened, and we won't be programming anymore.
<didoerpl> 100 years? singularity will occur by 2045, so no AI takeover will be complete by then. -- all powered by python. Lisp is not growing in terms of usage for AI
<didoerpl> AI is everything , not shit cake systems / kernel programming in C. It's bad.
<pjb> So you know what you have to do.
<didoerpl> pjb: by 2045, not 2099
<_death> didoerpl: I think python already lost to javascript.. so you may want to get on that.. uh.. train..
m0w has joined #lisp
<pjb> didoerpl: a 100 years is in 2118
<pjb> so basic arithmetic is not in your skill set either…
<didoerpl> js lost to webassembly. js is crap cake, it's for me. I do automating by pc, and AI. But I still don't understand why is Lisp not popular when compared to python - despite clear performance advantages. hmmm
<pjb> because "python is the future as it's growing" :-)
<didoerpl> pjb: yup. but singularity is near. Read the book. By ray kurzweil.
<didoerpl> Yup - python is already a hot topic for control the AI
<pjb> didoerpl: the purpose of brains is not to store soundbites and to reproduce them. A parrot can do that. You watched too much SpongeBob SquarePants… Brains are made to think!
<didoerpl> and control the pc for - Automating stuff using Python - There are books on that. I read them . I don't intend to learn another language- Python is so comfy. I don't understand why didn't Lisp is used as heavily as python for AI- despite performance
<pjb> didoerpl: start thinking!
<didoerpl> pjb: lol- brain IS a program. But a very large one. You need to seriously learn theoretical cs.
<didoerpl> brain is a python program.
<White_Flame> Python is now where Java was 10 years ago: the go-to language that has most the libraries
<didoerpl> I prefer to make python ai based brains.
<pjb> didoerpl: since python is so comfy and so good, then you should start thinking and infer a plan of action. For example, start by typing /leave and then /join #python
<White_Flame> and yeah, javascript is easily a competitor in that space
<verisimilitude> I'm always amazed at how a terrible language such as Python became popular.
<didoerpl> ok
<didoerpl> sorry pjb .
<_death> pjb: it takes time..
<didoerpl> verisimilitude: Terrible?
<pjb> _death: :-)
<didoerpl> It's easy to learn and "easy" to write.
<verisimilitude> When I learned about Python, I thought some of its qualities were jokes.
milanj has joined #lisp
<White_Flame> the brain is yet to be fully understood, so to claim that it is an implementation of any specific model is ignorant
<didoerpl> and look AI is - The ONLY thing that matters- programming 2.0 not 1.0
<verisimilitude> Things such as lambdas being restricted to a single line and no TCO and other drivel.
<verisimilitude> The brain is clearly a clock, White_Flame.
<didoerpl> White_Flame: nope - Brain cannot do "more" than a turing machine. - It can be proved.
<verisimilitude> Oh, wait, no; the brain is a radio.
<pjb> significant spaces. Blunders such as those have cost millions and billions long time ago already…
<verisimilitude> All joking aside, the brain isn't a formal system, I don't think, didoerpl, although your brain may be less capable than a Turing machine, sure.
<_death> python people keep claiming their code looks like pseudocode.. and that just gives away that their pseudocode is as low level as their language
<djeis[m]> Many things are turing complete- that doesn't mean we understand them.
<pjb> verisimilitude: we don't know if it's a formal system or not.
<pjb> verisimilitude: I would argue for formal system.
<verisimilitude> Since there are undesirable consequences of being a formal system, I believe it's not, pjb.
<didoerpl> In fact any "information processing system" cannot do more than a computer- because if it did - it would be a hypercomputer. But in the physical universe that is made of particles- Hypercomputers don't exist. Therefore brain is a computer.
<pjb> verisimilitude: it'd be nice to know at least that.
<verisimilitude> Otherwise, there are thoughts and whatnot humans are inherently incapable of.
<White_Flame> didoerpl: we don't know the extent & features of particles
<White_Flame> nor the boundary between particles and waves/strings/fields/etc
SaganMan has quit [Quit: WeeChat 1.6]
<verisimilitude> I refuse to participate in the reducing of mankind as a whole to unintelligent machines.
<didoerpl> Brain uses macroscopic particles, not quantum - so one thing is sure. Brain is classical, and quantum computer too is not superturing machine, it's just more efficient.
<verisimilitude> I choose to believe man is more than a machine.
<pjb> White_Flame: well the theory is that there's no boundary. A particule and a wave, locality and global reach, etc.
<didoerpl> verisimilitude: why not?
<pjb> ie. you can easily teleport elsewhere, if you can keep very still.
<White_Flame> pjb: right, and that really mucks with discrete turing-style modeling
<didoerpl> brain is superturing machine- That is what you are saying.
<djeis[m]> It's entirely possible that higher level brain processes are influenced by subatomic ones, we don't really know for sure.
<djeis[m]> I think it's unlikely/
<djeis[m]> But we really don't know.
<verisimilitude> A formal system combined with an informal system is an informal system.
<pjb> verisimilitude: it's true that we don't even know if this universe is closed or not, and there are theories indicating that it's not closed, that there are information exchanges with some external universe. So human beings (and other beings) could have some communicatig counterpart..
<pjb> of course, this would also explain some other strange phenomenon.
<verisimilitude> The brain could have, say, random influences that cause unpredictability and whatnot, as one example.
Bike has joined #lisp
akoana has joined #lisp
meiji11 has quit [Remote host closed the connection]
<pjb> verisimilitude: but we don't know the directionality and importance of those links. Some theory limit it to a few bit/second/brain in and out…
<_death> man is but a tree given life by the aesir, and trees are simply the hair of ymir
<verisimilitude> Anyway, let's return to how Python sucks.
<White_Flame> and if there are some field effects that the brain works in, brains might be mutually interfering with each other instead of being fully independent processes
<pjb> It's more like a graph than a tree, with sex and reproduction, if you watch it in 4D.
<djeis[m]> Python is... an odd language.
<verisimilitude> The version schism is just another nail in its coffin.
<djeis[m]> Convenient in some ways, massively frustrating in others.
<pjb> first rule of languages: reject languages that distinguish statements from expression, or have only statements.
<didoerpl> But brain "cannot" do anything MORE- just differently - it's called neuromorphic computing and we are getting there. But you don't even need neuromorphic systems, as you could have JUST a faster computer- and have VIRTUAL brain instead. Many brain sharing the same computer. Any information processing system is FORMAL. - according to Theory of computation. So aliens's brain is a COMPUTER- and we know how
<didoerpl> computers work- hence we know how the brain works. But not mind/consciousness- it's like an operating system. I know how computer works but not OS
<White_Flame> I agree that JS will overtake python. Especially now that there's webasm, we don't need a C FFI layer for fast back-end computation
<_death> (and ymir is born of the venomous yeast flowing through the elivogs in niflheim)
<verisimilitude> Ada is fine, pjb.
josemanuel has quit [Quit: leaving]
<didoerpl> djeis[m]: even if brain processes are subatomic- It's still a computer.
* _death wanders off ;)
<White_Flame> didoerpl: your "logic" is impressively backwards
<pjb> well, there's one thing that brains do better than our artificial system yet: it's synthesizing and "conscientizing" the masses of big data processed unconsciously by the lower levels.
<verisimilitude> It's good to be able to specify that a subprogram has no return value.
<didoerpl> OK. I know about theory of computation more than YOU all
<djeis[m]> didoerpl: For one thing, we don't know how neurons work. For another, we don't know how they interact.
<pjb> verisimilitude: but it must still be an expression of 0 values.
<djeis[m]> Like, at all.
<Bike> my first time on the channel in a week and it's like i never left
<verisimilitude> What, pjb?
<pjb> (values) is an expression in CL.
<didoerpl> I should stick with theory and not practice Lisp seeing your computational ignorance.
<pjb> It can be used in expressions: (list (values) (values))
<verisimilitude> Sure, pjb, but if you try to get a value from it you get NIL.
<pjb> of course, since it has no value :-)
thodg has joined #lisp
<verisimilitude> In a language like Ada, there's at least the efficiency argument for specifying that a subprogram really doesn't return anything.
<didoerpl> maybe this song sung by a computer will cheer you up-
<Bike> i bathe in computational ignorance.
<verisimilitude> So you're also in ##c, Bike?
<didoerpl> djeis[m]: did you watch the movie Matrix
<White_Flame> Bike: but surely you can understand that theoretical models dictate to the universe how it should be, especially for untested systems! ;)
<Bike> is that a burn on ##c for being full of computational ignorance, or a burn on all programming channels for being like this
<didoerpl> It's inside a computer - they go
<djeis[m]> didoerpl: Assuming that human brains are only as powerful as turing machines (which I strongly suspect but we really do not have any way to test) then we still have the issue that we don't have any understanding of the model the brain works on.
<verisimilitude> It was intended as a jab at the C language more than anything, Bike.
<Bike> cool, cool
<pjb> djeis[m]: finite universe.
<didoerpl> djeis[m]: did you watch the movie matrix
<Bike> i spent like six years getting a degree in neuroscience and it was clearly a mistake.
<TMA> what is the opposite of computational ignorance? halting problem oracle?
<djeis[m]> didoerpl: I'm not sure how that has relevance, but sure.
<pjb> Bike: why? didn't you learn anything about the brains?
<Bike> according to this channel, no
<pjb> :-)
<verisimilitude> Do you believe the brain is a formal system, Bike?
<White_Flame> instead of studying neuroscience, I accidentally studied zombie nutrition
<didoerpl> djeis[m]: a heroic dialog in the movie- So you are trying to tell me I can beat those agents by dogding bullets -- Morpheus said.... No neo what I am trying to tell you is you don't HAVE to. Meaning he will defeat them by stopping bullets in mid air in the movie.
<Bike> it's a formal system but not in any way that is particularly useful to think about
<djeis[m]> didoerpl: I still don't see the relevance.
<White_Flame> verisimilitude: physical reality is irrelevant of human models
<didoerpl> djeis[m]: the same with brains. HEY--we don't even know HOW brains work.... No djeis[m] - what I am trying to tell you- is that you don't HAVE TO understand how brain works, and therein lies the enigma.
<djeis[m]> didoerpl: I suppose? Honestly I'm not even sure what we're debating at this point.
<Bike> the matrix
<djeis[m]> I suspect that part of this is argument for argument's sake.
<verisimilitude> A model, sure, but a model isn't the real thing, White_Flame.
<Bike> personally i prefer the original backstory where they had humans locked up to use their brains for computers
<Bike> makes more sense than the energy thing
<djeis[m]> bike: agreed
<Bike> of course, the real important thing is the Gnostic background
<didoerpl> When you understand THAT you will have reached the level of computational "equivalence" of all objects that exist in the universe. Also if you want neural design for computers- Then sure we literally have brains on computers that can convice you- Welcome to Neuromorphic computing.
<verisimilitude> This is just alphabet soup at this point, didoerpl.
<Bike> you could link, like, a journal
<Bike> a book
<Bike> but no you link a fucking youtube search query?
<verisimilitude> Also, you should avoid linking to youtube if at all feasible.
<djeis[m]> didoerpl: neuromorphic computing doesn't make brains on chips, it models something similar to brains on chips.
<White_Flame> "neuromorphic" means attempting to replicate the nature/structure of neural systems. They are not literally brains on computers
robotoad has joined #lisp
<Bike> there is some actual work putting neurons on chips
<djeis[m]> Similar to our understanding of how brains work, which is very primitive.
<White_Flame> and it can't be a replica if we don't know how they work
<Bike> you put a little bit of metal over the axons and then you can sense the activity with piezo whatevers
cyrixhero_ has joined #lisp
<Bike> it's neat
<didoerpl> haha . I am trying to find a proof of computational equivalence of brain to computers- but don't have it yet- I am getting there wwith baby steps. But seriously so you never heard of brained based computing - if this cannot convince you- then the theoretical proof is beyond convincing you. I can give you the proof and you will still spit at it.
<didoerpl> also what is this formal informal system gibberish.
<Bike> it's pretty basic maths
<didoerpl> You don't NEED a neuron- or axon - you can have a model of it- virtually as well. "model" is sufficient. If you want physical then for that I gave you neuromorphic implementattion as well, but still you ar not satisfied, either with virtual or real brains..
<Bike> you can't make a model of something you don't understand. how would you design it?
<Bike> i mean you can, but it won't be any good.
<pjb> Actually, it seems that neurons are more complex than the simple sigmoid adder we use in ANN. That they have memory and more complex behavior.
<didoerpl> I am more into math physics really- so I know what I am taking. I am not into programming that much, beyond automatic stuff on my pc, and other simple things- that are practically useful for me.
<Bike> Okay, but if you want to make a proof of computational equivalence, you should learn some computability theory, no?
<White_Flame> pjb: it wasn't that long ago that we discovered the frequency of impulses were as important (if not more) than the mere presence/amplitude
<didoerpl> Bike: They already models of virtual neural nets- what are you talking. ....
<Bike> Yes, I have written several models of neurons myself, even. They are not very accurate.
<didoerpl> I hope you are catching with with DL(deep learning)
dale has quit [Quit: dale]
<Bike> Deep learning is barely related to actual brains.
<djeis[m]> didoerpl: And we're just guessing that they model actual neurons. They seem to work, but that doesn't mean they reflect reality.
<White_Flame> we very much know that they do not model nor work like biological neurons
<Bike> Artificial neural networks are based on a model of neurons from like seventy years ago. They moved towards doing useful computational things rather than accurate modeling, and so modern neural networks have very little to do with biology.
<White_Flame> they're at best allegorical to them
<Bike> But even the modeling of biological neurons isn't that accurate.
<Bike> A single neuron is enormously complicated. You need to run PDEs for even one of the stupid things.
<White_Flame> a neuron, akin to most other cells, could be considered a "living thing" on its own
<didoerpl> Implementation details dont matter. Only the theory does. Implementation will be taken care of. You don't NEED to understand how the brain works, just like - You don't NEED to understand how fished swim to make a submarine. How brain works in detail is irrelevant. If computers don't think, then submarines don't swim.
<Bike> Taken care of by me, I guess.
<verisimilitude> You're wrong, didoerpl.
<didoerpl> No Neo - what I am trying to tell YOU is that is don't HAVE to understand how brain works.
<TMA> there is no theoretical problem with modelling neurons directly as they are. the only practical problem there is that we do not possess enough computing power to do that
<White_Flame> computers don't do what brains do. If they did, you'd have a basis
<didoerpl> Therein lies the enigma.
<Bike> I shouldn't have bothered with this. Merry Christmas, everyone, or solstice or whatnot. Didoerpl, you sound self taught, which means you unfortunately know one or two things without having been crushed. Get some humility or you'll be the next Temple OS.
Bike has left #lisp [#lisp]
<verisimilitude> The Matrix wasn't a particularly good film.
<didoerpl> White_Flame: lol I sent you a youtube song where the AI sings- SEEING is believing- but you laugh at me when I send those youtube links.
dale has joined #lisp
<White_Flame> you have a very limited view of what the brain does if you believe that computers can fully do the same
<didoerpl> AI can sing / paint -- and soon do everything the brain can. -- what more do you need?
<White_Flame> neural nets are cargo cult generators
<verisimilitude> I can solve the halting problem.
<phoe> this discussion is dangerously nearing #lispcafe, folks
<didoerpl> White_Flame: Yes, I don't know how brain works- because I UNDERSTOOD that I don't HAVE TO- and that is the magic.
<verisimilitude> I can solve the halting problem for arbitrary programs.
<TMA> verisimilitude: in full generality?
rumbler31 has joined #lisp
<White_Flame> didoerpl: I'm not even talking abotu "how", just "what"
<verisimilitude> Yes, TMA.
<verisimilitude> By all means, take this to #lispcafe, since I'm not in #lispcafe.
<White_Flame> a computer program does not have the learning capability of the human system
<djeis[m]> Just because we know (or at least I think it's reasonable to assume) that the mind is computable doesn't mean we can emulate its behavior with anything other than a perfect simulation of a brain, and that requires an untenable amount of computing power. Also, neural networks can do each of those things, but they can't do ALL of them.
<White_Flame> and I agree. Lisp-based python bashing would be more on topic here
m0w has quit [Read error: Connection reset by peer]
<djeis[m]> We don't have an NN model general enough to do all of those tasks without retraining.
<phoe> I'd like to get a review of my article about MOP that sums up all the stuff I've been confused about recently. If someone feels like it, I'll be grateful.
<djeis[m]> Only specific models for specific NN-solvable problems.
<didoerpl> djeis[m]: Man, all of you are beyond hopeless, but in 2040 you will remember on irc chat you met me ,and my predictions came true...maybe then you will believe till then just remember me till 2039
<White_Flame> didoerpl: you're a clone of many who have come before you
<didoerpl> NN don't "solve" problems, you are mistaking the forest for the treees.
<didoerpl> White_Flame: nope I am different.
<White_Flame> many of us have gone through these progressions ourselves
<White_Flame> heck, the entire AI field has
<didoerpl> not really.
lavaflow has joined #lisp
<verisimilitude> I don't really find it fair to compare Terry Davis and didoerpl.
<djeis[m]> didoerpl: I still hope we'll hit the singularity by 2040. I just don't think NN will be that solution.
<didoerpl> I am not lying I have understood something that you are just not getting.
<pjb> didoerpl: the population will be decimated in before 2030. I doubt there will remain much infrastructure and programmers to finish AI by 2040.
<White_Flame> we know exactly what you're describing, have understood it, and have seen the limitations you haven't, since your reverence of the ideal won't let you
<White_Flame> but other than that, #lispcafe to go further
cmatei has quit [Read error: Connection reset by peer]
<didoerpl> pjb: lol, the population won't be decimated by 2030 due to warface or some accident- All humans are paranoid and stupid.
<pjb> No, just by famine.
<djeis[m]> Human idiocy is WHY the population may not survive through the 2030s lol
<White_Flame> also, a reminder that "decimated" means remove 1/10th
<pjb> civil/religious/race war and illness.
<pjb> The classic works
<djeis[m]> But agreed, #lispcafe
<didoerpl> ok joine me on #lispcafe then
<verisimilitude> We haven't even hit Godwin's Law, yet, though.
<verisimilitude> Also, since I've not mentioned it yet, Merry Christmas.
<pjb> White_Flame: right; I meant divided by 10 not by 1.111… sorry.
<pjb> wait.
<pjb> right.
<pjb> decimated = divided by 1.111…111…
Jesin has quit [Quit: Leaving]
<verisimilitude> I suppose there's no reason to continue the Python bashing either, now.
emaczen has joined #lisp
<pjb> I note something however. We have cl-python but it is bit-rotting. Would that be because there's absolutely no python library worth using in CL?
<verisimilitude> I figured that would be because most Python anyone uses is actually C or Fortran and so wouldn't work with that implementation, pjb.
vibs29 has quit [Ping timeout: 250 seconds]
<pjb> verisimilitude: same difference :-) Conclusion: python is useless.
<verisimilitude> Yes.
vibs29 has joined #lisp
cyrixhero_ has quit [Remote host closed the connection]
Jesin has joined #lisp
Kevslinger has joined #lisp
isBEKaml has quit [Quit: WeeChat 2.3]
sjl has quit [Ping timeout: 268 seconds]
notzmv has quit [Ping timeout: 250 seconds]
sjl has joined #lisp
<shka_> it makes me wonder if it would be possible to create library for CL that would streamline using actual C libs of python
<jcowan> Glue (as in actual wood glue) is not useless just because most of the table or whatever is not made of it. Python is glue.
<shka_> yes, i just want to replace glue
<jcowan> The Python C API is extremely messy and exposes far more Python assumptions than it should, unfortunately
<shka_> boomer
<jcowan> beach: That's a great paper about reversal, btw
<PuercoPop> shka_: I recall Nick Levine showed something for using python libs at an ELS
<PuercoPop> and there is also burgled-batteries
<shka_> regarding neurons, there is this HTM model that i am currently figuring out in lisp
<PuercoPop> which allows interoping with Python as an inferior process
<shka_> as for the neural networks... first they abandoned biology, next they abandoned math
<shka_> PuercoPop: i know about this one
<jcowan> OTOH an easy to use layer on CFFI for talking to Fortran libs would be a Very Good Thing, along with a layer over CL arrays
<pjb> As if it didn't exist already…
<jcowan> Well, of course that makes it an Even Better Thing. Existent perfections are more perfect than nonexistent perfections.
orivej has quit [Ping timeout: 250 seconds]
<phoe> What is the difference between SLOT-DEFINITION-INIT{FORM,FUNCTION}?
<phoe> Oh. I see.
<jcowan> my main perception of the UHH is that it seriously needed an update even when I read it, and complains about well-known weaknesses. Also, too much of it is about X, which really has nothing to do with Unix and is for the most part an anti-pattern for Unix (though not inherently bad, any more than Emacs is)
sjl has quit [Ping timeout: 272 seconds]
milanj has quit [Quit: This computer has gone to sleep]
rumbler31 has quit [Remote host closed the connection]
<verisimilitude> Wouldn't you use the Fortran compiler to Common Lisp for that, jcowan.
orivej has joined #lisp
simendsjo has joined #lisp
<TMA> phoe: I have read your article
<phoe> TMA: Thanks! What bugs have I made?
nanozz has joined #lisp
<jcowan> verisimilitude: Not unless it is more efficient than the Intel or GNU compilers.
<pjb> jcowan: still linux fails on the desktop :-)
* jcowan shrugs
<jcowan> For me, Unix is not about desktops, never was, and never will be.
<pjb> NeXTstep and macOS to a lesser extend demonstrate that unix can bear this load, however.
<jcowan> Indeed
<pjb> and honestly, better than WNT…
pjb has left #lisp ["ERC (IRC client for Emacs 26.1)"]
pfdietz has joined #lisp
pjb has joined #lisp
<adulteratedjedi> I use unix throughout, Illumos or BSD on the servers, and my Desktop is Freebsd
<verisimilitude> UNIX is clearly not suited towards desktop use.
<verisimilitude> It's not very good for servers, though, either.
rippa has quit [Ping timeout: 250 seconds]
<adulteratedjedi> Okay I'll bite. Not very good for servers, for what reason?
<verisimilitude> Oh no; someone got root on our server!
<verisimilitude> Let's revert the file system to a known good state, no wait.
<verisimilitude> Let's check the logs, no wait.
<verisimilitude> Let's just painstakingly take what we need and then wipe it and start over, yes.
<phoe> this also sounds like #lispcafe material
<shka_> indeed
<verisimilitude> I'd rather just stop, then, as opposed to being in yet another channel.
<adulteratedjedi> I can check the logs, and revert the filesystem to any state, good or bad (zfs!).. But yes sorry phoe I agree.
<verisimilitude> You can't trust the logs if they got root.
<TMA> phoe: I have not found any. the text is somewhat terse and I made sense of it on the second reading only.
atgreen has joined #lisp
<jcowan> Getting root is trivial compared to rootkits, and no OS is immune to those
<jcowan> or to the "trusting trust" attaack
<phoe> TMA: Yes. The text is an answer to a very specific problem, so it is terse. Maybe I will edit it tomorrow so it is a little bit more informative.
dale has quit [Ping timeout: 272 seconds]
<aeth> verisimilitude: Unix/Linux might not be good for servers, but the main alternative, Windows, is usually worse because of its focus on, well, windows. The #lisp solution is probably to contribute to Mezzano or some other Lisp OS since servers all run in VMs these days, anyway.
<jcowan> Unless you can build and operate your own fab, you are basically not immune to takeover.
<jcowan> "To secure a computer, disconnect all cables, find a deep dry well, drop the computer down the well, and then fill the well with concrete. The computer will then be fully secure."
<aeth> jcowan: Yes, but security by obscurity is, although often derided, imo a real thing. Especially if the OS is written in an OS they're not used to exploiting. It'd probably take popularity or a national security agency to exploit your LispOS unless it was carelessly written.
<aeth> s/written in an OS/written in a language/
<aeth> I doubt Lisp is immune to security bugs, but "everyone" knows how to exploit C/C++.
<aeth> And you can't just run a Ruby script with 10,000 exploits and see if any stick.
<jcowan> I don't think it's a matter of obscurity there, but of efficiency. It makes no sense to target a LispOS unless it is running something that is very much worth subverting.
<verisimilitude> To pretend that hardware and software aren't intimately tied for security, as UNIX does, is foolhardy.
<verisimilitude> I agree that an operating system written in anything besides C or C++ would necessarily be harder to attack.
<jcowan> People can write C++ in any language
<buhman> heh
<aeth> verisimilitude: well, at least until it's popular
<aeth> jcowan: as long as you can't disable bounds checking you're instantly more secure than C++ for this sort of thing.
<verisimilitude> I don't know; it takes several accidentally Turing-complete facilities to write C++ in any language well, jcowan.
<buhman> _death: what is that hardware?
<_death> buhman: it's a lisp machine on christmas
<buhman> no specific make/model?
dxtr has joined #lisp
<jcowan> Oh yes. TI Scheme was one of the earliest commercial Schemes
<jcowan> "Lisp Machine" capitalized but unqualified means a commercialized CADR, either by Symbolics or by LMI. Later models had their own names.
<buhman> > a port of Linux to the PowerPC
<buhman> that page is more dated than I thought
<aeth> Oh, and in case anyone is wondering, this is the safe way to remove bounds checking: (defun foo (a i) (declare (type (simple-array (unsigned-byte 8) (42)) a) (type (mod 42) i)) (aref a i))
didoerpl has quit [Quit: didoerpl]
<pjb> (defun foo (a i) (declare (type (simple-array (unsigned-byte 8) (42)) a) (type (mod 42) i)) (aref a i)) (foo #(1) 31) #| ERROR: The value #(1) is not of the expected type (simple-array (unsigned-byte 8) (42)). |# nope, not removed.
<pjb> even (defun foo (a i) (declare (type (simple-array (unsigned-byte 8) (1)) a) (type (mod 1) i)) (aref a i)) (foo #(1) 31) #| ERROR: The value 31 is not of the expected type (integer 0 0). |#
<pjb> you didn't remove anything.
<shka_> pjb: there was release note in sbcl
<shka_> two versions ago i think
<pjb> #+ccl here.
<pjb> and #lisp here.
<shka_> i suspect this is the source of misunderstanding :-)
<aeth> pjb: Right, what it actually does is that it pushes the bounds checking to the start of the function, which you have to do in a type declaration in SBCL, and probably in other implementations that respect type declarations as well. Simply checking the bounds in a conditional before won't remove the check iirc.
<aeth> pjb: So it's probably not faster in my simple example, but once you do several AREFs, especially in a loop, it'll be faster. Now, the real trick is figuring out how many iterations in a hot loop it would take before compiling a new function specifically for that array's length is faster than keeping the bounds checking in.
krwq has joined #lisp
yvy has joined #lisp
<aeth> (Most languages wouldn't even have the option to manually compile a new function at runtime if necessary!)
<aeth> pjb: Because in my example it doesn't remove anything but if you did (dotimes (j i) (format t "~D~%" (aref a j))) then the declaration starts to matter because it replaces i bounds checks with 1.
nanoz has quit [Ping timeout: 250 seconds]
nanozz has quit [Ping timeout: 268 seconds]
<pjb> I would expect it to remove them in any case. It's a smart little compiler, isn't it?
<aeth> You *might* be able to get that to become 1 bounds check in DOTIMES and LOOP and other simple iterations, but you could construct one that would fool the compiler.
kotrcka has joined #lisp
<pjb> And what about: (defun foo (a i) (declare (type (simple-array (unsigned-byte 8) (1)) a) (type (mod 1) i)) (foo (lambda (x) (setf i x))) (aref a i))
<pjb> with either a sequential foo, or a threaded foo?
<aeth> It looks like my example is complicated enough using DOTIMES enough to fool SBCL. You'd probably want to do (loop :for number :across a :repeat i :do (format t "~D~%" number)) to only bounds check once on an arbitrary array, although that still might need more information.
<aeth> That won't help you if you have to modify a, though.
<shka_> it works with map though
<aeth> shka_: Well, yes, but it's hard coming up with trivial DOFOO/LOOP that aren't overkill for the DOFOO/LOOP
<shka_> also works with reduce
<aeth> Where things get really complicated with avoiding bounds checking is when you have to set, too. Although I guess map-into could work with some simple cases of that.
<aeth> Consider something like this, though:
<aeth> The simplest solution I've found for stuff like that imo is to inline the function even though it's quite large (1000+ bytes) because then that solves all of the type/length issues. You just have to be aware that it's a large inline function so you can avoid certain things, like calling it too many times in a function without an inner non-inline flet.
hiroaki has quit [Ping timeout: 268 seconds]
<pjb> aeth: we really don't have to concern ourselves with that. Assume that you have a bound check expression before each access. The compiler can easily eliminate those expressions by removing duplicate subexpressions. It has nothing special to do. The check will be performed only once and only if needed.
dale has joined #lisp
<pjb> aeth: or you are implementing a compiler? Then I just explained that you don't have to deal with it, it's already taken into account by this more general optimization!
<pjb> FOO!
isBEKaml has joined #lisp
<aeth> pjb: I try to write the fastest programs on current compilers, rather than write for a hypothetical compiler developed with the financial resources of today's C++/Java/etc. compilers.
<pjb> ok
<pjb> again, that'd be the difference of point of view between #lisp and #sbcl…
Mr-Potter has joined #lisp
<verisimilitude> I write my Common Lisp how I think the compiler should be able to optimize it, without concern for how any single compiler actually does, if I even bother to do that.
<verisimilitude> Usually, there's an ideal way to write a function and if the compiler can't optimize that then that's its loss.
X-Scale has joined #lisp
<jcowan> The compiler doesn't have any interest in producing fast code, though its author may
<verisimilitude> Myself, I want to create a Common Lisp that focuses purely on size, instead.
<no-defun-allowed> Don't personify the compiler, it doesn't like that.
* jcowan chuckles
<jcowan> N properties of a compiler, pick K
<_death> size of what
<_death> generated code?
<jcowan> Of its organ, obvs
<isBEKaml> There are no organs. Only players
<verisimilitude> Yes, _death.
<_death> well, do you have info on how different implementations compare with regards to SPACE optimize qualities?
<verisimilitude> No; I don't care what the other implementations do.
<verisimilitude> I know they're all far too large, though.
<verisimilitude> What I intend to do is eventually create a Common Lisp implementation in which every decision leads towards optimal size complexity, rather than time complexity, with perhaps some exceptions in extreme cases; everything would be written optimized for size.
<verisimilitude> I figured I could call it LittleCL.
<_death> CLeine is smaller
mrcom has quit [Read error: Connection reset by peer]
<verisimilitude> Well, I wanted to call it CLOJURE:
<verisimilitude> Common
<verisimilitude> Lisp
<verisimilitude> Optimized for
<verisimilitude> Justified
<verisimilitude> Use of
<verisimilitude> Resources and
<verisimilitude> Entities
<verisimilitude> I still think that would be amusing to do.
Kevslinger has quit [Quit: Connection closed for inactivity]
emaczen has quit [Ping timeout: 250 seconds]
<phoe> Sure, let's introduce more confusion into the ecosystem. Newbies will be glad that it's not just CLISP and Common Lisp, and Clojure and Clozure having similar names.
<no-defun-allowed> That'd make clojure/clozure/closure even worse.
<_death> modifying an existing CL implementation seems easier
<no-defun-allowed> Oh god, clisp.
<_death> clisp could actually make sense, with its bytecode
<verisimilitude> Yes; that would be so amusing, wouldn't it?
<verisimilitude> Oh; there are certain things I'd do a certain way, even if it wouldn't lead to a smaller size.
<verisimilitude> As an example, since the output of TRACE is implementation-dependent, you could just cheat and have it do nothing; similarly for many other facilities.
<verisimilitude> That's just awful, though.
<verisimilitude> Similarly, I'd want it to compile to machine code, not a virtual machine code.
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 250 seconds]
shv4 has joined #lisp
permagreen has joined #lisp
Arcaelyx has quit [Ping timeout: 250 seconds]
dmiles has quit [Ping timeout: 250 seconds]
logicmoo has joined #lisp
frgo has quit []
mrcom has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
simendsjo has quit [Ping timeout: 244 seconds]
shv4 has quit [Remote host closed the connection]
shka_ has quit [Ping timeout: 244 seconds]
elderK has joined #lisp
<elderK> Merry Christmas, all!
themsay has quit [Ping timeout: 250 seconds]
shv4 has joined #lisp
meepdeew has joined #lisp
shv4 has quit [Remote host closed the connection]
frgo has joined #lisp
meepdeew has quit [Ping timeout: 250 seconds]
nowhere_man has joined #lisp
Bike has joined #lisp
vlatkoB_ has quit [Remote host closed the connection]
<phoe> What does COMPUTE-EFFECTIVE-METHOD-FUNCTION do? It is not described in the MOP.
<phoe> And yet it is exported by C2MOP.
isBEKaml has quit [Read error: Connection reset by peer]
<Bike> it's not in mop.
<Bike> maybe it's like compute-effective-method but takes it all the way to a function instead of remaining source.
<Bike> better yet, maybe it's documented
<Bike> doesn't look like it. shame.
<Bike> does seem to do what i said, though.
<Bike> couldn't tell you what you'd use it for, though.
<Bike> the default implementation seems to work manually instead of using a macrolet for some reason...
shv4 has joined #lisp
ebrasca has quit [Remote host closed the connection]
mrcom has quit [Read error: Connection reset by peer]
Mr-Potter has quit [Quit: Leaving]
mrcom has joined #lisp
shv4 has quit [Remote host closed the connection]
<phoe> Also, what is C2MOP's ENSURE-FUNCTION?
<phoe> I mean
<phoe> If I understand correctly, it instantiates the method, adds it to a GF, and returns the method.
<Bike> i would assume it is analogous to ensure-generic-function
<Bike> so basically the function version of defmethod
<Bike> so what you said.
<phoe> OK - thanks.
Arcaelyx has joined #lisp
wanz has joined #lisp
thodg has quit [Ping timeout: 240 seconds]
varjag has quit [Ping timeout: 272 seconds]
Zelmin has joined #lisp
CrazyEddy has joined #lisp
<pjb> jcowan: some compilers are intent on producing fastest running code. They may search a large space of possibility to generate the best possible instruction sequences. I hear gcc does this kind of optimization (but perhaps off-line, when processing the instruction set while compiling the compiler, I don't know).
Zelmin has quit [Ping timeout: 252 seconds]
<jcowan> There is such s superoptimizer, GNU Lightning, but AFAIK it is stand-alone
<pjb> ok.
<jcowan> If CL ever becomes really popular, there will probably be a compiler, or mode of another compiler, that is just as nasty-minded as gcc.
<pjb> Reall, if you want to get high speed, (or even small space), the best way to optimize it will be to perform a global analysis of the whole executable.
<jcowan> Yes indeed. I assume a CL-R compiler will be a whole-program compiler
<verisimilitude> A major difference is CL lacks undefined behavior around every corner, jcowan.
<verisimilitude> There's also multiple good implementations that set a baseline of quality.
<jcowan> gcc's behavior is high-quality, it's just not the quality that some people prefer.
<jcowan> It executes perfectly conforming code as fast as possible, with no forgiveness for non-conforming code.
<verisimilitude> I mean if there's an implementation that does screw with code and does things people dislike, there's plenty of other implementations.
<jcowan> It has been consciously optimized in that direction for many years.
<verisimilitude> Again, however, you can't screw with CL as easily as you can C, in detrimental ways.
<verisimilitude> The silent actions of GCC are another thing that wouldn't really fly in a Common Lisp implementation. The compiler is expected to tell you if something odd is happening.
Lycurgus has joined #lisp
isBEKaml has joined #lisp
<jcowan> But the standard does not prescribe it, and so the minute it becomes to anyone's advantage to have a compiler that does not warn, that's what we'll have.
<jcowan> With (safety 0) there are an awful lot of cases of UB
yvy has quit [Ping timeout: 246 seconds]
<verisimilitude> I really don't see that happening, in practice.
<verisimilitude> A decent Common Lisp requires decent interactivity.
<verisimilitude> In C, the supposedly low level language, it's not easy to even see what the compiler produces for a function, whereas DISASSEMBLE makes this effortless.
<jcowan> Well, except in ECL.
<jcowan> CL programmers value things other than execution speed, that's all. C programmers generally don't nowadays, unless they are using C under duress.
<verisimilitude> That's really something poor; I'd consider that a bug.