<no-defun-allowed>
Prior to that, there was also GNU Nettle (a C cryptography library). So it's not just Lisp projects, and it's not just software projects either.
rgherdt has quit [Ping timeout: 272 seconds]
greisean has left #lisp ["Konversation terminated!"]
EvW has quit [Ping timeout: 260 seconds]
<lotuseater>
i wonder how difficult it is to realize good and safe cryptostuff in CL. someone told me two years ago the best is in deterministic aka direct assembly
<lotuseater>
but i think the most crypto software is in C
johnjay has quit [Ping timeout: 256 seconds]
<thmprover>
Wheh, luckily, no one is using on github either, so I claim in it my own name.
mason has joined #lisp
<no-defun-allowed>
Ironclad makes an attempt to be constant-time IIRC, for example there is an equality operator that computes error |= x[n] ^ y[n], but it's really up to how the implementation handles things.
<thmprover>
My experiment with declarative theorem provers will henceforth occupy the CL-AIM project.
<thmprover>
CL-AIM will test my claim about the irrelevance of the choice for the foundations of mathematics.
<lotuseater>
thmprover: oh sounds interesting. i want to understand more how to work with ACL2, Coq and recently i read LāāN should also be good
torbo has joined #lisp
<thmprover>
ACL2 looks fascinating. I have a love/hate relation with Coq, but my interest is in doing mathematics with theorem provers, not verifying software.
<no-defun-allowed>
ACL2 is very different. It does the theorem proving process automatically, but you usually need to steer it with lemmas, and it only does first order logic (no higher order functions).
<lotuseater>
yeah and my knowledge of category theory, dependent types is not deep enough yet. but Haskell drills me to widen it. but that's another story. and I know ACL2 is another approach than Coq
<thmprover>
Automath is a good way to learn dependent types, but it's quirky...it's not even in the lambda cube.
<thmprover>
no-defun-allowed: I thought that "wandering" aspect to ACL2 was particularly unique and intriguing.
<thmprover>
Wait, hypothetical question: CL is a lisp-2, so there are separate namespaces for functions and values, right?
<thmprover>
Could I create my own separate namespace for, say, theorems?
<no-defun-allowed>
Yes, usually you would use a hash-table, and some accessor functions like FIND-THEOREM, (SETF FIND-THEOREM), ... to use the namespace.
EvW has joined #lisp
<thmprover>
no-defun-allowed: that was my first instinct, too, but it is a "poor man's namespace" rather than a first-class namespace.
<no-defun-allowed>
I don't think there are first-class namespaces in Common Lisp. And if you implicitly FIND-THEOREM on some things, you wouldn't be able to tell the difference.
<thmprover>
Yeah, I was just curious if first-class namespaces were allowed. It seems like quite a niche thing, so completely understandable CL would not have it.
<no-defun-allowed>
And all the CL namespaces are just sets of accessors (occasionally with an environment object).
ebrasca has joined #lisp
<Bike>
having an actual namespace would be most useful for when you want lexical bindings. not sure that's the case for theorems, though.
<no-defun-allowed>
Indeed.
<Bike>
also you can kind of hack lexical binding arbitrary things by abusing symbol-macrolet.
<Bike>
but only for compile time bindings
<thmprover>
I will have to study symbol-macrolet, I have a peripheral awareness of it, but haven't looked at it.
<Bike>
well, basically you can have your binding macro expand into (symbol-macrolet ((some-magic-symbol bindings)) ...), and then use (macroexpand-1 'some-magic-symbol env) to get the bindings.
<thmprover>
Can you override the meaning of a symbol temporarily using symbol-macrolet?
<Bike>
you bind what it means as a variable, if that's what you mean
<thmprover>
But you couldn't re-bind, say, 'let' (or some other builtin function) temporarily using symbol-macrolet?
<Bike>
let is a special operator, not a function. and symbol-macrolet deals with variables rather than operators. you can use macrolet to shadow operators.
<Bike>
but you can't shadow operators that are part of the standard CL package, such as let.
kaftejiman has quit [Remote host closed the connection]
<Bike>
because that makes macroexpansions really fraught.
<thmprover>
Alright, good to know, that will save me much trouble later.
Oladon has joined #lisp
frodef has quit [Ping timeout: 256 seconds]
<Bike>
oh, and you said CL was a lisp-2, but there are actually some more namespaces too, like the one for types and classes. doesn't come up immediately in the evaluation semantics though.
dhil has quit [Ping timeout: 240 seconds]
EvW has quit [Ping timeout: 244 seconds]
johnjay has joined #lisp
johnjay has quit [Ping timeout: 240 seconds]
johnjay has joined #lisp
zcheng3 has quit [Ping timeout: 246 seconds]
akoana has joined #lisp
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life has joined #lisp
jeosol has quit [Remote host closed the connection]
akoana has left #lisp ["Leaving"]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
jeosol has joined #lisp
Josh_2 has quit [Ping timeout: 246 seconds]
surabax has quit [Quit: Leaving]
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
Khisanth has quit [Ping timeout: 240 seconds]
Khisanth has joined #lisp
shifty has quit [Ping timeout: 256 seconds]
shifty has joined #lisp
frost-lab has joined #lisp
pfdietz has quit [Remote host closed the connection]
Stanley00 has joined #lisp
johnjay has quit [Ping timeout: 265 seconds]
johnjay has joined #lisp
thmprover has quit [Quit: This parting was well made]
vegansbane has quit [Remote host closed the connection]
zulu-inuoe_ has quit [Read error: Connection reset by peer]
<loke[m]>
I want opinions on a design choice:
<loke[m]>
Imagine a list of "graphical objects" (because that's what they are in Climaxima), and there is a generic function called SAVE-STATE that, when called with a graphical object as an argument returns its configuration as a specially formatted list (a Maxima list actually, but that doesn't matter).
vegansbane has joined #lisp
<loke[m]>
The caller has a list of these objects, and it collects the class name and the output of SAVE-STATE for each object.
<loke[m]>
So far so good.
<loke[m]>
Now, I need to write a LOAD-STATE that does the opposite. One way of doing that would be to take the class name, and call MAKE-INSTANCE on it with the values previously returned from SAVE-STATE as argument.
<loke[m]>
Another would be to have a big ECASE that knows about the object types and dispatch to the correct initialiser.
<loke[m]>
Suggestions?
galex-713 has quit [Ping timeout: 272 seconds]
<Bike>
make-instance sounds appropriate to me.
<loke[m]>
Bike: But that would add the requirement that whatever is returned from SAVE-STATE is in a form valid as argument to MAKE-INSTANCE. And it may be that some special internal state needs to be initialised that isn't visible from MAKE-INSTANCE. I'd like my solution to be as flexible as possible.
<loke[m]>
Another idea I had was to use ALLOCATE-INSTANCE and then call a generic function with this instance.
<loke[m]>
(I've never used ALLOCATE-INSTANCE though, and frankly it feels a bit dodgy
<Bike>
what make-instance does is call allocate-instance and then call initialize-instance on the result. initialize-instance can be customized with whatever keyword parameters for providing whatever state.
Fare has quit [Ping timeout: 264 seconds]
<loke[m]>
I see.
Fare has joined #lisp
aaaaaa has quit [Ping timeout: 240 seconds]
saganman has joined #lisp
madage has quit [Ping timeout: 240 seconds]
Alfr has joined #lisp
miasuji has quit [Ping timeout: 264 seconds]
<beach>
Good morning everyone!
Alfr_ has quit [Ping timeout: 264 seconds]
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 246 seconds]
skapata has quit [Quit: Leaving]
johnjay has quit [Ping timeout: 260 seconds]
skapata has joined #lisp
miasuji has joined #lisp
akrl has quit [Read error: Connection reset by peer]
akrl has joined #lisp
johnjay has joined #lisp
johnjay has quit [Read error: Connection reset by peer]
pi123 has joined #lisp
pi123 has quit [Ping timeout: 240 seconds]
johnjay has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
Fare has quit [Ping timeout: 264 seconds]
benjamin-l has quit [Ping timeout: 240 seconds]
johnjay has quit [Read error: Connection reset by peer]
pi123 has quit [Read error: Connection reset by peer]
johnjay has joined #lisp
niceplace has quit [Ping timeout: 256 seconds]
drl has quit [Quit: Leaving]
miasuji has quit [Ping timeout: 264 seconds]
niceplace has joined #lisp
johnjay has quit [Ping timeout: 240 seconds]
benjamin-l has quit [Ping timeout: 260 seconds]
torbo has quit [Remote host closed the connection]
benjamin-l has joined #lisp
zacts has joined #lisp
miasuji has joined #lisp
srandon111 has joined #lisp
<srandon111>
hey people, so i am starting with common lisp, do you suggest SBCL ?
<srandon111>
is it the common choice amaong beginners?
<loke[m]>
srandon111: The choice of implementation doesn't really depend on your skill level.
<loke[m]>
Bascially, you have: SBCL - Most common use. It's really high performance, everything is well supported on it and it has great error messages. ABCL - If you need to integrate with the JVM. ECL - If you are looking at integrating with C code, or if you are running on things like embedded platforms.
<zacts>
is clisp still around?
<srandon111>
zacts, clisp? isn't this a channel about clisp ?
<zacts>
no, clisp the MIT gpl lisp implementation
<srandon111>
thanks loke[m] you gave me a great overview about the different implementations, that's really what i needed!
<loke[m]>
zacts: Well, hasn't had a release in 10 years, and most software don't work on it anymore. It's supposedly still being developed but I wouldn't bother until they actually decide to release something.
aartaka has joined #lisp
<srandon111>
loke[m], what's the last release of sbcl instead ?
<zacts>
loke[m]: ok, thanks. the reason I ask is I think it's what that land of lisp book uses.
<loke[m]>
The benefit CLISP had was that it was easy to port to new platforms. However, these days I think ECL fits that role much better.
<zacts>
cool
<loke[m]>
Then of course there is Lispworks and Allegro. But those are commercial products and unless you're a commercial project there isn't much reason to look at them.
kir0ul_ has quit [Ping timeout: 272 seconds]
<no-defun-allowed>
Except for the networking code, you can run all the code in Land of Lisp in any Common Lisp implementation.
<zacts>
ah cool
<loke[m]>
Did I miss anything? There is GCL. That one still exists and gets fixes once in a while. These days the only thing it's used for that I know of is some distributions still build Maxima using it.
amplituhedron has quit [Ping timeout: 240 seconds]
aartaka_d has quit [Ping timeout: 256 seconds]
<zacts>
huh, I wonder if ABCL can interop with other JVM based languages.
<no-defun-allowed>
I am sure someone has ported it already, but a fun extension might be to look up the usocket documentation and have a go at porting the networking code to use usocket. From memory, the CLISP and usocket interfaces are very similar.
<loke[m]>
zacts: Yes, it can. Most JVM languages use some Java-compatible way of exposing API's.
<srandon111>
loke[m], what do you suggest to do network programming on lisp ?
<srandon111>
like crafting packets
<no-defun-allowed>
I'm also sure that interfacing Kotlin and Scala is basically the same as interfacing Java.
<loke[m]>
srandon111: That question is too broad to give a simple answer.
<loke[m]>
*no-defun-allowed*: Yes, definitely.
<loke[m]>
srandon111: SBCL does this very well.
<loke[m]>
But ABCL has a huge benefit if you want to integrate will any of the billions of Java libraries.
<srandon111>
loke[m], i was searching for something similar to python scapy ... beware NOT scrapy, but scapy, which is a packet crafter
<loke[m]>
With SBCL I've had to turn to IOLIB quite a few times. IOLIB is OK, but its requirement on libfixposix is very annoying.
<srandon111>
loke[m], "but good" ahahah explain that
<srandon111>
loke[m], these libraries are not able to send any packets it seems
<loke[m]>
srandon111: Of course not. Sending packets is a different thing. You open a connection and WRITE them. These are different things, and handled by different libraries of course.
<no-defun-allowed>
"packet crafter" suggests that we are trying to fiddle with packets, and not normal network programming which doesn't explicate packets.
<srandon111>
no-defun-allowed, i see but i've seen generally that packet crafters generally also have functions to send/receive packets
<srandon111>
e.g., liike the one loke[m] sent..
<no-defun-allowed>
I hear pcap can send packets now.
<srandon111>
plokami... wow, this is the thing i was searching i think... now i only have to understand how to idgest lisp docs
<srandon111>
thanks loke[m]
<srandon111>
sbcl is only for gnu/linux and macosx right? what is it used on windows?
<srandon111>
just as a curiosity... to understand how much cross platform it is...
ebrasca has quit [Remote host closed the connection]
Necktwi has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
I think SBCL on AArch64/macOS is being worked on.
<loke[m]>
Perhaps the ARM boxes on this table should be red rather than grey for ARM mac?
<loke[m]>
OK, yellow then :-)
<srandon111>
it's a pity it doesn't work on dragonflyBSD PPC64le
<srandon111>
also RISC-V 64 architecture is not supported with DragonFlyBSD, well SBCL does not seem really cross-platform as i thought
<srandon111>
loke[m], do you think they are working on this?
<loke[m]>
srandon111: Well, the platform is very low-level, which is why it can be so efficient.
<no-defun-allowed>
I think you are the only person in #lisp that uses dragonflyBSD on PPC64le.
<srandon111>
no-defun-allowed, wow really? why? what you don't like about dragonflyBSD on PPC64le ?
<srandon111>
loke[m], yes i see..
<loke[m]>
srandon111: I don't think anyone said they don't like it.
<moon-child>
I don't think anyone dislikes that combination specifically; just, both components are somewhat obscure
<srandon111>
loke[m], so why they are not using it ?
<srandon111>
oh okok moon-child
<no-defun-allowed>
Now that you mention it, I don't really like Unix at all, but otherwise I think that most people don't use PowerPC machines, most people don't use BSD, and out of the BSD family, most people don't use dragonflyBSD [citation needed].
<srandon111>
well i thought dragonflyBSD was more popular these days
<loke[m]>
srandon111: I can't speak for others, but for me it's a combination of no access to the hardware, and that my BSD machines run FreeBSD which works fine for my use cases.
<srandon111>
no-defun-allowed, since you don't like UNIX what OS do you like ?
<srandon111>
loke[m], so you are running FreeBSD ?
<loke[m]>
srandon111: On my servers yes.
<srandon111>
loke[m], what about laptops/workstations?
malm has quit [Quit: Bye bye]
<srandon111>
dragonflyBSD ?
<no-defun-allowed>
"An operating system is a collection of things that don't fit inside a language; there shouldn't be one."
<loke[m]>
Various Linuxes. I try to run Qubes OS as much as I can, but I tend to need GPU support which means I'm on Fedora/Arch.
Necktwi has joined #lisp
<srandon111>
no-defun-allowed, sorry what do you mean? i mean if you don't like UNIX what are you using? TempleOS or windows?
<loke[m]>
I agree with *no-defun-allowed*
<loke[m]>
I wish I didn't have to run Linux but here we are.
zcheng3 has quit [Ping timeout: 265 seconds]
<no-defun-allowed>
I use Smalltalk-80 on a Wii.
<srandon111>
loke[m], what's the meaning ? i mean if you run freebsd or MAC you still run some kind of UNIX
<srandon111>
so the options are not many when talking about laptops/workstations..
<no-defun-allowed>
No, I also put up with a Linux machine. Dammit, two of them. And the two Android phones on my desk, which sometimes count and sometimes don't.
<loke[m]>
srandon111: Unix isn't good. It's pretty awful really, but out of the systems one can practically run these days, there isn't anything better.
<srandon111>
loke[m], what makes it awful ?
<beach>
srandon111: There is a book about it: "The Unix haters handbook" I recommend it.
<beach>
srandon111: It was written by very smart and highly knowledgeable people.
zaquest has quit [Quit: Leaving]
<beach>
srandon111: It is available for free as a PDF.
<loke[m]>
I don't fully agree with all of beach's opinions, but I'm mostly aligned, so I would recommend you read his paper on this topic.
<no-defun-allowed>
Ideally, I would have something closer to Genera, then closer to Mezzano or CLOSOS, but (supposing I can accept the slowdown) with some form of network transparency.
<no-defun-allowed>
I have network transparent and replicatable objects of some form in Common Lisp, now I just need CLOSOS.
<beach>
Wow, the pressure...
* beach
is joking.
<srandon111>
loke[m], no-defun-allowed you guys talk bad about UNIX just because I think you didn't have a real UNIX experience, that is DragonFlyBSD on a PPC64le!
<loke[m]>
srandon111: I'll ignore that comment :-)
<no-defun-allowed>
A "real" UNIX would require a teletype and a PDP-11
<beach>
srandon111: We talk bad about Unix because we knew that there were better things before, and we know that we can do much better.
<srandon111>
beach, i see, i will certainly read the paper
<beach>
srandon111: Unfortunately, many generations of software developers have been brainwashed to think that Unix is the best we can do, and the best we ever did.
<srandon111>
beach, well probably becacuse the alternatives suck more
<zacts>
by Unix do you mean primarily the kernel, or the entire system?
<beach>
srandon111: Not so, no.
<loke[m]>
Also, I have worked with different Unix vendors since the mid-90's. And I did spend many years working for Sun Microsystems, and my opinion is that the best C code base I've had the pleasure of working with was Solaris. I do believe I have quite a bit of Unix knowledge.
<no-defun-allowed>
In the introduction to the book I'm writing, I also have a few things to say about the "real" Unix philosophy, and the braindead programs it spawns. We pretend we have smaller and smaller machines, write programs targeting those machines, then simulate having smaller machines, and screw up inter-"machine" communication.
<srandon111>
zacts, well i mean the whole system also the basic utilities and man pages
<srandon111>
beach, well the alternatives for consumer electronics are Windows or MacOS
<srandon111>
beach, so now GNU/Linux seems better
<no-defun-allowed>
Because lots of consumers use dragonflyBSD. Right.
zaquest has joined #lisp
<beach>
zacts: Well, applications compensate for the horrible programming model, but the cost is huge.
zaquest has quit [Remote host closed the connection]
<srandon111>
no-defun-allowed, unluckily not =(
<beach>
srandon111: Sure, if all you look at is what is readily available.
<loke[m]>
Also, mac, windows and linux use pretty much the exact same programming model for the most part. They all have the same memory, the same concept of processes and threads, etc.
<zacts>
how about plan9?
<srandon111>
loke[m], that's why i switched to dragonflyBSD
* no-defun-allowed
will refrain from trying to guess the usage of a hardware Ć operating system combination next time.
<srandon111>
it's somewhat different and the amount of software you can run is astonishing
<loke[m]>
srandon111: ...which also has exactly the same memory model and processes concepts.
<loke[m]>
What most of us consider "better" doesn't actually exist in a user-friendly package at this time.
<beach>
Well put.
<srandon111>
loke[m], well it's somewhat different, i advice you to try it on your laptop for a real experience... install it, it's cool! well i don't know how the experience is on non PPC64le
<srandon111>
loke[m], youo can also install it on some smart phones...
bmansurov has quit [Ping timeout: 240 seconds]
<srandon111>
well after that you cannot make phone calls, but you have a full fledged cli shell that rocks!
<loke[m]>
srandon111: Most of us are experienced enough that a new coat of paint on top of the same old isn't going to excite us very much.
nullheroes has quit [Ping timeout: 256 seconds]
<srandon111>
loke[m],yah i see
<no-defun-allowed>
Damn, even my girlfriend used to maintain a BSD operating system. Kinda rude for me to forget then. Don't tell her that.
<srandon111>
there is also this project "Gentoo/DragonFlyBSD" that was interesting but unluckily does not seem to be ported to PPC64le
<loke[m]>
srandon111: Trust me, I know perfectly well what you're talking about. I was pretty happy to be able to install a proper shell on my Lego Mindstorms hardware so I could ssh into it and actually do stuff with it.
<srandon111>
ahahahah
<srandon111>
loke[m], that's great!
<loke[m]>
I them proceeded to port ECL to it so I could control my Lego stuff from Lisp.
<srandon111>
i used to install gentoo on wii it was cool
<no-defun-allowed>
But given the pains I have with a "fake" Unix, I don't want to know how a "real" one goes.
<srandon111>
no-defun-allowed, let's write a cool OS
<srandon111>
based entirely on LISP ;D
dmiles has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Given that you upcase it, I fear we are not going to work well together.
<loke[m]>
srandon111: But you have to understand that when we talk about a "better" operating system, we look at something way beyond just a new user interface, or getting rid of systemd.
<no-defun-allowed>
And I already said that I think there shouldn't be an operating system.
madage has quit [Remote host closed the connection]
madage has joined #lisp
<zacts>
no-defun-allowed: like, there would be no kernel, or?
<fe[nl]ix>
loke[m]: would it be useful to you if I distributed an SBCL image with libfixposix (an perhaps also openssl) statically compiled ?
<loke[m]>
I'm saying that the whole idea of a "process" is not necessary. It was based on ideas that would not be needed.
<beach>
zacts: Exactly.
<beach>
zacts: Even Multics (that Unix attempted to copy as much as they could) did not have a kernel.
<srandon111>
loke[m], what to usue instead of processes?
<beach>
srandon111: Threads.
<srandon111>
no-defun-allowed, we make it entirely lisp but with the same user experience of drangonflybsd on ppc64le
<srandon111>
beach, and then?
<beach>
I don't understand.
<srandon111>
no-defun-allowed, that would rock the s**t out of all other OSes
<loke[m]>
fe[nl]ix: For me? No. I can personally deal with libfixposix. It's no big deal. I also have no issues with software distribution myself. The one issue with it that people download SBCL, ECL, ABCL, try to quickload a project that depends on IOLIB and it explodes because libfixposix isn't available.
<srandon111>
i mean why people should still use Win/Mac/Lin if they can have a dragonflyBSD experience?
<no-defun-allowed>
srandon111: And nothing of value would be made.
<loke[m]>
fenlix: I think having libfixposix in quicklisp would be a solution. I think it would be possible, with the package including the C source code and it being compile das part of loading the ASDF package.
<srandon111>
no-defun-allowed, what do you mean?
<no-defun-allowed>
It would stink as much as any other Unix system.
bmansurov has joined #lisp
<srandon111>
no-defun-allowed, no no trust me...
<fe[nl]ix>
loke[m]: I doubt that would be possible because the configure script needs to run first, then the library must be installed in a proper location for loading to work
bmansurov is now known as Guest93124
<loke[m]>
srandon111: I think we're all having completely different perspectives. Even if you don't agree with it, could I ask you to watch this video showing what Lisp-based computing is all about. It doesn't mean that we all want exactly this, but it's an illustration of what used to be, and why we're looking at these concepts for inspiration?
nullheroes has joined #lisp
<srandon111>
no-defun-allowed, let's strt it dude... like let's quit our jobs and start this project, we will become rich... i already all the people using our OS in schools and hacking with the DragonFly
<zacts>
wait, loke[m] no-defun-allowed, are you actually working on a lisp based OS?
<beach>
zacts: There are already two of those around: Movitz and Mezzano.
<srandon111>
loke[m], i am not saying i don't agree with you... because my skill level is much lower than yours to have my own robust opinion on this topic, so surely, I will inspect the references you are sending me
<loke[m]>
zacts: Well, I'm not directly working on it. I'm trying to help out as much as I can though.
<beach>
zacts: But I am working on SICL which I hope will be the basis for CLOSOS.
<srandon111>
no-defun-allowed, we just have to think about a name now...
<loke[m]>
srandon111: the video is really showing some of the interesting concepts.
<srandon111>
loke[m], thanks Sir! I appreciate it!
<beach>
zacts: I really need to get SICL into a good-enough state that others can start working.
frost-lab has quit [Quit: Ping timeout (120 seconds)]
hugh_marera has quit [Quit: Ping timeout (120 seconds)]
<srandon111>
no-defun-allowed, what do you say about AstonishingDragonFlyInspiredCoolOS ?
<srandon111>
ADFICOS
<srandon111>
seems cocol
<srandon111>
*cool
<zacts>
oh neat
<srandon111>
zacts, you will be the first user
<srandon111>
we will install it on your microwave, fridge, laptop, router, server, and wife!
<srandon111>
or husband depending on your preferences of cocurse
<srandon111>
ADFICOS is a politically correct OS
Guest93124 has quit [Ping timeout: 240 seconds]
Necktwi has quit [Ping timeout: 246 seconds]
nullheroes has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
srandon111: Stop pinging me.
<srandon111>
no-defun-allowed, sorry Sir i didn't do it on purpose
<srandon111>
ops sorry again
<zacts>
so would the lisp OS require a specific type of CPU?
<no-defun-allowed>
Quite frankly, I don't give a shit - you may get commercial success, but if I do that, I'm sure I've failed in my work.
<srandon111>
zacts, well that's easy... PPC64le of course
g0d_shatter has quit [Remote host closed the connection]
<no-defun-allowed>
And I'm ma[d']am to you.
g0d_shatter has joined #lisp
<srandon111>
ok ma'am
<no-defun-allowed>
Right, thankyou.
<srandon111>
sorry for annoying you with the pings, it wasn't my purpose i was just excited for ADFICOS you know
<zacts>
I'm just having a difficult time wraping my head around not having a kernel+userspace.
<srandon111>
zacts, you must have an open mind, let's start to code it
<zacts>
ugh..
<no-defun-allowed>
I'm not very excited about it - most of my problems with my work are because of serialization (and because people end up using data structures and the serialized representation as the basis for their protocols) and process boundaries.
<srandon111>
how can you not be not excited??????? :( you are emotionless
<srandon111>
zacts, what?
<srandon111>
zacts, create an svn repo
<no-defun-allowed>
Instead of working with objects like normal people, we're writing lenses translating JSON documents and basing more protocols around "the schema" and whatever.
<no-defun-allowed>
srandon111: I have emotions, thankyou. And I have been depressed that wherever I go, there is not much imagination going around.
<loke[m]>
srandon111: I can telly you why I'm less interested. I've been excited about these things many times before, and after a while you get jaded. There really isn't much new here.
<srandon111>
no-defun as you can imagine, i am joking, i didn't mean you have no emotions... i hope you can solve your problem with the lenses anyway!
<srandon111>
loke[m], yeah i see
bmansurov_ has joined #lisp
<no-defun-allowed>
Oh, and I've been depersonalised enough times, thankyou.
<no-defun-allowed>
And I said I didn't want to use lenses, but whatever I say doesn't seem to be sticking.
Necktwi has joined #lisp
<srandon111>
no-defun i am really sorry, i mean it was just a joke to say "you are emotionless" i don't even know you, i mean it was just to joke, really I mean sorry! I really didn't have any reason to say that...
<loke[m]>
srandon111: I really don't want to try to extinguish your excitement. I used to be really excited about some of these things too. I used to be really exited about the prospects of GNOME, for example. How it promised to integrate applications in a really neat way, when it was based on CORBA (remember that one?).
<srandon111>
loke[m], yes i know what you are talking about...
<srandon111>
yes but nowadays gnome really disappoints me
<loke[m]>
In a way, GNOME did manage to fulfil some of its promised, but I see its true potential to be hampered by a lot of legacy.
<srandon111>
i never really use it
<srandon111>
loke[m], gnome is dependant on systemd last time i checked
nullheroes has joined #lisp
hugh_marera has joined #lisp
<srandon111>
i mean from gnome 3
<loke[m]>
So what me, beach, n-d-f and others are talking about here are ideas related to completely getting rid of a lot of this legacy. For example, why do we even have the concept of a "process" with different "address spaces"? Well, the reason is that once upon a time you wrote code in assember or C which translates directly to machine code where the code can access any memory address they want to.
mbomba has joined #lisp
<loke[m]>
The idea of a process serves to abstract this away at the machine lever to make execution safe.
<loke[m]>
Well, what if you abstract things on a higher level? Most software already does this, for example Lisp, Javascript, Java, Python, etc. All of these use some form of "managed runtime". If we all do this already, why are we even restricting ourselves by thinking about resources in terms of processes?
<loke[m]>
srandon111: well, you could. It serves to illustrate that there used to be different (and sometimes, but not always) better solutions to Unix solutions. It reads like grumpy old men complaining abut how Unix ruined their favourite operating systems (Which usually is VMS), which is a style I don't like, because VMS is also not perfect.
<srandon111>
loke[m], ok so basically i can imagine a machine where the OS is an interpreter, let's say for the sake of this example a sort of python interpreter and then basically everything that gets created is a thread
<srandon111>
but what would be the advantage of this ?
<loke[m]>
srandon111: For that, I suggest you read beach's paper. It really explains exactly that.
<srandon111>
i mean we still should have vulnerabilities right ? threads can share resources
<srandon111>
ok loke[m] sos i will first read beach's paper
<beach>
srandon111: Today, when you need to communicate between processes, you need to convert everything to a stream of bytes. That is not only silly and costly, you also lose identity.
<beach>
zacts: As loke[m] says, the idea of a process is to emulate a bare machine so that we can program the same way that we did some 70 years ago, but there is no profound reason why we would want that. So if you don't allow application code direct access to its entire address space, there is no need for a kernel.
<srandon111>
beach, what do you mean by identity ? ok sorry probably i will find that out in the paper
<moon-child>
beach: shared memory is a thing
<beach>
srandon111: You can't send a pointer to an object from one process to another, and have that other process update it.
<moon-child>
on unix
<loke[m]>
srandon111: Yes, vulnerabilities doesn't magically go away. However, process boundaries also doesn't magically _solve_ those problems.
<loke[m]>
Process boundaries are a terrible crude way job isolation.
<beach>
moon-child: Yes, there are kludges to get around it, but you can do that only if both processes agree on the addresses and such.
<srandon111>
ok loke[m] i see
<srandon111>
beach, i understand
<srandon111>
it's crazy how the common OS are behind the state of the art o the research like decades
<srandon111>
i mean after hearing your point
gioyik_ has joined #lisp
<moon-child>
srandon111: another fun thread to pull on is keykos
<srandon111>
moon-child, never heard about it
<loke[m]>
srandon111: It's not crazy at all. These systems became popular for the exact reason that they are old. It's stable platform on which people can develop solutions for decades without worrying about things changing underneath them.
<beach>
srandon111: Not quite. The technology existed 50 years ago. It is just that Unix became very popular and squashed what we had.
<srandon111>
moon-child, what about TempleOS, was it implementing state of the art stuff ?
<loke[m]>
srandon111: In a way, yes. A lot of ideas in temple is embodying the same concepts as Lisp machines.
<srandon111>
loke[m], i didn't know
<loke[m]>
If you look a people talking about temple they are impressed by how objects are preserving identity across the system. Exactly what Beach is talking about.
<loke[m]>
However, it's of course hampered by all the crazy stuff. But there are neat ideas there.
gioyik has quit [Ping timeout: 256 seconds]
Oladon has quit [Quit: Leaving.]
treflip has joined #lisp
<srandon111>
loke[m], that's crazy
<zacts>
beach: that's a cool paper
<beach>
Thanks.
davisr has quit [Remote host closed the connection]
davisr has joined #lisp
<zacts>
so could a user extend the system kind of like on the hurd? a user could implement their own filesystem or device driver to use?
<beach>
Sure, with the proper permissions.
<beach>
But not at all like the Hurd.
<beach>
The Hurd is kind of byte-copying in the extreme.
<no-defun-allowed>
Outside of technical issues like the isolation model, I dislike Unix because a. how you expect to use it doesn't correspond to how you should use Lisp - I read tutorials where the author wrote "Oh, SLIME and Emacs and all that shit? Don't need it. Just use vi to write the file, and then run 'sbcl --script file.lisp'", and I know that they have screwed over their readers; and b. it's presented as an improvement over
<no-defun-allowed>
Windows or macOS, and then you need a kick in the stomach to consider that you might want to improve on that, too.
miasuji has quit [Quit: Leaving]
andreyorst` has joined #lisp
<no-defun-allowed>
The former is often blamed on Lisp ("guis this is why Lisp isn't popular, we just need to take away the part that makes people want to use it"), but I choose to blame it on Unix.
<zacts>
hum... the fs mentioned in the paper sounds interesting too.
<beach>
There is no file system because there are no files. But one could be written of course.
<no-defun-allowed>
The "converse" of that would be why I wouldn't write a Unix clone in Lisp; you lose the dynamics and the abstraction that Lisp facilitates with a kernel-userland split and processes, respectively.
<zacts>
beach: no files? so just data structures?
<moon-child>
(It's probably worth noting that lisp vs unix is a flamewar that goes back decades, and that if I defend unix I'm mostly playing devil's advocate)
<beach>
zacts: Yes. But some of those can be vectors of bytes, of course.
<moon-child>
zacts: I mean, a tree is a data structure
<moon-child>
zacts: so, not 'just' data structure; *more* data structure, a superset of those exposed by hierarchical FS
<moon-child>
*structures
<no-defun-allowed>
Data isn't real, but objects are. For the purpose of avoiding another flamewar, that is a joke, but I'm otherwise dead serious with that statement.
<zacts>
moon-child: I'm not trying to argue lisp vs unix, but I'm just trying to understand this.
<zacts>
moon-child: re: *more* data structure, that sounds cool
<moon-child>
no-defun-allowed: data is not well-defined in a vacuum, but can be real under some interpretation. (I guess maybe that's what you mean by object?)
<beach>
Yes, an object is defined by the operations you can apply to it.
<zacts>
gosh, I've got to learn lisp.
<zacts>
this all sounds pretty neat
<no-defun-allowed>
Yes, I mean exactly that. If you know how to interpret it, then you've cut down on the difficulty of {backwards, forwards, cross} -compatibility quite a bit. And I wish some of the people who write up articles translating bare data structures would find that out; but they probably wouldn't have much of a business if they did.
<moon-child>
zacts: this is cs / math; not lisp-specific
<no-defun-allowed>
The problem is then interpreting how those operations correspond to each other, which is also hard, but in my opinion more manageable.
skapata has quit [Quit: Leaving]
<zacts>
moon-child: lisp sounds like a more natural medium for learning some of these concepts than C I'm guessing? but good to know.
malm has joined #lisp
<moon-child>
yes
dreamcompiler has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
Oh, also b. makes for very stupid "experts" sometimes. Like an article I read where the author thought that Unix was the first operating system written in a high level language, and that Java is the only language where objects aren't represented as hash tables. But I don't think I can really pin that on Unix.
<moon-child>
zacts: good read is _Gƶdel, Escher, Bach_
<zacts>
moon-child: I've heard of that book before
yonkunas has quit [Quit: Connection closed for inactivity]
bitmapper has quit [Quit: Connection closed for inactivity]
<beach>
no-defun-allowed: Yes, the book by Tanenbaum and Bos mentions that, and also that they consider it impossible to use a language with automatic memory management to write an OS.
mgxm has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
beach: Oh dear. I was referring to <https://matklad.github.io/2020/09/13/your-language-sucks.html>, which if I may paraphrase the title, "sucks and doesn't matter". But they probably fall for the same stuff at the end of the day.
<zacts>
beach: could sicl or closos make use of something like the netbsd rump anykernel to run on existing hw?
<no-defun-allowed>
(For reference for the comment on Java, the paper introducing "maps" in a Self implementation by Ungar, Chambers and Lee was published in 1991, as well as The Art of the Metaobject Protocol, which of course has storage vectors.)
<beach>
zacts: I don't see any reason for that. The "bare metal" aspect is fairly simple to realize, and not terribly interesting. The interesting part is the interface between an application and the system, and between applications.
<zacts>
I see
<beach>
zacts: And SICL bootstrapping is just going to generate an executable, for Linux for now, since that's all we have.
andreyorst` has quit [Quit: andreyorst`]
andreyorst` has joined #lisp
<zacts>
so the "bare metal" aspect would be similar to how adding a new architecture to llvm is just an implementation detail, and it's not the overall system.
<zacts>
my point being, that porting sicl to a particular platform or whatever, would just be a particular implementation detail. it's not what makes the system interesting in itself.
podge has joined #lisp
<zacts>
like it's difficult for me to get out of the kernel mindset I think.
<zacts>
anyway, lots to learn. I'm going to pick up this practical common lisp text for now I think.
podge has quit [Client Quit]
orivej has joined #lisp
luckless has joined #lisp
<beach>
zacts: Good luck. We hang out in #sicl if you have more detailed questions later.
<phoe>
good morning
<beach>
Hello phoe.
<phoe>
hey hi
<no-defun-allowed>
Hello phoe.
<treflip>
good morning phoe
<phoe>
zacts: you have seen mezzano, right?
tessier has quit [Ping timeout: 240 seconds]
zaquest has joined #lisp
zaquest has quit [Read error: Connection reset by peer]
random-nick has joined #lisp
<zacts>
thanks
<zacts>
phoe: not yet
<adlai>
srandon111: loke[m] forgot Clozure CL, an implementation that is quite portable, and has a compiler that runs quickly and produces reasonably fast code
<phoe>
zacts: you should
<phoe>
it's a Common Lisp OS that runs on bare metal
* adlai
usually recommends CCL for beginners because the compiler is fast enough that, for interactive programming at the repl, there is pretty much no noticeable compilation delay
<phoe>
it has enough sophistication to run IRC, Quake, and Doom
mgxm has joined #lisp
<adlai>
I thought running IRC betrayed a lack of sophistication? :P
<phoe>
it betrays the fact that it has a working network stack
<phoe>
which is already non-trivial
<zacts>
I'll check it out thanks
shifty has quit [Ping timeout: 256 seconds]
<srandon111>
adlai, thanks Sir/Ma'am
Cymew has joined #lisp
pankajsg has joined #lisp
Lycurgus has joined #lisp
<adlai>
it is amazing how an unexpected escalation of formality can be a wet blanket to one's hubris, although that is off-topic.
wxie has joined #lisp
<adlai>
zacts: allow me to add an anti-recommedation for Godel, Escher, Bach, unless you are also a fan of classical music, douglas hofstatder, or even both
* adlai
is a fan of Hafstadter's works -- that is how he first read about lisp! -- although there are excerpts from the book that give you an idea of the whole thing while leaving you precious hours free for, I dunno, reading CLHS?
<moon-child>
adlai: hubris can always a problem. That doesn't devalue formalism
<Lycurgus>
dumbass video games: lack of sophistication, human conversational agent, the opposite of that
<Lycurgus>
*human-interfacing
<adlai>
apparently that book is considered a "cult book", similar to cult movies, where people tap out early if they are not hooked; which is a shame, since it is written as a book that expects the reader to read the entire thing, as opposed to e.g. a standards document.
benjamin-l has quit [Ping timeout: 246 seconds]
<Lycurgus>
the stuff with analogies (hofstadter) is more amenable to practical lisp usage
<ck_>
his book of essays (Metamagical Themas) is more suited if you don't want a cover-to-cover experience. There's also more usage of lisp in it.
* adlai
had just taken an entire semester of java, before reading Metamagical Themas over the summer and encountering lisp. life could have taken a severely different turn!
<flip214>
I quite liked GEB... it's on my technical top-10 list, along with "Visual Display of Quantitative Information"
<ck_>
adlai: :)
pankajsg has quit [Ping timeout: 256 seconds]
<no-defun-allowed>
adlai: In my experience, the reverse is more painful.
<flip214>
ck_: " The item is not available due to issues with the item's content. " when trying to download an ebook?
<adlai>
no-defun-allowed: that's understandable; one of the few long conversations I had irl about cl ended with the other person (also a programmer) concluding that learning such a powerful language is a bad life decision, because then most other encounters with human technology will consist of disappointment
<ck_>
flip214: ok?
<no-defun-allowed>
Well, sure, that describes it. And that you also may have standards for the presentation of the course that also are not met.
<adlai>
although, he seemed to be at the end of his active programming career, and thus able to make such a statement.
<beach>
adlai: Wow, that's a very strange (to me) attitude. But I guess it is common.
<flip214>
but thanks for the tip
cl-arthur has quit [Ping timeout: 260 seconds]
saganman has quit [Ping timeout: 256 seconds]
<flip214>
beach: the attitude is strange - but the content is (sadly) correct
<flip214>
OTOH, especially in IT there's _so_much_ disappointment when dealing with other people's stuff... my own stuff I expect to break (or at least can guess when), but commercial software should behave better
<ck_>
I've watched a few older talks this year, one Keynote by Guy Steele (From 2013 I believe?) where he implores "can we please get tail calls in JDK 9?"
<ck_>
I guess it gets better only very slowly in general
<moon-child>
ck_: I have found it an endless source of hilarity that guy sat on the design comittees for common lisp, scheme, java, and c
<Lycurgus>
the reason people burn out and have negative attitudes about software development (in comparison with other professionals fields)
<Lycurgus>
is the capitalism
<adlai>
beach: I think it is a common attitude among those who are seeking careers working as fungible programmers in a variety of enterprises, as opposed to those for whom 'career as programmer' could plausibly include a decade working alone, another decade doing academic research, etc
<no-defun-allowed>
adlai: Then make them not disappointing. How to do that is up to you, but you are likely as capable as as your colleagues to make the field better, and you may have a better idea of what would be better.
<Lycurgus>
which mode of society/production, determines the greater and lesser snake pits of industry/academe
<no-defun-allowed>
adlai: Be practical, do the impossible!
<Lycurgus>
under the capitalism pretty much everything is impossible
<Lycurgus>
compared to what could be done
<Lycurgus>
from first principles
shka_ has quit [Remote host closed the connection]
<adlai>
no-defun-allowed: here's one impossible... I wish all the hi-tech managers got together and decided on programming practices that kept their employees as fungible cogs, without limiting the choice of programming language
<no-defun-allowed>
I won't say what exactly, but "just" invalidate the assumptions that your statement has.
<Lycurgus>
there's no money for/in it closes stuff off effectively
srandon111 has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
.-.
treflip has quit [Ping timeout: 256 seconds]
<beach>
adlai: Makes sense.
treflip has joined #lisp
<adlai>
in Earth, we've had a century of capitalism, communism, and hegelism, and it has given us Common Lisp, Racket, and most importantly, Stalin; whereas in the other planets, they've had five billion years of peace love and no complaints, and what do they have to show for themselves? not even a cuckoo clock, just a bunch of epicycles.
<loke[m]>
adlai: Can't argue with logic.
frodef has joined #lisp
<Lycurgus>
oh right, Guy Stalin, he invented common lisp didn e?
<zacts>
stalin is also a scheme interpreter
<phoe>
"in Earth, we've had a century of capitalism, communism, and hegelism, and it has given us Common Lisp, Racket, and most importantly, Stalin"
<adlai>
'stalin' is a scheme ~compiler~, not interpreter, supposedly one that reached new heights of whole-program optimization.
shka_ has joined #lisp
<no-defun-allowed>
damn I guess I have to use Racket now
<zacts>
s/interpreter/compiler/
<Lycurgus>
the cl implementation of copycat does appear to be complete and reasonably current
<adlai>
is there a (require 'cl) for Racket, similar to what emacs has?
<moon-child>
no-defun-allowed: eh, don't make a racket about it
<no-defun-allowed>
moon-child: Good point.
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
cl-arthur has joined #lisp
Aurora_v_kosmose has joined #lisp
<adlai>
back to more productive topics, what is the best overview of the new package naming conventions?
* adlai
keeps seeing references to [a] package-local nickname library[ies], and never bothered studying this
<no-defun-allowed>
Package local nicknames are probably better implemented and more used.
mbomba has quit [Quit: WeeChat 3.0]
ljavorsk has joined #lisp
* adlai
repeats that the underlying emphasis should be on the naming convention for the long verbose detailed unambiguous name, and wonders whether there are alternatives to pretending that the domain-name system is sane
<adlai>
off the top of my head, the packages all use either reversed domain names (e.g. com.symbolics.information.much.too ), or a long library name as prefix and hope the name is uncommon enough to avoid collision.
<phoe>
and these are correctable using package local nicknames
<phoe>
because you can use a:alist-plist instead of net.common-lisp.alexandrias.completely.imaginary.package.name:alist-plist
<adlai>
phoe: your gist is short, lemme finish reading it please :)
<phoe>
OK
<phoe>
(I need to make a second version of it that it less of a rant and more of a useful article)
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
scymtym_ has quit [Remote host closed the connection]
aaaaaa has joined #lisp
<adlai>
easy, just delete everything except for footnote four.
scymtym has joined #lisp
ldbeth has joined #lisp
<adlai>
... wonderful, I learn now that ultralisp includes scalpl, just after its removal from quicklisp
bjorkintosh has quit [Ping timeout: 256 seconds]
* adlai
does not mind people acting as travis-ci backups; it is almost a compliment, although... not necessarily a good idea.
bjorkintosh has joined #lisp
<flip214>
phoe: package-local nicknames mean that using INTERN at runtime (even indirectly, eg. when parsing JSON, YAML, etc.!) needs to take *PACKAGE* into account, right?
<flip214>
Well, as long as these intern keys just into KEYWORD, it might not matter that much
<flip214>
ah, but messagepack has a symbol encoding, IIRC
<phoe>
flip214: yes
<phoe>
all code that depends on the runtime value of *PACKAGE* is affected by PLNs
iskander- has quit [Read error: Connection reset by peer]
iskander has joined #lisp
zge has left #lisp [#lisp]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
aartaka has quit [Ping timeout: 240 seconds]
galex-713 has joined #lisp
* adlai
is amazed that phoe has the patience to answer so many of the reddit comments on the article!
DGASAU` has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
DGASAU has joined #lisp
pankajsg has joined #lisp
zaquest has joined #lisp
zaquest has quit [Remote host closed the connection]
<adlai>
some of the behavior standardized as undefined in clhs 2.3.5 could be useful for concisely naming common mathematical objects according to small integers
* adlai
even at one point had a teacher who used that notation for fractions; in this case, the mathematical objects are, e.g., roots of unity as equivalence classes, rather than members of the field of complex numbers
dmiles has joined #lisp
jonatack has quit [Ping timeout: 256 seconds]
jonatack has joined #lisp
wxie has quit [Ping timeout: 265 seconds]
igemnace has quit [Ping timeout: 260 seconds]
frost-lab has joined #lisp
aaaaaa has quit [Ping timeout: 256 seconds]
McParen has joined #lisp
imode has quit [Ping timeout: 246 seconds]
treflip has quit [Ping timeout: 260 seconds]
treflip has joined #lisp
g0d_shatter has quit [Ping timeout: 256 seconds]
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
jeosol has quit [Remote host closed the connection]
X-Scale has quit [Ping timeout: 246 seconds]
treflip has quit [Quit: WeeChat 2.6]
X-Scale has joined #lisp
ldbeth has quit [Quit: ERC (IRC client for Emacs 27.1)]
<jmercouris>
I feel like he is, I just can't remember his username
<jackdaniel>
he doesn't seem to be online right now, but indeed he joins irc often
frgo_ has joined #lisp
<jackdaniel>
I don't remember exact nick, but it is derived from his name (available on the github page)
kir0ul_ has joined #lisp
frgo has quit [Ping timeout: 260 seconds]
<phoe>
MichaelRaskin
<phoe>
he tends to be online, yes; you could leave him a memo
galex-713 has quit [Ping timeout: 246 seconds]
cosimone has quit [Quit: cosimone]
zaquest has joined #lisp
rgherdt has joined #lisp
zaquest has quit [Remote host closed the connection]
yaji has quit [Remote host closed the connection]
yaji has joined #lisp
<jmercouris>
OK, thanks, I will leave a memo with minion
<jmercouris>
minion: memo for MichaelRaskin can you package Calispel for NixOS?
<minion>
NixOS: watch out, you'll make krystof angry
<jmercouris>
???
<jmercouris>
is that not the right syntax?
gxt has quit [Quit: WeeChat 2.9]
<jmercouris>
minion: memo for MichaelRaskin: can you package Calispel for NixOS?
<minion>
Remembered. I'll tell MichaelRaskin when he/she/it next speaks.
<jackdaniel>
minion: say "perhaps"
<minion>
say "perhaps": An error was encountered in lookup: Parse error:URI "https://www.cliki.net/say%20\"perhaps\"?source" contains illegal character #\" at position 28..
<jmercouris>
we need to add a 'faith' command like the emacs bot
yaji has quit [Ping timeout: 260 seconds]
<jmercouris>
for when we despair
gxt has joined #lisp
lucasb has joined #lisp
<adlai>
why would anyone get angry at Nix? it is a strict improvement over the predecessor posix distros...
frost-lab has quit [Ping timeout: 265 seconds]
<lucasb>
Hello. I think something messed the layout of planet.lisp.org, everything is in italics, inside <i></i> tags, after the middle of first post.
<adlai>
jmercouris: there's a joke here somewhere, about how only Japanese Lisp programmers have faith
<jmercouris>
I'm not sure I get the joke
iskander has quit [Ping timeout: 246 seconds]
* adlai
is not sufficiently versed in Japanese culture to describe the concept precisely, but essentially, the word "face" has a meaning there, beyond the literal one.
iskander has joined #lisp
<jmercouris>
hai
<adlai>
it is probably closer to the idiomatic usage of 'spine', in English, than to nebulous concepts such as prestige and reputation.
<jmercouris>
hai, hai
Bike has joined #lisp
cosimone has joined #lisp
Fare has joined #lisp
jason_m has quit [Read error: Connection reset by peer]
notzmv has quit [Ping timeout: 265 seconds]
cosimone has quit [Remote host closed the connection]
leo_song has quit [Ping timeout: 246 seconds]
cosimone has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
shifty has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
ecm has joined #lisp
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
lotuseater has quit [Ping timeout: 240 seconds]
aartaka has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
iskander has quit [Ping timeout: 256 seconds]
pankajsg has quit [Read error: Connection reset by peer]
iskander has joined #lisp
liberliver has quit [Remote host closed the connection]
liberliver has joined #lisp
enrio has joined #lisp
shoshin has quit [Ping timeout: 256 seconds]
save-lisp-or-die has quit [Ping timeout: 265 seconds]
shifty has quit [Ping timeout: 256 seconds]
shifty has joined #lisp
wsinatra has joined #lisp
wsinatra has quit [Ping timeout: 240 seconds]
ibinderwolf has quit [Remote host closed the connection]
wsinatra has joined #lisp
ibinderwolf has joined #lisp
waleee-cl has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
ljavorsk has quit [Ping timeout: 240 seconds]
rogersm has joined #lisp
notzmv has joined #lisp
mrchampion has quit [Ping timeout: 260 seconds]
hendursaga has quit [Ping timeout: 240 seconds]
scymtym has quit [Remote host closed the connection]
save-lisp-or-die has joined #lisp
shoshin has joined #lisp
hendursaga has joined #lisp
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
sjl has joined #lisp
mrchampion has joined #lisp
jxy has quit [Quit: leaving]
jxy has joined #lisp
scymtym has joined #lisp
toorevitimirp has quit [Ping timeout: 260 seconds]
iskander- has joined #lisp
iskander has quit [Ping timeout: 246 seconds]
lucasb has quit [Quit: Connection closed for inactivity]
lotuseater has quit [Remote host closed the connection]
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
rumbler3_ has joined #lisp
rumbler3_ has quit [Read error: Connection reset by peer]
rumbler3_ has joined #lisp
EvW has joined #lisp
akoana has joined #lisp
rogersm has joined #lisp
zacts has joined #lisp
bilegeek has joined #lisp
rumbler3_ has quit [Remote host closed the connection]
benjamin-l has joined #lisp
wsinatra has quit [Ping timeout: 256 seconds]
wsinatra has joined #lisp
enrioog has quit [Ping timeout: 240 seconds]
aaaaaa has joined #lisp
wsinatra has quit [Ping timeout: 240 seconds]
rogersm has quit [Quit: Leaving...]
matryoshka has quit [Read error: Connection reset by peer]
matryoshka` has joined #lisp
frodef has quit [Ping timeout: 256 seconds]
gxt has quit [Remote host closed the connection]
gxt has joined #lisp
wsinatra has joined #lisp
wsinatra has quit [Client Quit]
wsinatra has joined #lisp
wsinatra has quit [Client Quit]
wsinatra has joined #lisp
vaporatorius has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius__ has quit [Ping timeout: 256 seconds]
Lord_of_Life has joined #lisp
Lord_of_Life has joined #lisp
Lord_of_Life has quit [Changing host]
rumbler3_ has joined #lisp
nkatte has joined #lisp
nkatte has quit [Read error: Connection reset by peer]
nkatte has joined #lisp
shifty has joined #lisp
rumbler3_ has quit [Ping timeout: 240 seconds]
frodef has joined #lisp
aeth_ has joined #lisp
nkatte has quit [Quit: nkatte]
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
nkatte has joined #lisp
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
dim has quit [Ping timeout: 240 seconds]
frodef has quit [Ping timeout: 260 seconds]
dim has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
nkatte has quit [Quit: nkatte]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
cosimone has quit [Quit: cosimone]
oni-on-ion has quit [Read error: Connection reset by peer]
davisr_ has joined #lisp
davisr has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
diamondbond has quit [Ping timeout: 246 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
enrioog has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
liberliver has quit [Remote host closed the connection]
liberliver has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
oni-on-ion has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
andreyorst has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
wsinatra has quit [Ping timeout: 256 seconds]
wsinatra has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
liberliver has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
cosimone has joined #lisp
zacts has quit [Ping timeout: 246 seconds]
zacts has joined #lisp
zacts has quit [Client Quit]
zacts has joined #lisp
narimiran has quit [Ping timeout: 256 seconds]
enrioog has quit [Ping timeout: 240 seconds]
diamondbond has joined #lisp
shka_ has quit [Ping timeout: 264 seconds]
wsinatra has quit [Ping timeout: 256 seconds]
wsinatra has joined #lisp
hal99999 has quit [Ping timeout: 272 seconds]
<Krystof>
receiving notifications from minion since... what, 2002?
<jackdaniel>
minion: tell something
<minion>
does torturing a poor bot with things beyond its comprehension please you?
EvW has quit [Ping timeout: 272 seconds]
Jesin has quit [Quit: Leaving]
drot has quit [Read error: Connection reset by peer]
lotuseater has joined #lisp
<lotuseater>
What do you do if someone asks you what you can use Lisp for in everyday life?
JohnnyL has joined #lisp
<no-defun-allowed>
Probably pretend I didn't hear the question. Or say, "most things you would do in everyday life, and then some more".
<lotuseater>
Yes it is very exhausting to have to justify yourself.
<lotuseater>
I told him beside other stuff CL is more general purpose as C/C++ and not just domain specific like those :D
aartaka has quit [Ping timeout: 256 seconds]
Jesin has joined #lisp
EvW has joined #lisp
PuercoPop has joined #lisp
PuercoPop has quit [Client Quit]
<Xach>
darn it
<lotuseater>
Xach: what's wrong?
<lotuseater>
no-defun-allowed: now he said "I have also done code generation in other languages. I don't really see why it is necessary to use a self-modifying language." *sigh*
<lotuseater>
<Xach>
lotuseater: planet lisp html foulup
<Xach>
it generally hasn't fouled up too bad in the past, and it's a 20-year-old python program doing the HTML bit.
<lotuseater>
oh
aeth has quit [Ping timeout: 246 seconds]
wsinatra has quit [Ping timeout: 256 seconds]
aeth has joined #lisp
<lotuseater>
haven't been on this site so much yet, but seems to contain a big bunch of infos
<Xach>
it had more infos in 2002 when it started, but it still has some infos in 2020
<mfiano>
Xach: looks like the timestamp is way off
<mfiano>
or rather than "x hours ago"
<lotuseater>
hm okay I wish I would have none lisp in 2002 :)
<mfiano>
s/than/the/
Blkt has quit [Ping timeout: 272 seconds]
fe[nl]ix has quit [Ping timeout: 272 seconds]
urek has quit [Ping timeout: 246 seconds]
Blkt has joined #lisp
fe[nl]ix has joined #lisp
catchme has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
<lotuseater>
s/none/known o_O
<Xach>
I should just take that out.
KREYREEN has quit [Ping timeout: 240 seconds]
<mfiano>
"days ago" seems correct anyway. Somehow it is adding a day to hour calculation or something
KREYREEN has joined #lisp
<mfiano>
Actually 16 hours. Odd
dim has quit [Ping timeout: 265 seconds]
akoana has left #lisp ["Leaving"]
dim has joined #lisp
shifty has joined #lisp
scymtym has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
dbotton has joined #lisp
frodef has joined #lisp
u0_a128 has joined #lisp
dbotton has quit [Quit: Leaving]
aartaka has joined #lisp
amplituhedron has joined #lisp
zacts has quit [Quit: leaving]
urek has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
aartaka has joined #lisp
luckless_ has joined #lisp
luckless has quit [Ping timeout: 240 seconds]
sjl has quit [Ping timeout: 272 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
u0_a128 has quit [Ping timeout: 272 seconds]
mbomba has joined #lisp
imode has joined #lisp
leo_song has joined #lisp
<lotuseater>
Are you aware of newer resources on how to do "real" AI stuff with CL?
kaftejiman has joined #lisp
cosimone has quit [Quit: cosimone]
random-nick has quit [Ping timeout: 264 seconds]
rumbler31 has joined #lisp
madage has quit [Ping timeout: 240 seconds]
igemnace has joined #lisp
jurov_ has quit [Remote host closed the connection]
madage has joined #lisp
jurov has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
JohnnyL has quit [Ping timeout: 240 seconds]
rgherdt has quit [Ping timeout: 246 seconds]
xrash has joined #lisp
pve has quit [Quit: leaving]
rumbler31 has joined #lisp
urek__ has joined #lisp
froggey has quit [Ping timeout: 256 seconds]
urek has quit [Ping timeout: 272 seconds]
yonkunas has joined #lisp
ebrasca has joined #lisp
JohnnyL has joined #lisp
dhil has quit [Ping timeout: 272 seconds]
vydd has joined #lisp
Oladon has joined #lisp
<White_Flame>
lotuseater: define "real"
<no-defun-allowed>
It's AI until it begins to work.