_ark_ has quit [Remote host closed the connection]
lnostdal has quit [Read error: Connection reset by peer]
lnostdal has joined #lisp
notzmv has joined #lisp
_whitelogger has joined #lisp
_whitelogger has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
smokeink has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
jb__ has joined #lisp
Essadon has quit [Quit: Qutting]
orivej has quit [Ping timeout: 240 seconds]
lnostdal has quit [Read error: Connection reset by peer]
markoong has quit [Ping timeout: 272 seconds]
lnostdal has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
dale has quit [Quit: dale]
lnostdal has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
X-Scale has quit [Ping timeout: 240 seconds]
lnostdal has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
lnostdal has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 268 seconds]
JetJej has quit [Quit: [Quit]]
lnostdal has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
lnostdal has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Ping timeout: 246 seconds]
lnostdal has joined #lisp
shifty has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
auxruul has joined #lisp
lnostdal has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
lnostdal has joined #lisp
Kundry_Wag has joined #lisp
lnostdal has quit [Read error: Connection reset by peer]
amerlyq has quit [Quit: amerlyq]
Kundry_Wag has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
Kundry_Wag has joined #lisp
travv0 has quit []
travv0 has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
space_otter has joined #lisp
lnostdal has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
jbayardo has quit [Quit: Bye!]
FreeBirdLjj has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
FreeBirdLjj has quit [Ping timeout: 245 seconds]
X-Scale has joined #lisp
dale has joined #lisp
Kundry_Wag has joined #lisp
vtomole has quit [Ping timeout: 256 seconds]
<beach>
Good morning everyone!
<Josh_2>
Mornin'
Kundry_Wag has quit [Ping timeout: 244 seconds]
<beach>
Writing a Common Lisp system in assembler? It would have been funny if it were a joke, but I fear it wasn't.
<no-defun-allowed>
I don't think it was, unfortunately.
<beach>
Yeah.
noobineer has joined #lisp
<no-defun-allowed>
It did come up from a strange problem I've heard before, though.
<beach>
What's that?
<no-defun-allowed>
Some people wonder why there are no (large) Common Lisp systems written in C, or if they are educated enough, why ECL is the only Common Lisp in C.
<beach>
And?
<beach>
Well, there is CLISP as well, I guess.
<no-defun-allowed>
I think people expect other languages to be bootstrappable from a C compiler, but most languages are implemented in themselves once they're developed enough.
<beach>
I think that's a very silly expectation.
<no-defun-allowed>
Yes, it is.
dddddd has quit [Remote host closed the connection]
<beach>
I have yet to investigate why people expect that.
<beach>
I think there are two separate reasons (with different people).
marvin2 has quit [Ping timeout: 250 seconds]
<beach>
One is that they think C is always available, so everything should build with C.
<diip>
I am quite the opposite, I wonder why most CL implementations must have C in them and don't seem to be able to interact with the hardware directly, I know of clozure and SBCL, but even clozure has some C in it.
<beach>
The other is a conviction that higher level languages must somehow be written in lower-level languages.
<no-defun-allowed>
So, I suppose I will tell them to compile ECL or CLISP and use that to bootstrap SBCL.
<beach>
Yes, that is one way.
<rme>
On Unix, C is the interface to the operating system. You can't really escape it.
<beach>
diip: How are the two related? The C and the interaction with hardware, I mean?
<no-defun-allowed>
I imagine in some places of SBCL and other implementations, it would be terrible for the programmer to accidentally cons or do any mutations to the Lisp image's state for some reason.
<diip>
CFFI
<beach>
rme: Hey, long time no see.
<beach>
rme: Hey, long time no C. :)
<rme>
heh
<beach>
rme: What's up with you?
<no-defun-allowed>
I could also imagine an internal special form or declaration that refuses to compile any consing code. It'd be like assembler with nested parens.
Kundry_Wag has joined #lisp
<rme>
been hacking CL for RavenPack since july and working on Opusmodus and CCL in my copious spare time
<beach>
I see.
<diip>
beach: I meant to do anything hardware related, you seem to have to go through the CFFI and generally end up using C rather than straight to the hardware itself (or assembly)
<no-defun-allowed>
Wooow, those are some big products, rme.
<rme>
someone has to do it
<beach>
rme: Are the plans to move definitely off?
<djeis[m]>
I mean, strictly speaking the CFFI is no more CL than the hardware access something like Genera or Mezzano provides.
<no-defun-allowed>
I'm not complaining, though, that's quite impressive.
<beach>
"definitively" I guess.
<rme>
Unfortunately, a move to France looks like it's not going to happen.
<beach>
:(
<no-defun-allowed>
):
Kundry_Wag has quit [Ping timeout: 250 seconds]
<diip>
I am still very much learning though but there is little to no documentation on hardware interaction with CL, it seems implementation specific and generally not advertised by the implementations themselves
<rme>
yeah, it's too bad.
<beach>
diip: It not only SEEMS implementation specific. It IS, because there is nothing like that defined in the standard, just like with most other languages.
<djeis[m]>
diip: It is entirely implementation specific, CFFI just abstracts over the differences in many implementations API's for C.
<djeis[m]>
*implementation's APIs
<no-defun-allowed>
When it's provided, I think it'd be hidden quite well or regulated so the Lisp image doesn't destroy itself.
<no-defun-allowed>
Or, it's managed carefully like CFFI.
<diip>
beach: nothing like "hardware interaction" defined in other languages. some languages (C inline ) do
<rme>
RavenPack would like it if I moved to Spain, but I don't know Spanish and the kids are too old now to just go to Spanish public schools and pick up the language by immersion.
<diip>
no-defun-allowed: I think this image part is where I get lost, how would using assembly affect the lisp image?
<beach>
rme: That's too bad. Spain is nice as well.
<rme>
I felt more at ease in France, but I'm sure that's mostly because I know the language.
<beach>
Yes, I see.
<djeis[m]>
It's more that direct hardware access gives you the tools to royally shoot yourself in the foot.
<beach>
I could live in Spain.
<no-defun-allowed>
Assembly has very little protection, and can be used to harm a Lisp system.
<djeis[m]>
But I don't think that's why the APIs are hard to find.
<no-defun-allowed>
diip: One simple experiment is to write a function with (declaim (optimize (speed 3) (safety 0))) and some type declarations, and then funcall it with different types.
<djeis[m]>
I think it's just that there aren't a lot of people that want to do that sort of thing, so the interface isn't well documented for the vast majority of implementations.
<no-defun-allowed>
You will quickly encounter strange values, and objects which the Lisp system doesn't understand. Often, the garbage objects will cause the garbage collector and printer to error.
<djeis[m]>
Telling SBCL to generate arbitrary ASM is actually relatively (relatively) straightforward when you've done it a couple times.
Kundry_Wag has joined #lisp
<djeis[m]>
It not something you can just do inline tho.
jkordani has quit [Read error: Connection reset by peer]
<diip>
djeis[m]: won't it help somewhat with performance?
<djeis[m]>
And the interface for it is only meant to be used by people with knowledge of the compiler internals, so the docs for it aren't written to be user-facing and are also relatively sparse.
<djeis[m]>
Honestly the likelihood of me writing better ASM than SBCL is fairly low.
Necktwi has joined #lisp
<djeis[m]>
For anything nontrivial.
<djeis[m]>
SBCL is already a good compiler.
<djeis[m]>
rme: that's really neat.
serichsen has quit [Ping timeout: 252 seconds]
<diip>
djeis[m]: I agree, but that assumes that the lisp compiler make use of all the optimisations of the chip (which for x86_64 I find hard to believe)
Kundry_Wag has quit [Ping timeout: 246 seconds]
<djeis[m]>
Well, that depends which version of x86_64 you're talking about.
<djeis[m]>
Are you allowing for SSE? because SBCL can make use of those, although admittedly I haven't seen it generate them on its own.
<fiddlerwoaroof>
Part of the problem is that oftentimes the "below-C" level is an implementation detail
<djeis[m]>
It does use the floating point registers properly.
<fiddlerwoaroof>
e.g. on OSX, a lot of the stable interfaces are defined in terms of C or Objective-C
<diip>
no-defun-allowed: I'll test that piece of code out in a bit, thanks
<fiddlerwoaroof>
(to the system)
<fiddlerwoaroof>
If you work below that level, you have a lot more maintenance work to do every time Apple releases an update.
<no-defun-allowed>
diip: You'll need to write your own function which requires specific types. One good, simple function just adds two fixnums.
<beach>
I personally think that if your goal is to turn Common Lisp into C or assembler, you might as well use C or assembler in the first place.
<fiddlerwoaroof>
Well, I would generally like to write CL applications that "fit in" with the rest of the system.
<beach>
Not me.
<fiddlerwoaroof>
But, my general goal is to have as thin a layer at the boundary as possible.
<djeis[m]>
If you just want to hand optimize a particular function for use cases involving very specific types and you know how SBCL has laid those types out in memory, go for it and write an SBCL VOP and teach the compiler the hand written assembly for your problem. But that sort of thing is well beyond diminishing returns for a lot of use cases- the compiler is very clever, especially given the type annotations you'd need for that
<djeis[m]>
inline assembly to be usable by the compiler in the first place.
<fiddlerwoaroof>
Also, from my fiddling with the objective-c runtime and the various APIs exposed on a Mac, my general impression is that the technologies underlying OSX are much nicer than the equivalent layer on Linux
<diip>
beach: don't like C and I do sometimes use assembler, it is just a bit tedious. but I am not trying to turn CL into anything else, I just wondered why.
<diip>
can you call assembler functions from the FFI?
<fiddlerwoaroof>
They're quite inspired by Smalltalk and so they feel more "lispy" when you integrate with them.
pierpal has joined #lisp
<djeis[m]>
If those assembler functions use the C calling conventions, sure.
<djeis[m]>
And expose themselves in a symbol table.
<djeis[m]>
Actually the latter may not be technically required.
<fiddlerwoaroof>
diip: if you're on sbcl, you might also look at pvk.ca and/or figure out how to use sbcl's built-in assembler
<djeis[m]>
You can just call a pointer.
<beach>
diip: I used properly, Common Lisp is a language that is much safer than assembler, C or C++. That is one of its major strengths to me. By "turning Common Lisp into C", I mean making Common Lisp as unsafe as C, which is taking away one of its main advantages.
<djeis[m]>
Tho you'd need to get such a pointer, how you do that is up to you.
keep_learning_M has joined #lisp
<diip>
fiddlerwoaroof: I am thinking of that but like I mention the documentation is a bit evasive, I have only heard of rumours online which point to read the source code eventually
<fiddlerwoaroof>
Yeah, I wish that it was documented better
<djeis[m]>
There are a couple blogposts on that site which walk through the process of writing and interacting with VOPs.
<diip>
djeis[m]: read them (I think)
<djeis[m]>
Past that yea, you basically have to read the source. There are some manuals for the CMUCL compiler and the architecture/terminology is pretty similar to SBCL, so those are helpful.
<diip>
beach: I would like to do some unsafe stuff from time to time even if just to find out why it is unsafe, I like assembler for that I just which I could experiment within the CL environment.
<diip>
fiddlerwoaroof: that I haven't seen, Thanks
<diip>
djeis[m] yes that is how I found out about it
<djeis[m]>
Fair enough.
<djeis[m]>
I'd suggest going back to it every now and then as you learn more of the higher level terminology and such, it actually covers a lot.
<djeis[m]>
There are SBCL-specific calls unrelated to ASM that you're kinda just expected to know about in order to follow along.
<diip>
Python is the compiler for both SBCL and CCL right?
<djeis[m]>
No, SBCL and CMUCL.
<djeis[m]>
Although they've diverged quite a bit.
<djeis[m]>
I'm not honestly sure how similar they are at the line-by-line code level at this point.
<djeis[m]>
CCL has its own thing which I admit little knowledge of.
verisimilitude has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<diip>
djeis[m]: I do go back to the article every so often as it is a bit complicated
<djeis[m]>
I'm happy to answer particular questions to the best of my own knowledge, and that's also a good way for us both to arrive at right answers as someone more knowledgeable jumps in to correct me.
Kundry_Wag has quit [Ping timeout: 268 seconds]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
Oladon has quit [Quit: Leaving.]
pierpal has quit [Read error: Connection reset by peer]
<no-defun-allowed>
If all my threads are waiting on mutexes (with bt:make-lock mutexes) for some reason, is it likely that would appear as high CPU usage?
<no-defun-allowed>
My parallel program sometimes stops and I can't tell why. I think there are mutexes halting everything.
<no-defun-allowed>
A: Probably not, the mutex I have is still free.
<Bike>
if there's like a spinlock
Kundry_Wag has joined #lisp
<no-defun-allowed>
Well, with these pauses there's little benefit to parallelism. It just appears to go very, very slowly after a while.
<Jachy>
It's not deadlocked though?
<no-defun-allowed>
Maybe it is for a while. The one lock I can think of that's important is usually free though.
<no-defun-allowed>
It could also be garbage collecting, actually, but the pauses are very, very long for a GC.
<Jachy>
For deadlock to occur you need to have mutual exclusion, lock & wait (once a thread has a resource, it won't let it go until it's acquired all the others and done its work), no preemption, and circular wait (T1 needs R1 and R2, has R1, waiting on R2. T2 also needs R1 and R2, has R2, waiting on R1.)
<Jachy>
If you can rule out any of those then you're ok as far as deadlock is concerned, though might have other problems.
<Jachy>
e.g. livelock
Kundry_Wag has quit [Ping timeout: 245 seconds]
<no-defun-allowed>
Yeah, I think there wouldn't be any circular waits since the threads will only ever wait on two independent resources, the statistics output and the database.
<no-defun-allowed>
It also could just be the heat, even though it was warmer yesterday.
<no-defun-allowed>
I mean, it could be throttling, but I'd probably notice it a bit more.
xkapastel has quit [Quit: Connection closed for inactivity]
<no-defun-allowed>
It could also be input buffering, come to think of it.
slightlycyborg has quit [Ping timeout: 250 seconds]
iovec has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
ggole has joined #lisp
smokeink has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
dale has quit [Quit: dale]
pierpal has joined #lisp
nanoz has joined #lisp
<no-defun-allowed>
So....I think the issue with my parallel program was that the cache was being overwritten by many differenct processes working on different parts of the computation, so I would need to make the cache larger to accomodate.
prite has joined #lisp
lnostdal has joined #lisp
pierpal has quit [Ping timeout: 245 seconds]
pierpal has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
lnostdal has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Ping timeout: 246 seconds]
quazimodo has quit [Ping timeout: 246 seconds]
<phoe>
pjb: I'll test your graph equality code for a moment. What license do you put on it?
noobineer has quit [Ping timeout: 240 seconds]
quazimodo has joined #lisp
Kundry_Wag has joined #lisp
<splittist>
morning
<beach>
Hello splittist.
Kundry_Wag has quit [Ping timeout: 240 seconds]
lnostdal has joined #lisp
megalography has joined #lisp
ggole has quit [Ping timeout: 240 seconds]
ggole has joined #lisp
orivej has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 250 seconds]
marvin2 has joined #lisp
<phoe>
heyyy
<beach>
Hello phoe.
<no-defun-allowed>
hello phoe
d4ryus has quit [Quit: WeeChat 2.3]
<pjb>
phoe: what license do you want?
d4ryus has joined #lisp
<phoe>
pjb: anything that allows me to embed it in a BSD 2-clause project.
<phoe>
(Which is a library, actually.)
<phoe>
Honestly, I don't know. All of this ends up linked to an AGPL3 project anyway.
<phoe>
And I'm too tired today to think properly.
markoong has joined #lisp
<no-defun-allowed>
what about the #.(tagbody :loop (unwind-protect (loop) (go :loop))) license?
<phoe>
no-defun-allowed: I'd spend too much time figuring it out
<no-defun-allowed>
give it to your lawyer then
<phoe>
it'd ruin me, they bill by hour
random-nick has joined #lisp
Zaab1t has joined #lisp
Kundry_Wag has joined #lisp
ravenousmoose has joined #lisp
Kundry_Wag has quit [Ping timeout: 244 seconds]
ravenousmoose is now known as ravenousmoose[aw
ravenousmoose[aw has quit [Quit: Taking a quick nap...ZZzzz]
<pjb>
phoe: so AGPL3 will be ok. ;-)
atgreen_ is now known as atgreen
Kundry_Wag has joined #lisp
wxie has joined #lisp
angavrilov has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
Kundry_Wag has quit [Ping timeout: 268 seconds]
<phoe>
pjb: okiedokie, I'll give credit to you and license it under agpl3
MetaYan has quit [Ping timeout: 246 seconds]
Kundry_Wag has joined #lisp
<prite>
How does one deal with the 'WARNING: No definition for CFLAG-...' lines from (I'm guessing) loading CFFI? Just let it go to log and ignore it?
Kundry_Wag has quit [Ping timeout: 272 seconds]
ravenousmoose has joined #lisp
smokeink has quit [Quit: Leaving]
wxie has quit [Ping timeout: 240 seconds]
<beach>
One way would be to write your entire program in Common Lisp.
<phoe>
prite: which implementation is that? are you loading CFFI alone?
<prite>
phoe: SBCL. Loading CL+SSL, which depends-on CFFI. I'm loading via asdf.
Kundry_Wag has joined #lisp
fusagi has joined #lisp
<prite>
I tried with "No definition for ~S" (with and without the format specifier) in uiop:*uninteresting-conditions*, but no dice.
<atgreen>
puzzle: (format nil "~{~A~^, ~}" '(:a :b :c)) produces "a, b, c". What I really want is "1, a, 2, b, 3, c" where the number starts at 1 and increments with each new item. Is there any special format hack I can use to do this, or will I have to cons up a new list, inserting the numbers I want?
<refpga>
Hello, are there any common lisp to Web Assembly compilers out there? I can find mentions of Douglas Crosher having worked on it but can't find any related code.
<beach>
Probably not. When it is mentioned as a possibility of running Common Lisp code in the browser, the problem with GC often comes up. It can be argued that you would need a full Common Lisp system running in the browser for it to work.
<beach>
I suppose you could use it as intermediate code in an ordinary Common Lisp system.
atgreen has quit [Remote host closed the connection]
atgreen has joined #lisp
<refpga>
Yeah, I don't necessarily want a repl in the browser. Anyway I'm still learning lisp so I probably don't understand how GC works, but I see lua has a Wasm VM running in the browser(https://cdn.rawgit.com/vvanders/wasm_lua/d68f46a8/main.html)
<refpga>
>I suppose you could use it as intermediate code in an ordinary Common
<refpga>
Lisp system.
<refpga>
Does any implementation do that?
<beach>
The compiler is sometimes used at run-time, for instance to create a discriminating function for a generic function. You could structure your Common Lisp system to avoid that, but it sounds like it would require rethinking the entire architecture compared to existing systems.
ravenousmoose is now known as ravenousmoose[aw
robdog_ has joined #lisp
<beach>
refpga: I have not heard of such a system. What is the reason for your question?
<loke>
There was one CL that compiled to JS
Kundry_Wag has joined #lisp
<refpga>
I was looking into possibility of executing code snippets in a static website.
abhixec has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
nowhere_man has joined #lisp
ravenousmoose[aw has joined #lisp
ravenousmoose[aw has quit [Client Quit]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
cage_ has quit [Remote host closed the connection]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
Kundry_Wag has joined #lisp
FreeBirdLjj has quit [Ping timeout: 246 seconds]
Kundry_Wag has quit [Ping timeout: 246 seconds]
abhixec has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
FreeBirdLjj has joined #lisp
ravenousmoose[aw has joined #lisp
ravenousmoose[aw has quit [Client Quit]
Mr-Potter has joined #lisp
Kundry_Wag has joined #lisp
abhixec has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
FreeBird_ has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
Inline has quit [Read error: Connection reset by peer]
Inline has joined #lisp
abhixec has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
pierpal has quit [Ping timeout: 268 seconds]
Khisanth has quit [Ping timeout: 245 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
slightlycyborg has joined #lisp
msb has quit [Ping timeout: 250 seconds]
ravenousmoose has joined #lisp
ravenousmoose has quit [Client Quit]
ravenousmoose has joined #lisp
Khisanth has joined #lisp
Josh_2 has joined #lisp
abhixec has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
msb has joined #lisp
pierpal has joined #lisp
abhixec has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
rozenglass has quit [Ping timeout: 268 seconds]
Kundry_Wag has joined #lisp
pierpal has quit [Ping timeout: 250 seconds]
pierpal has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
abhixec has quit [Ping timeout: 245 seconds]
pierpal has quit [Ping timeout: 246 seconds]
pierpal has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
phoe has quit [Ping timeout: 252 seconds]
pierpal has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
pierpal has joined #lisp
phoe has joined #lisp
pierpal has quit [Ping timeout: 246 seconds]
pierpal has joined #lisp
pierpal has quit [Ping timeout: 250 seconds]
pierpal has joined #lisp
ravenousmoose has quit [Quit: Taking a quick nap...ZZzzz]
karlosz has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
ebrasca has quit [Remote host closed the connection]
Lycurgus has joined #lisp
pierpal has joined #lisp
nanoz has quit [Ping timeout: 245 seconds]
ebrasca has joined #lisp
Kundry_Wag has joined #lisp
ravenousmoose has joined #lisp
pierpal has quit [Ping timeout: 250 seconds]
random-nick has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
pierpal has joined #lisp
pierpal has quit [Ping timeout: 245 seconds]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Quit: karlosz]
pierpal has joined #lisp
metallicus has joined #lisp
Kundry_Wag has joined #lisp
sjl_ has quit [K-Lined]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
Kundry_Wag has joined #lisp
dddddd has quit [Remote host closed the connection]
random-nick has joined #lisp
metallicus has quit [Quit: WeeChat 2.3]
pierpal has quit [Ping timeout: 250 seconds]
Kundry_Wag has quit [Ping timeout: 240 seconds]
verisimilitude has joined #lisp
ravenousmoose has quit [Quit: Taking a quick nap...ZZzzz]
pierpal has joined #lisp
orivej has joined #lisp
atgreen has quit [Ping timeout: 240 seconds]
pierpal has quit [Ping timeout: 250 seconds]
<LdBeth>
does anyone heard of Ludwig Wittgenstein?
<MichaelRaskin>
I am a bit scared this question is asked here and not in #lispcafe, given who Wittgenstein is.
<aeth>
logic could technically just barely be on topic here, though.
<Bike>
eh, wiittgenstein is closer to lisp than a lot of philosophers
pierpal has joined #lisp
Zaab1t has quit [Quit: bye bye friends]
slightlycyborg has quit [Ping timeout: 244 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
pierpal has quit [Ping timeout: 240 seconds]
figurehe4d has joined #lisp
<LdBeth>
> Some romantics had even demanded that robots be programmed with desires of their own, but this was illegal.
abhixec has quit [Ping timeout: 245 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
Lycurgus has quit [Quit: Exeunt]
<Bike>
is that in wittgenstein? i don't think it is.
figurehe4d has quit [Remote host closed the connection]
<Jachy>
That's from McCarthy's robot story I think.
<verisimilitude>
It is; my first thought was it was from that queer story RMS wrote, but that couldn't be right.
<verisimilitude>
It's ``The Robot and the Baby'', Jachy.
ravenousmoose has joined #lisp
la_mettrie has joined #lisp
<verisimilitude>
I suppose I'd argue McCarthy had too much faith in AI. The future of IA is much more optimistic, I'd think.
<Bike>
AI but french?
<aeth>
Everyone was overly optimistic on two things: artificial intelligence and space travel. You can see both in 2001, the movie, of course, not the year.
<verisimilitude>
The IA is Intelligence Amplification, Bike.
<verisimilitude>
So, you simply augment an existing intelligence, instead of creating an artificial such intelligence.
<Bike>
like when i do some speedballs and figure out the riemann hypothesis? yeah i dig that
<aeth>
verisimilitude: I'm not sure there's a clear line between AI and IA. If I can plug my mind into a computer and gradually increase my intelligence, at what point do I stop being human and just become an AI via bootstrapping?
<verisimilitude>
I figure eventually animal brains will be grown in vats or simply harvested and then used for object recognition or other such tasks they're good at.
<verisimilitude>
You wouldn't necessarily be plugging your brain into a computer, aeth.
<verisimilitude>
General AI doesn't exist. A basic example of IA is a pen and paper.
<aeth>
verisimilitude: Bandwidth issues. Eventually we're going to need direct neural interfaces to continue to see efficiency improvements.
<Josh_2>
stick those needles into my brain!
<verisimilitude>
Well, I'll pass. Have fun becoming a toaster.
<Bike>
needles probably wouldn't be adequate, you'd need some of your skull removed and one of those cortical implants
Kundry_Wag has joined #lisp
<Bike>
it's more like a sheet covered in a billion tiny needles, see
la_mettrie has left #lisp ["WeeChat 2.2"]
<aeth>
I mean if Amamicroapgoobook is doing the neural interface, I'd pass on it too.
<Josh_2>
Bike: sounds like some needs to me
<verisimilitude>
Anyway, AI problems can feed into IA. The basic example is having an ``AI'' solve what it can, leaving what is the IA to direct it and free to solve what is left.
<Bike>
amazon microsoft .... something.... google facebook
<aeth>
ap for apple
<Bike>
oh those guys.
<MichaelRaskin>
State of IA seems to be worse than the in The Demo (by Engelbart)
notzmv has joined #lisp
<verisimilitude>
You already see this in plane controls and whatnot; the plane software manages everything it can with the human pilot ultimately in control.
<aeth>
I mean I guess I could say FAANG but that includes Netflix and doesn't include Microsoft and I doubt Netflix is going to be a heavy hitter in this sort of thing.
FreeBird_ has quit [Remote host closed the connection]
Kundry_Wag has quit [Read error: Connection reset by peer]
<aeth>
But my bad, I should have said app for apple
FreeBirdLjj has joined #lisp
<verisimilitude>
Oh, here's an amusing abbrevation for those companies I've seen, aeth:
<verisimilitude>
FAGMART (Facebook Apple Google Microsoft Amazon Reddit Twitter)
Kundry_Wag has joined #lisp
<verisimilitude>
I suppose it could become the more casual FANGMART if you include Netflix in there.
joethecodhr has joined #lisp
atgreen has joined #lisp
<djeis[m]>
To keep seeing improvements then eventually such external control systems would need solvers on the same tier as general intelligence tho, wouldn't they? That or they'd need to tie in the human at ever more complex levels, at which point you start talking about neural interfaces again.
<djeis[m]>
Given, as was pointed out, the bandwidth issues of our senses.
<verisimilitude>
Machines are limited in ways I'd argue humans aren't.
<verisimilitude>
There are problems Turing machines can't solve, but I don't accept the brain is a Turing machine, so the brain would always be the superior and more capable.
<djeis[m]>
And now we're brushing awfully close to philosophy.
FreeBirdLjj has quit [Ping timeout: 244 seconds]
<aeth>
djeis[m]: To be fair, afaik it hasn't been proven either way, yet.
Kundry_Wag has quit [Ping timeout: 240 seconds]
<djeis[m]>
Also, you haven't shown that the brain is capable of solving said problems.
<djeis[m]>
Sure, hence why I'm hesitant to get into that debate lol
<verisimilitude>
I just think it's obvious. I refuse to accept there are things humans can't understand until shown otherwise.
<djeis[m]>
Well then we can take this discussion no further.
<Bike>
what if we can't understand what we can't understand
<verisimilitude>
The people who want to be limited machines can do that if they please.
<aeth>
verisimilitude: That's a very 1900-1910s view, that humans will eventually solve everything
<aeth>
The contemporary approach is that there are limits
<pjb>
Yes, we have limitation theorems in CS.
<pjb>
And we know the universe itself is limited.
<aeth>
Stuff like Godel's incompleteness, the halting problem, the standard interpretation of quantum mechanics, etc.
<pjb>
ONLY 1e80 particules in the universe!
<verisimilitude>
Since formal systems are limited, that just shows me that the brain isn't a formal system.
<pjb>
ONLY 1e200 years of life expectancy (actually only 1e15 of business as usuall remaining, the rest is just cold death).
<djeis[m]>
If the reasoning of the human brain is beyond that of any feasible formal systems then we have a problem, because that requires the universe itself to be beyond the models of any formal system and our understanding of it will always be flawed.
<pjb>
verisimilitude: I would bet the opposite.
<pjb>
verisimilitude: prove that any material agglomerate of finite mass does not form a formal system.
<djeis[m]>
Because we can only understand the universe through the predictions of our models.
<aeth>
pjb: To be fair, our observations about the universe are about the observable universe, and if we do have faster than light travel that's sufficiently fast (intergalactic, not just interstellar), we expand the observable universe, so even if we had a perfect bounds on the observable universe's size, we can't say that's it until we prove/disprove FTL
<verisimilitude>
Well, I'm going to live my life thinking what I do, rather than believe I could be emulated by a machine.
<pjb>
aeth: granted, but nothing says that you have to know all the parts of a formal system either.
<djeis[m]>
I choose to believe I have free will, because that belief is more useful to me than assuming the opposite and I have no particularly good evidence either way.
<pjb>
verisimilitude: no difference.
<djeis[m]>
But I still admit that that is a faith I hold.
<pjb>
verisimilitude: notice that you still have free will: your program will run without interference from God.
<verisimilitude>
Rephrase that, pjb.
<djeis[m]>
And that doesn't preclude me from accepting evidence of the opposite, or even exploring technologies that involve the opposite assertion.
<pjb>
verisimilitude: people have a wrong idea of what free will is. Free will is the promize by God that He will not interfer with your program. He won't use gdb attach verisimilitude and modify variable while you're alive.
<verisimilitude>
It would be comforting to believe a god exists, but I don't.
<pjb>
This is important because the Bible reports a few humans that were tampered.
<pjb>
They you should be happy: no God => automatic free will.
<fiddlerwoaroof>
#offtopic
<fiddlerwoaroof>
:)
<pjb>
Yep. This is the mood.
<verisimilitude>
I look at the current state of the world and I think most people would agree the Christian god should hurry up and start killing entire groups of people again.
<fiddlerwoaroof>
Anyways, in emacs, shouldn't I be able to expect that (let ((inferior-lisp-program "ccl")) (slime)) to start ccl?
<Josh_2>
#lispcafe
adam45 has joined #lisp
<fiddlerwoaroof>
I'm pretty sure that this worked at one point...
<verisimilitude>
That seems right, fiddlerwoaroof.
<djeis[m]>
Well that's a totally different discussion and not one I'm interested in having lol
<djeis[m]>
fiddlerwoaroof: yea that looks right.
<fiddlerwoaroof>
But, now, it's just starting my default implementation
<pjb>
verisimilitude: Christian God is not of the killing type. Ask Muslims' or Jews' God instead.
<Josh_2>
^ *dabs*
<djeis[m]>
Do you have any of the other implementation variables set?
<verisimilitude>
That variable isn't lexical, right
<verisimilitude>
?
<fiddlerwoaroof>
I don't think it's lexical
<pjb>
It could be.
<fiddlerwoaroof>
I have functions in my init-el that I've used that do this
<djeis[m]>
Global variables get dynamically bound even when lexical binding is turned on.
<pjb>
But some implementations issue warning if it's not.
<verisimilitude>
No, it's dynamic, yes.
<pjb>
djeis[m]: if you're talking of lexical binding being turned on, then you're off-topic. emacs lisp is in #emacs
<verisimilitude>
So, it's odd that wouldn't be working, fiddlerwoaroof.
<djeis[m]>
This is a question about an emacs init file pjb
<djeis[m]>
So if ppl are off topic it's not my fault.
<fiddlerwoaroof>
I know it's not lexical, because I added a (message) to the (defun slime)
<pjb>
Then #emacs You're more off-topic than God questions (everybody knows God used Common Lisp to write the universe)