<jasom>
I use my thumb for alt and my middle finger for control when I need to use emacs keys that I haven't remapped yet (e.g. C-c C-k) by moving my whole hand; it's a smaller movement than going to my trackball so shouldn't be too bad.
<Blackbeard>
i am trying to write a function
<Blackbeard>
that repeats every 30 minutes
<Blackbeard>
I tried a while loop with an (sleep ) and then the actual function
<Blackbeard>
but it didn't work
<Blackbeard>
after the first iteration it breaks
<Blackbeard>
any suggestions?🤔
<Bike>
"while loop"?
<jasom>
Blackbeard: paste what you tried?
<Blackbeard>
sorry
<jasom>
This ought to work: (loop (sleep (* 30 60)) (function))
<Blackbeard>
(loop while t (progn (sleep 30)(function)))
<Bike>
that shouldn't compile
<Bike>
just go with jasom's
<jasom>
also yours is 30 seconds, not 30 minutes, FWIW
<Blackbeard>
yes sorry
<Bike>
you don't need to apologize
<no-defun-allowed>
hi Blackbeard🎖🛡🗡
<Blackbeard>
i was using 30 seconds to test
<no-defun-allowed>
you only need the short form of LOOP: `(loop (sleep LENGTH) (function))`
<no-defun-allowed>
if you do want the long form, you can just do `(loop do ...)`
Arcaelyx_ has quit [Ping timeout: 240 seconds]
<Blackbeard>
perfect it works!
<Blackbeard>
My only problem now is that i can't do anything else 😅
<stylewarning>
I talked to the guy who is in the middle of trying to port PPC64 on SBCL. Hasn’t made it past cold-init
<aeth>
ah
FreeBirdLjj has quit [Remote host closed the connection]
<aeth>
I expected "in progress" to mean more than that
<stylewarning>
Likewise
FreeBirdLjj has joined #lisp
dented42 has joined #lisp
Bike has quit [Quit: Lost terminal]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
Roy_Fokker has quit [Read error: Connection reset by peer]
meepdeew has quit [Remote host closed the connection]
Fare has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 245 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
Fare has joined #lisp
FreeBirdLjj has joined #lisp
anewuser has quit [Quit: anewuser]
Fare has quit [Ping timeout: 252 seconds]
suskeyhose has quit [Quit: ERC (IRC client for Emacs 26.1)]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
Fare has joined #lisp
Oladon has quit [Quit: Leaving.]
holycow has quit [Quit: Lost terminal]
Fare has quit [Ping timeout: 252 seconds]
Pixel_Outlaw has joined #lisp
fortitude has quit [Ping timeout: 252 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
<beach>
Good morning everyone!
FreeBirdLjj has quit [Remote host closed the connection]
Pixel_Outlaw has quit [Quit: Leaving]
<no-defun-allowed>
morning beach
makomo has quit [Ping timeout: 260 seconds]
<beach>
plathrop: No, not every language must be written in another language. In fact, languages are not written in anything at all. Implementations are.
<beach>
pfdietz: Eclector replaces the SICL reader that I refer to in my papers.
<beach>
no-defun-allowed: So you have made a decision? 2020 it is?
<no-defun-allowed>
yes, 2020 it is
<beach>
Great!
smokeink has joined #lisp
FreeBirdLjj has joined #lisp
<Blackbeard>
What are your favorite Lisp programs or games or scripts
<aeth>
stumpwm
<aeth>
at the very least, most used
<Blackbeard>
yeah 😃 it is awesome
<no-defun-allowed>
do metacircular evaluators count? i like those.
smokeink has quit [Ping timeout: 240 seconds]
FreeBirdLjj has quit [Ping timeout: 244 seconds]
eminhi has joined #lisp
<LdBeth>
Just Clozure CL
<no-defun-allowed>
after an hour i got shodan.io giving me lots of results using the powers of BISECTION and COORDINATES and things
<no-defun-allowed>
the only downside is i couldn't get drakma to replicate the requests so i have to run curl ):
smokeink has joined #lisp
eminhi has quit [Quit: leaving]
SenasOzys has quit [Read error: Connection reset by peer]
<no-defun-allowed>
writing my own mass scanner seems more feasible than getting this to work reliably and quickly
housel has quit [Read error: Connection reset by peer]
housel has joined #lisp
SenasOzys has joined #lisp
sauvin has joined #lisp
steiner has quit [Remote host closed the connection]
steiner has joined #lisp
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
nowhere_man has quit [Ping timeout: 252 seconds]
nowhere_man has joined #lisp
_whitelogger has joined #lisp
weltung has joined #lisp
nowhereman has joined #lisp
nowhereman is now known as Guest25977
nowhere_man has quit [Ping timeout: 240 seconds]
jack_rabbit has joined #lisp
FreeBirdLjj has joined #lisp
shka_ has joined #lisp
orivej has joined #lisp
TMA has joined #lisp
<mfiano>
Shinmera: Not just cl-jpg, but retrospectiff can't read all TIFFs, and cl-tga can't read all Targa files. All image format parsers in CL are either slow or incomplete, and sometimes the speed is due to a dependency, like with the pngload case. I really wish the quality of these codes were a bit better, but I have no time to fix pngload, let alone write a faster chipz replacement. Actually there are a few
<mfiano>
alternatives to chipz, and they are all horrible :/
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<shka_>
why chipz is slow?
<|3b|>
presumably wasn't written for speed
<shka_>
eh
<|3b|>
(and written in a way that isn't obvious how to optimize after the fact)
<|3b|>
also a bit hard to write that sort of thing quickly without sacrificing safety
<|3b|>
and/or readability
<|3b|>
lots of random array accesses at calculated indices, so hard to statically guarantee they are in-bounds
<|3b|>
(at least i think that was one of the problems with it)
razzy has quit [Read error: No route to host]
angavrilov has joined #lisp
* |3b|
wonders if asdf memoizes/caches results while figuring out how to load a system. loading a system with 4.5k deps, which are nodes of a fairly shallow tree, and wondering if it is recalculating the interior nodes every time it sees them or not
<|3b|>
(takes ~14sec to figure out how to load the whole thing)
* |3b|
realizes this is a silly thing to want to do, blame android :/
<|3b|>
probably doesn't help that i'm including some of the intermediate deps twice... i should probably fix that
vlatkoB has joined #lisp
la_mettrie has joined #lisp
<la_mettrie>
which lisp dialect to study? which paperbook about lisp to buy? (i have no particular use for the language, just interested in reading about different languages. i am a linux/unix user, inspired by the traditional hacker culture, emacs user)
<beach>
la_mettrie: This channel is dedicated to Common Lisp.
varjag has joined #lisp
<beach>
la_mettrie: So that's what we recommend.
<jackdaniel>
minion: tell la_mettrie about pcl
<minion>
la_mettrie: direct your attention towards pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<jackdaniel>
minion: tell la_mettrie about paip
<minion>
la_mettrie: paip: Paradigms of Artificial Intelligence Programming
<jackdaniel>
oh, minion does not have a link to paip
<beach>
la_mettrie: If you already know how to program in some other language, then PCL is usually what people here recommend.
<jackdaniel>
la_mettrie: paip was recently released so you can read it online for free
<la_mettrie>
okay, thanks
<la_mettrie>
what is the argument for choosing the common lisp?
<jackdaniel>
standard, relatively big ecosystem, rich set of compilers, performance
<la_mettrie>
okay, fine
<beach>
Excellent object system.
<beach>
Friendly and helpful IRC channel. :)
<TMA>
an often overlooked asset is the condition system
<la_mettrie>
okay, so the latest edition of pcl is from 2005
<Shinmera>
and it still is a fine book
<beach>
la_mettrie: There are some thing that did not exist then, but mostly it is still valid.
<beach>
la_mettrie: We recommend Quicklisp to install systems, and most people here probably use Emacs with SLIME.
<la_mettrie>
ok, just wanted to be sure that 2005 is the latest edition so that i do not grab an older one
<no-defun-allowed>
you can install slime via quicklisp (or emacs's package manager) which may be easier to maintain
<Shinmera>
la_mettrie: one note is that the book will talk about a "Lisp Box". This is outdated and likely won't work anymore. There is a replacement however, called Portacle. https://portacle.github.io
<beach>
Good point.
SaganMan has quit [Quit: WeeChat 1.6]
vlatkoB has quit [Remote host closed the connection]
edgar-rft has joined #lisp
vlatkoB has joined #lisp
Patzy has quit [Ping timeout: 246 seconds]
random-nick has joined #lisp
Patzy has joined #lisp
robotoad has quit [Quit: robotoad]
razzy has joined #lisp
kenu has quit [Ping timeout: 240 seconds]
ggole has joined #lisp
steiner has quit [Remote host closed the connection]
ggole has quit [Client Quit]
ggole has joined #lisp
wigust has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
marvin2 has quit [Ping timeout: 252 seconds]
robotoad has joined #lisp
orivej has joined #lisp
<|3b|>
ah, most of the time seems to be quicklisp reading its list of systems to see if it knows about them :/
igemnace has quit [Quit: WeeChat 2.2]
makomo has joined #lisp
varjag has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
la_mettrie has left #lisp [#lisp]
astalla has joined #lisp
robotoad has quit [Quit: robotoad]
pjb has joined #lisp
steiner has joined #lisp
<makomo>
morning
doubledup has joined #lisp
moei has quit [Ping timeout: 252 seconds]
random-nick has quit [Read error: Connection reset by peer]
<phoe>
...damn, I just realized that I'm facing a problem that could easily be solved using continuations - if I only could save the stack somewhere and somehow
<flip214>
or, if you don't want that library, just pass lambdas around... ;)
shrdlu68 has joined #lisp
pioneer42 has joined #lisp
<phoe>
flip214: yes, I'm thinking of it right now
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
anewuser has joined #lisp
marvin2 has joined #lisp
<shka_>
phoe: what are you trying to do?
asarch has joined #lisp
<phoe>
shka_: implement a reader for a Lisp-like protocol, except the reader may be interrupted at any point (for example, by NIL returned from READ-CHAR-NO-HANG) and it should be possible for it to remember what it read so far and restart reading when input is available again
<shka_>
phoe: and protocol is in the form of...?
<phoe>
S-expressions, more or less
<phoe>
parens, symbols, strings, numbers
<shka_>
ok
ober has joined #lisp
<phoe>
in the worst case, I'll just remember the part of the string that was read so far, save it somewhere, and then start reading again from a concatenated stream
<shka_>
that may not be enough
<phoe>
if we read "(1 2" then we save that string somewhere, so later we may read "3 4 5)" which will give us the resulting (1 23 4 5)
makomo_ has joined #lisp
<shka_>
and what if 3 4 5 will be read multiple times?
<shka_>
is it allowed?
<phoe>
multiple times? what do you mean?
<phoe>
let's assume that we're reading from a network socket - when a character is read from that socket's stream, it won't be read again from it
<shka_>
yup
varjag has joined #lisp
pioneer42 has quit [Quit: Leaving.]
makomo has quit [Ping timeout: 252 seconds]
<pjb>
You could invent a reader macro to read parts several times.
<pjb>
But for a character by character repeatition, it'd be harder, because in your example, the prefix would already be parsed…
varjag has quit [Ping timeout: 246 seconds]
<phoe>
Yep, my issue is that I need to be able to return control any time READ-CHAR-NO-HANG returns NIL, meaning, there's no character available for reading.
<phoe>
And then I need to be able to rewind the stack and continue reading from the exact same position and state.
<shka_>
reading after nil?
<phoe>
No - once there is some input on the character stream again.
<shka_>
ah, you don't want to block?
<phoe>
Once READ-CHAR-NO-HANG is able to return non-NIL.
<phoe>
Yes - I don't want to block.
<shka_>
well, ok
<phoe>
If I could just call a blocking READ or anything similar, that wouldn't be an issue.
<shka_>
and threads is no-go?
tfeb has joined #lisp
rumbler31 has joined #lisp
<phoe>
I don't want to create hundreds+ of threads just to make sure my connectivity works
<phoe>
Since it's possible that I will have hundreds+ of simultaneous connections
<shka_>
ok
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
lnostdal has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<razzy>
x
<phoe>
Error: The variable X is unbound. [Condition of type UNBOUND-VARIABLE]
Lycurgus has joined #lisp
cl-arthur has joined #lisp
steiner has joined #lisp
nullniverse has joined #lisp
<shka_>
shrdlu68: and?
<shka_>
no compression i tink
edgar-rft has quit [Remote host closed the connection]
<asarch>
An off-topic question: what is comment in CSS?
<shka_>
so it should not by any better
<phoe>
/* this */
<asarch>
Thank you!
<asarch>
Any good IRC client written in Common Lisp?
<phoe>
/* no problem (: */
<shrdlu68>
shka_: It's better, memory-wise. But performance is horrible.
<phoe>
asarch: a user-facing client? I don't know, might be none
<oni-on-ion>
css: Found premature EOF or No input files
<phoe>
but there's plenty of libraries
<shka_>
shrdlu68: worse then my version?
<asarch>
There is a small one called ii
<asarch>
Written in C?
<asarch>
I'm planning to write a web interface for an IRC client written in Common Lisp so I could check all the messages from any PC connected in the LAN
<shrdlu68>
shka_: Lemme compare them.
<oni-on-ion>
asarch: sounds cool. i had a very pleasant time setting up cl-irc for a similar purpose the other day.
<phoe>
How can I create an output stream that forever blocks? I need it for testing purposes.
<phoe>
In other words, I want to create a modified string output stream that, for example, outputs "a b" and then hangs indefinitely (READ-CHAR-NO-HANG returns NIL on it).
<shka_>
phoe: flexistreams?
<phoe>
shka_: what exactly about flexistreams?
<shka_>
phoe: in-memory flexistream
<phoe>
sure, but the in-memory flexistream will AFAIK behave the same way a string output stream behaves
<phoe>
which is to output everything, and then return EOF
<shka_>
oh
<phoe>
I want it NOT to return an EOF and instead hang
<phoe>
More or less like a network socket stream
<shka_>
hmmmm
<phoe>
Except I don't want to create network sockets for that, since that would be a hack
<shrdlu68>
shka_: Interestingly, converting to a vector instead of a class improves performance 2x.
<oni-on-ion>
net work socks
<shka_>
shrdlu68: struct should be equally good
<shrdlu68>
Actually that might have to do with the fact that each child node is only created when needed.
<shka_>
well, yes
<shka_>
but there is more going on here
<shka_>
if i was you, i would try to introduce bitmask into my tree node and use this to compress vector
<phoe>
wait, not an output stream - an input stream
<phoe>
agh! I always confuse these two
nullniverse has quit [Quit: Undertaking stack overflow prevention]
SenasOzys has quit [Ping timeout: 240 seconds]
Posterdati has joined #lisp
<Posterdati>
hi
<Posterdati>
please help, how can I handle :ENOTCONN error during a socket connection?
<dlowe>
I'm pretty sure that means you've set the socket to non-blocking mode before connecting
<dlowe>
no, that's EINPROGESS
<dlowe>
you're getting ENOTCONN from connect()?
<Posterdati>
yes, but cannot intercept it in the client thread with handler-case
<Posterdati>
I placed in the handler-case (iolib/sockets:socket-not-connected-error () ... )
<Posterdati>
it didn't work when connection was established and server went away
<ggole>
IIRC connect(2) doesn't generate ENOTCONN, read(2) does
<dlowe>
try handling iolib:socket-error and iolib:hangup
<dlowe>
I handle a lot of different potential network errors
<dlowe>
ENOTCONN is when you try to use a socket and it's not connected
<Posterdati>
yes
<dlowe>
you don't want a socket to be connected if you're using it for connecting
<Posterdati>
and it is correct, I had this error because the server went away
gector has quit [Read error: Connection reset by peer]
<flip214>
phoe: you can use a CONCATENATED-STREAM and have first a STRING-OUTPUT-STREAM and then some pipe or socket
<Posterdati>
mmmh I placed iolib/sockets:socket-error in the thread, but fallen in to the debugger...
gector has joined #lisp
<phoe>
flip214: yes, but employing sockets for that looks pretty un-clean to me
rumbler31 has joined #lisp
<flip214>
phoe: well, how about your own stream class that just never returns data?
<phoe>
flip214: I'm thinking of that
<phoe>
writing a trivial Gray stream class and methods on it
<_death>
it's unlikely that you actually want something that "hangs indefinitely".. you can use gray streams to define a stream that makes sense
rumbler31 has quit [Ping timeout: 252 seconds]
<Posterdati>
people! I founf the problem, I used remote-host and remote-port on the error handler-case on the dead socket :), now I removed them and it worked!
<flip214>
phoe: if you would be so kind as to create a github project with a stream that outputs _only_ what gets written to it? a "pipe stream"?
<Posterdati>
thanks people!!!
<phoe>
flip214: I'll think of it, sure
<flip214>
thanks
pierpal has quit [Ping timeout: 246 seconds]
cl-arthur has quit [Ping timeout: 240 seconds]
<shrdlu68>
flip214: Isn't this the natural function of streams?
<pjb>
on the other hand, you have a parenthesis error.
<paule32>
sbcl
<paule32>
illegal terminating character after a colon: #\; Line: 514, Column: 1, File-Position: 21863
<pjb>
paule32: also, you're confusing program and data.
<pjb>
paule32: nope. [1]> (load "/tmp/a.lisp") ;; Loading file /tmp/a.lisp ... *** - READ: input stream #<INPUT BUFFERED FILE-STREAM CHARACTER #P"/tmp/a.lisp" @516> ends within an object. Last opening parenthesis probably in line 413.
<pjb>
<paule32>
yes
<paule32>
i can't see it
<paule32>
i check over
<paule32>
but fail to find
smokeink has quit [Remote host closed the connection]
smokeink has joined #lisp
<pjb>
paule32: that's because you're not using emacs.
<phoe>
or any other editor that counts parentheses for you
sauvin_ has joined #lisp
sauvin_ has quit [Max SendQ exceeded]
<pjb>
paule32: but you can be smart: (with-open-file (source #P"/tmp/a.lisp") (loop for sexp := (read source nil source) :until (eq sexp source) :do (print sexp)))
<paule32>
i have open emacs
<paule32>
what's next?
sauvin has quit [Ping timeout: 240 seconds]
<pjb>
C-h t
<pjb>
to read the tutorial (1/2 hour).
<pjb>
C-h t = type control-h and then t
ggole has quit [Quit: ggole]
dented42 has joined #lisp
Kevslinger has joined #lisp
dented42 has quit [Client Quit]
lemonpepper24 has joined #lisp
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
jack_rabbit has joined #lisp
sauvin_ has joined #lisp
fchurca has quit [Quit: Page closed]
sauvin_ has quit [Max SendQ exceeded]
sauvin_ has joined #lisp
sauvin_ has quit [Max SendQ exceeded]
sauvin_ has joined #lisp
thetemplar has joined #lisp
rumbler31 has joined #lisp
thetemplar has quit [Quit: WeeChat 2.2]
thetemplar has joined #lisp
rumbler31 has quit [Ping timeout: 245 seconds]
pierpal has quit [Ping timeout: 244 seconds]
Jesin has quit [Quit: Leaving]
sauvin_ is now known as Sauvin
Fare has joined #lisp
<paule32>
so, found
<paule32>
it is an advanture programming with lisp, if you have much code - that means, if you have forget a open or closed parenthese, you fail
<paule32>
but, lispers are hard
<paule32>
they felt in love with ( and ) :-D
<djeis[m]>
I would hate having to manage parens by hand, it would quickly drive me nuts.
<djeis[m]>
So I let my editor do that bit.
<thetemplar>
paredit in emacs?
<paule32>
it's not i can't programming, but i am new in lisp and emacs
pierpal has joined #lisp
<adlai>
thetemplar: what is jeopardy?
<paule32>
and i found, lisp is good for learning systems
<no-defun-allowed>
Morning everyone
<paule32>
morning
<aeth>
Managing parentheses by hand isn't bad.
<djeis[m]>
paule32: it is difficult at first, but if you learn some paren management packages it’ll become a lot easier.
<aeth>
Managing your own parentheses while refactoring is painful.
<djeis[m]>
paule32: after a little while the parens stop bothering you altogether.
<aeth>
if I want to move the (* 3 4) in (+ 1 2 (* 3 4)) I don't want to have to do anything other than move the ( before the *
<adlai>
managing them by hand builds character, and eventually you lose patience with unbased chars
<no-defun-allowed>
If Gerald Sussman can do it on a blackboard, it can't be that bad.
<djeis[m]>
Fair lol
<aeth>
no-defun-allowed: did someone check his work to make sure they were always balanced?
<adlai>
it's well-known that MIT students sleep during lectures
<no-defun-allowed>
aeth: Edwin would blink the parens in the book I presume
<no-defun-allowed>
On the blackboards he was checking himself. He only missed one in lecture 2b.
<paule32>
2b - class 12?
pierpal has quit [Ping timeout: 244 seconds]
<aeth>
The problem with parentheses is that the level they're at often changes, especially if you e.g. refactor (+ 1 2 (* 3 4)) into (let ((a 0) (b 1) (c 2) (d 4)) (+ a b (* c d)))
<aeth>
It can quickly become slow if you don't use something like paredit
<paule32>
if you speak over programming or program speed ?
dented42 has joined #lisp
<paule32>
is the stack of clisp limited to 10 pushes ?
Jesin has joined #lisp
<no-defun-allowed>
10 is quite small.
<no-defun-allowed>
I'd say usually program stacks are around 1000 calls long in interpreters.
<paule32>
i test it here with (setq foo '() '() ... ) and clisp crashed at 10
<no-defun-allowed>
I think it would just be annoyed you told it to set (quote nil).
<no-defun-allowed>
(setq/f happens in variable+value pairs.)
<makomo>
paule32: that's not how you're supposed to use SETQ. the syntax is (setq <var1> <value1> <var2> <value2> ...)
<aeth>
paule32: what were you trying to do?
pierpal has joined #lisp
<paule32>
aeth: natural text recognition
<makomo>
paule32: clisp didn't crash, it just signalled an error
<paule32>
aeth: at this stage: a simple grammar tester
<no-defun-allowed>
Yeah, it's very rare for a Lisp system to crash.
<no-defun-allowed>
`(loop collect 42)` is a good way to try to crash it.
<makomo>
paule32: also, the size of the stack is irrelevant here, because who knows how the parameters are actually passed (it's an implementation detail)
<paule32>
yes
<aeth>
no-defun-allowed: It's very easy to get a Lisp system to crash.
<aeth>
no-defun-allowed: (safety 0) in SBCL
<makomo>
lul
<aeth>
well, it won't crash, it'll just say "the integrity of this image has been compromised. continuing with fingers crossed" or whatever the exact message is.
<aeth>
I don't want to torture a poor image just to get the exact quote
<paule32>
does clisp compile native?
<makomo>
paule32: i'm not sure, but i don't think so. SBCL does
<aeth>
Ah, it's "The integrity of this image is possibly compromised.\nContinuing with fingers crossed.\n" I looked it up in the source.
<no-defun-allowed>
Clisp uses bytecode.
<White_Flame>
paule32: there's the CALL-ARGUMENTS-LIMIT constant that will tell you the max things you can pass to a function
<White_Flame>
however, SETQ isn't a function; it's a special form
<Bike>
when paul came around here last january it was suggested they read a book about the language, but they don't seem to have gotten around to it.
<Bike>
maybe there's a german (?) language text, i don't know. Something.
<makomo>
heh :p
<paule32>
my plan is it (atm), to have a database of nouns, vocals ... these what you can see in the paste, i try to place it into real database like mysql
<aeth>
SBCL and CCL and CMUCL are native compilers. ABCL compiles to JVM bytecode. CLISP compiles to its own bytecode. ECL compiles to C, but has a backup interpreter.
<Bike>
It's just annoying seeing everybody trying here when none of it is getting through.
<White_Flame>
paule32: honestly, Prolog is probably what you want to play with, as it combines symbolic inference with a database
<Shinmera>
hasn't it been a year of unheeded advice by now?
<Bike>
at least nineteen months
<aeth>
I haven't seen paule32 here in a long time. Months.
<paule32>
White_Flame: no, prolog is 0 or 1 logic
<White_Flame>
wat
<paule32>
i need something between there
<paule32>
hi aeth, sorry
<no-defun-allowed>
paule32: that's verilog if I had to guess
<adlai>
paule32: ever heard of the dedekind cut?
<paule32>
i have mess time with programming a ide for programming
<paule32>
my intention is to support lisp
<paule32>
ansi standard
<paule32>
a moment please, i will make screen shoot's ...
<adlai>
paule32: skip the screenshot, study p-adic arithmetic and see if you can't find a more efficiently verifiable proof of Fermat's Last.
<adlai>
trust me, Top Men are hard at work on "supporting lisp ansi standard ide programming" or whatever it is.
<White_Flame>
paule32: CL is a language steeped in issuing custom commands, from the language to the editor. I don't think colors, buttons, & forms will garner much interest, but rather any useful helper call that those invoke
<aeth>
no-defun-allowed: it's done without any consideration of aesthetics or design... very 90s retro
<no-defun-allowed>
The colour choices are quite concerning.
<White_Flame>
unless you have something genera-like, where all those elements are active Lisp objects
<pjb>
And English is irrelevant here. Even in French, there are no parenthesis in lisp.
<White_Flame>
or since you're already an emacs user, install paredit
<pjb>
paule32: you should read PAIP. Check notably chapter 4.
<paule32>
#| block comment |#
<paule32>
can it be used in multiple lines?
gravicappa has quit [Ping timeout: 252 seconds]
<White_Flame>
yes. Also, maybe these sorts of questions are more appropriate for #clschool than #lisp
stnutt has left #lisp [#lisp]
<Blackbeard>
#'no-defun-allowed: yes master yoda🤔
<aeth>
pjb: That's an oversimplification
<aeth>
Lisp has both #\( and #\)
<pjb>
aeth: that's and advice. Learning the GPS should help somebody who wants to do NLP but don't seem to care for learning lisp before trying to write NLP in lisp…
<White_Flame>
then the source doe lisp source is text? :-P
<White_Flame>
s/doe/for/
<pjb>
White_Flame: not the source. The human-readable serialised form.
<pjb>
White_Flame: you could also serialize the sexps into ASN.1 BER format.
<White_Flame>
you mean human-written
<pjb>
PRINT.
<White_Flame>
"serialized" tends to imply output, not input
<White_Flame>
and "source" tends to imply input
random-nick has quit [Ping timeout: 246 seconds]
<pjb>
White_Flame: you can insert elements in a list without tying parentheses. Try sedit.
<White_Flame>
yes, but that's not "source code"
<White_Flame>
those are runtime effects
<pjb>
White_Flame: now, granted, sedit would need a new command to insert a new list. I took the easy path, by using the lisp reader.
<paule32>
can i provide you the executable for alpha testing ?
<pjb>
Nope. I only take sources. (or their human and machine-readable serialized forms)
<paule32>
ok, i will make a zip
<razzy>
no-defun-allowed: i like your humour
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
<pjb>
paule32: it would be better to put it on github, and let us clone your repo.
<pjb>
paule32: because you will keep ask questions, in newer versions!
<no-defun-allowed>
Thankyou.
<White_Flame>
pjb: btw, #. #+ and #- are part of source code, but are not part of serialized "lisp source" as you refer to
<pjb>
White_Flame: only of the serialized form.
<White_Flame>
they don't serialize from sexprs
<pjb>
Of course, as everything in lisp, you have a lisp in the reader.
<White_Flame>
again, "serialization" implies an output to serialized form
<White_Flame>
from an internal form
<pjb>
Quoting serialized forms is done with " not with ' !
<White_Flame>
I would argue they are not serialized
<pjb>
White_Flame: you can look in com.informatimago, there are a few examples of serializing #. #+ #-
<White_Flame>
they're source
<White_Flame>
sure, you may have created sexpr-level constructs for those, but they aren't part of the lisp core
<White_Flame>
lisp source is text. lisp forms & expressions are conses & such
xrash has quit [Ping timeout: 272 seconds]
<pjb>
White_Flame: and furthermore, #+ #- are very problematic. Try to write a documentation generator on serialized forms full of #+ #-!
xrash has joined #lisp
<White_Flame>
(they're not serialized!)
<White_Flame>
serialized means there's some canonical object form that has been converted into a serial form
<White_Flame>
but the textual form IS the canonical input in the first place
<White_Flame>
true it is a "serial" format, but it is not "serialized" from any prior data structure
shka_ has quit [Ping timeout: 272 seconds]
dented42 has joined #lisp
dented42 has quit [Client Quit]
hitchhikingcoder has joined #lisp
aydio has quit [Quit: WeeChat 2.2]
dented42 has joined #lisp
<pjb>
White_Flame: this is what you're believing.
<pjb>
White_Flame: there's a data structure in your brain, and again, in com.informatimago and elsewhere, there's code to generate them!
<White_Flame>
there isn't a data structure in my brain, and even if there were, it's external to the lisp image, so the interface between is still the original source
<White_Flame>
and yes, tools to generate it fall into a turing tarpit argument
Guest25977 has joined #lisp
rtypo has joined #lisp
orivej has quit [Ping timeout: 252 seconds]
hitchhikingcoder has quit [Remote host closed the connection]