dilated_dinosaur has quit [Ping timeout: 246 seconds]
<defunkydrummer>
lotuseater: no, i mean, as far as i know it's not a binding to a C library, but it implements the X protocol 100% in Lisp
<defunkydrummer>
so it directly talks to the X server
<defunkydrummer>
just as, for example, there's a postgres driver for clsql that implements the protocol directly, doesn't need any postgres lib installed previously
<lotuseater>
ahh okay, that would be even better, but I don't know
<lotuseater>
but yes that would fit to the motto "Now proudly done with 100% less C"
<defunkydrummer>
exactly
Steeve has quit [Quit: end]
<defunkydrummer>
"the stuff boring dreams are made of"
<defunkydrummer>
well, gotta go
<defunkydrummer>
bye bye
defunkydrummer has quit [Quit: Leaving]
harlchen has quit [Quit: WeeChat 2.9]
tisskenzen has quit [Ping timeout: 240 seconds]
gxt__ has quit [Ping timeout: 240 seconds]
cantstanya has quit [Ping timeout: 240 seconds]
luckless has quit [Ping timeout: 240 seconds]
tamarindo has quit [Ping timeout: 240 seconds]
madage has quit [Ping timeout: 240 seconds]
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
hendursaga has quit [Ping timeout: 240 seconds]
<aeth>
lots of things are stable from the 90s
<aeth>
Windows probably has things last touched since then. Probably not entire files. They've probably run some automatic refactoring tool to change the header of the file or whatever.
<aeth>
s/last touched/not touched/
EvW has quit [Ping timeout: 258 seconds]
<lotuseater>
thanks to the standard specification!
<lotuseater>
ok I meant for CL stuff
<lotuseater>
aeth: and so some exploits for Windows NT kernel or so still have worked on XP/Vista/7/10 :D
luckless has joined #lisp
gxt__ has joined #lisp
<aeth>
I mean, as I've said before fairly recently here... CL shifts the burden of quite a few things onto the implementations.
hendursaga has joined #lisp
<aeth>
Most stuff doesn't ever really need updating because the implementations themselves (or, more rarely, various key libraries) handle such things instead.
Aurora_v_kosmose has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
cantstanya has joined #lisp
<lotuseater>
:)
judson_ has joined #lisp
jpli has quit [Quit: No Ping reply in 180 seconds.]
madage has joined #lisp
jpli has joined #lisp
phoe6_ has joined #lisp
frost-lab has joined #lisp
thmprover has joined #lisp
<lotuseater>
How do you usually start writing a binding or reimplementing something from scratch?
<thmprover>
Like Johnny Cash put it, one piece at a time.
<lotuseater>
yes you're right
ioa___ has joined #lisp
ioa___ has left #lisp [#lisp]
tisskenzen has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
judson_ has joined #lisp
judson_ has quit [Client Quit]
Jesin has quit [Quit: Leaving]
<aeth>
Find the smallest possible thing you could implement. Write it up as an issue in an issue tracker. Try to implement it. It'll take weeks/months because you could actually have picked a smaller increment.
<lotuseater>
and in PAIP one of the last chapters guides through how basic LOOP is implemented, but I must study it more in depth myself
<nij>
Thanks for the pointer to PAIP!
<nij>
Ok I will learn both.
<nij>
It's fun anyway.
<nij>
I just feel LOOP is little bit like DSL. But I came here for lisp's elegance.
<lotuseater>
yes it IS a DSL
<lotuseater>
same with FORMAT
<no-defun-allowed>
That is arguably part of the elegance.
<nij>
:(
<nij>
In a nutshell, how does iterate work?
<lotuseater>
hm, like LOOP but more lispy and extensible?
<lotuseater>
do a macroexpand on a simple LOOP expression and you'll see
<nij>
oh i mean
<nij>
does it work on first translating itself to LOOP?
<lotuseater>
no I don't think so, but maybe it could be
<nij>
Nvm I will look into that. Thanks :D
<lotuseater>
i don't see some call to LOOP in the source
wxie has joined #lisp
<nij>
Must be some other elegant twists.
* nij
is excited.
gasby has joined #lisp
gasby has left #lisp [#lisp]
<Xach>
elegance is not a design goal
<lotuseater>
it's efficiency and expressiveness, isn't it?
<lotuseater>
or am I now stucked in the LOOP? :D
judson_ has joined #lisp
<nij>
(loop (gtd (be-efficient)))
<nij>
(loop (feel-good (gtd (be-efficient))))
<nij>
Sorry..
<nij>
Yeah I hope one can achieve elegance + efficiency + expressiveness.
lucasb has quit [Quit: Connection closed for inactivity]
nij has quit [Ping timeout: 258 seconds]
jeosol has quit [Remote host closed the connection]
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life has joined #lisp
jpli has quit [Quit: No Ping reply in 180 seconds.]
rumbler31 has joined #lisp
jpli has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
zcheng3 has quit [Ping timeout: 258 seconds]
tisskenzen has left #lisp [#lisp]
devon has joined #lisp
semz has quit [Ping timeout: 260 seconds]
surabax has quit [Quit: Leaving]
Oladon has joined #lisp
semz has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
orivej has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
danielfar has joined #lisp
danielfar has left #lisp [#lisp]
karlosz has joined #lisp
jibanes has quit [Ping timeout: 264 seconds]
jibanes has joined #lisp
jeosol has joined #lisp
jpli has quit [Quit: No Ping reply in 180 seconds.]
jpli has joined #lisp
flip214 has quit [Ping timeout: 264 seconds]
flip214 has joined #lisp
jpli has quit [Quit: No Ping reply in 180 seconds.]
jpli has joined #lisp
madage has quit [Ping timeout: 240 seconds]
Stanley00 has joined #lisp
PuercoPop has joined #lisp
<PuercoPop>
lotuseater: It says 20 years ago because that is when they where committed to version control. The some code is even older
<thmprover>
Random question: where can I read more about readtables? I'm curious about understanding how it works exactly, I don't want to do anything with reader macros, just understand them deeper.
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
igemnace has quit [Ping timeout: 260 seconds]
<PuercoPop>
thmprover: you could checkout vacietis, which uses readtables to parse C into CL
<thmprover>
That's awesome!
<aeth>
PuercoPop: sometimes version control uses fake commits to provide the real date... I mean, that's basically what it has to be to some extent since 20 years ago predates git
<thmprover>
Also kind of amusing, because I'm tinkering around with implementing a toy lisp in C, and thinking about implementing a toy readtable is what prompted me to investigate this further.
<PuercoPop>
aeth: Yeah, but the first commit says something like checking in FOO's version into CVS iirc. Some code there has 1985 in the headers iirc
<lotuseater>
PuercoPop: yup, with another system
madage has joined #lisp
<aeth>
PuercoPop: heh, cvs
<aeth>
svn was quite the upgrade.
Alfr_ has joined #lisp
<aeth>
So I guess a lot of projects went cvs->svn->git, and that's only if they didn't pick some losing thing before git, e.g. hg
<lotuseater>
PuercoPop: does f2cl also work with readtables?
<beach>
Good morning everyone!
<PuercoPop>
lotuseater: sorry I'm not familiar with f2cl, what is it?
<thmprover>
Good morning, beach!
<lotuseater>
it translates Fortran77 code
<PuercoPop>
aeth: most (all?) of hu.dwim uses darcs to this day!
<aeth>
we need to rewrite distributed version control in Lisp
<lotuseater>
darcs is great. some guy once told me "too slow for managing things like linux kernel" blabla. but that is not what it's primarily for
<lotuseater>
aeth: with patches please
<aeth>
lotuseater: ah, so darcs doesn't *scale*
Alfr has quit [Ping timeout: 258 seconds]
<PuercoPop>
aeth: fiddlerwoaroof has started working on that!
<aeth>
lotuseater: you have to scale on the cloud to win
<lotuseater>
hm cloud
<lotuseater>
darcs has mathematical fundament
<PuercoPop>
lotuseater: the problem with darcs is that their worst case for resolving merge conflicts is n² iirc.
<lotuseater>
yes something like that was it
<aeth>
lotuseater: I was joking when I was talking about clouds. It's all about the edge computing blockchains for XR now. :-P
<lotuseater>
all this modern stuff :D
<lotuseater>
"Fundamentally good ideas are that which stand the test of time."
<lotuseater>
s/that/those
<aeth>
PuercoPop: is the project public yet?
<lotuseater>
one can also peek into pijul source
flip214 has quit [Ping timeout: 240 seconds]
judson_ has joined #lisp
flip214 has joined #lisp
<aeth>
I'd say that the big problem with git is that it's distributed, but the issues, the wiki, and so on live in essentially just a handful of places (Github, Gitlab, Bitbucket, etc. And mostly just Github.)
<PuercoPop>
aeth: git is only a version control system, not a 'project manager system'. Wiki, issues seem out of scope. But you can build those on top of the same object database. If everything is in CL it would be easier to do so, or at least nicer to write imho
galex-713 has quit [Ping timeout: 272 seconds]
shifty has joined #lisp
notzmv has quit [Remote host closed the connection]
galex-713 has joined #lisp
<lotuseater>
îs DEFINE-SETF-EXPANDER the same as DEFINE-SETF-METHOD?
<beach>
clhs define-setf-method
<specbot>
Couldn't find anything for define-setf-method.
<beach>
See, there is no such thing.
<lotuseater>
yes I know ;) but I read about that in PAIP
<no-defun-allowed>
I guess it was called DEFINE-SETF-METHOD before ANSI Common Lisp?
<lotuseater>
ah yes that would fit :) and it's said it is a quite tricky macro ^^
<mfiano>
What is the proper way to combine features with boolean logic to control the evaluation of the next form with reader conditionals? for example feature X and not feature Y
<no-defun-allowed>
Well, you can write #+(and x (not y)) (something), or is there something else you're thinking of?
<mfiano>
I infact did just that, but wasn't sure if the (not y) was going to behave as I'd expect.
<mfiano>
Thanks for the confirmation
narimiran has joined #lisp
<lotuseater>
you can build conditionals which will never work unless you push some keywords on your own to *FEATURES* :) something like #+(and linux windows)
<mfiano>
True, implementations may use any such symbols. But, we have trivial-features for that.
gzj has joined #lisp
<lotuseater>
as I got to know #+ and #- I first thought it expands the code into WHEN and UNLESS forms but because it doesn't even produces NIL for false forms you know it's really commented out
akoana has quit [Quit: leaving]
<lotuseater>
OK you have runtime in between for checking the membership of the keyword
rumbler31_ has quit [Ping timeout: 256 seconds]
<mfiano>
Every phase of the evaluation model can invoke any other. That's the main reason I have stayed with Lisp for 15 years. It allows for very interesting solutions to problems in my domain.
luckless has quit [Quit: luckless]
<lotuseater>
yes I know
Bike has quit [Quit: Lost terminal]
Oladon has quit [Quit: Leaving.]
aaaaaa has joined #lisp
<PuercoPop>
Is there a way to view/treat a multi-dimensional array as a sequence/vector? II want to use COUNT-IF on the array.
waleee-cl has quit [Quit: Connection closed for inactivity]
aartaka has joined #lisp
aartaka_d has joined #lisp
perrier-jouet has quit [Ping timeout: 260 seconds]
aartaka has quit [Ping timeout: 260 seconds]
PuercoPop has quit [Remote host closed the connection]
aartaka_d has quit [Ping timeout: 260 seconds]
aartaka has joined #lisp
mrchampion has quit [Read error: Connection reset by peer]
perrier-jouet has joined #lisp
aartaka has quit [Ping timeout: 256 seconds]
_whitelogger has joined #lisp
aartaka_d has joined #lisp
phantomics has quit [Quit: Ex-Chat]
aartaka has quit [Ping timeout: 258 seconds]
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
aartaka has quit [Ping timeout: 258 seconds]
Lord_of_Life has quit [Changing host]
Lord_of_Life has joined #lisp
aartaka has joined #lisp
aartaka_d has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
aartaka has quit [Ping timeout: 256 seconds]
ebrasca has joined #lisp
sgibber2018 has quit [Quit: WeeChat 2.9]
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
jibanes has quit [Ping timeout: 258 seconds]
jibanes has joined #lisp
<phoe>
morning
<no-defun-allowed>
Hello phoe.
<beach>
Hey phoe.
<phoe>
hi hey
infosec_yo has joined #lisp
<infosec_yo>
i think lisp is bloated.
<lotuseater>
ok and now?
<no-defun-allowed>
Too bad.
<infosec_yo>
its also insecure.
thmprover has quit [Quit: Goodnight, ladies, good night, sweet ladies, good night, good night]
<flip214>
infosec_yo: any more opinions we should know?
<flip214>
you'll excuse if our experience differs.
<infosec_yo>
when is lisp getting deprecated ?
infosec_yo was banned on #lisp by phoe [*!*sid476935@gateway/web/irccloud.com/x-ezccxoibyygulirl]
infosec_yo was kicked from #lisp by phoe [infosec_yo]
<phoe>
please carry on
<flip214>
not enough patience lately, phoe?
<flip214>
;)
<lotuseater>
thx phoe
<no-defun-allowed>
Aw, I was thinking of a retort, but "when is your big mouth getting deprecated" is a bit poor.
<phoe>
flip214: I kinda recognize the person.
<phoe>
they used to post the "lisp sucks" quality content from webchats multiple times before.
<lotuseater>
i think phoe ran out of patience with such bloated people since recently
<phoe>
and as for patience, well. I think you know everything.
<flip214>
I guess you just saved me quite a bit of time
<flip214>
that I'll now use for me tel conferences ;/
<phoe>
ha, yes
<flip214>
no, I don't know everything.... but I can guess that small detail
<phoe>
flip214: so you know everything enough
<lotuseater>
maybe infosec_yo is one of those self-claimed experts with unlimited knowledge too
<flip214>
If you know all you see your horizon might be too near
<Nilby>
I'm pretty sure that's someone who's been trolling Lisp communities for like 20 years, saying "lisp is dead", etc. It's funny that there's still something to troll then.
norserob has joined #lisp
<lotuseater>
there's always more to learn, even for a master
<phoe>
the issue is that (foo :bar 2 :bar 3 :bar 4) is a well-formed plist
<phoe>
I mean, uhh, s/is/contains/
<jackdaniel>
interesting, thanks for this information
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<luis>
phoe: that tip seems PSA-worthy
<phoe>
luis: I can blog about it sure thing
amb007 has joined #lisp
<phoe>
or, uhhhh. maybe not. I'll pass and leave it to some other person because blogging in my current state of mind is dangerous.
* Nilby
has probably never been in a "not dangerous to blog" state of mind.
nij has joined #lisp
GZJ0X_ has quit [Remote host closed the connection]
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
GZJ0X_ has joined #lisp
Bike has joined #lisp
cosimone has joined #lisp
rixard has joined #lisp
rixard_ has quit [Read error: Connection reset by peer]
cosimone has quit [Quit: cosimone]
OlCe has quit [Remote host closed the connection]
OlCe has joined #lisp
<luis>
phoe: I can review the blog post if you'd like or I could take the opportunity to blog for the first time in 2 years or so
jibanes has quit [Ping timeout: 256 seconds]
<jackdaniel>
luis: do it! take the opportunity
<jackdaniel>
maybe you'll warm up and then you'll write something about cffi or slime :-)
<phoe>
luis: please take it
<phoe>
I need to find a new blogging platform because movim screws up code blocks even years after I highlighted it to them.
<luis>
I'm surprised Google hasn't killed Blogger yet.
<luis>
Must still be a source of AdSense revenew.
jibanes has joined #lisp
aaaaaa has quit [Quit: leaving]
jibanes has quit [Ping timeout: 258 seconds]
jibanes has joined #lisp
jibanes has quit [Ping timeout: 240 seconds]
nij has left #lisp ["ERC (IRC client for Emacs 27.1)"]
jibanes has joined #lisp
FennecCode has quit [Quit: IRCNow and Forever!]
jeosol has joined #lisp
frost-lab has quit [Quit: Connection closed]
orivej has quit [Ping timeout: 256 seconds]
troydm has joined #lisp
FennecCode has joined #lisp
lotuseater has quit [Ping timeout: 240 seconds]
ljavorsk_ has quit [Remote host closed the connection]
ljavorsk has joined #lisp
liberliver has quit [Quit: liberliver]
iskander has quit [Ping timeout: 256 seconds]
Lycurgus has quit [Quit: Exeunt]
igemnace has quit [Remote host closed the connection]
wsinatra has joined #lisp
gzj has quit [Remote host closed the connection]
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
gzj has joined #lisp
EvW has joined #lisp
mrchampion has joined #lisp
liberliver has joined #lisp
gxt__ has joined #lisp
scymtym has quit [Read error: Connection reset by peer]
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
harlchen has joined #lisp
<devon>
Howdy Lispers, how best to adapt a Scheme program to run in Common Lisp?
<phoe>
devon: depends on the Scheme program
<phoe>
how large is it?
<phoe>
what language features does it use?
waleee-cl has joined #lisp
<devon>
Smallish and probably no Lisp1/2 issues.
<phoe>
call/cc?
<beach>
devon: It also depends on whether you want the result to just work, or whether you also want it to be maintainable as Common Lisp.
<devon>
Unlikely. The result should be maintainable CL code.
<phoe>
then just rewrite all DEFINEs to be DEFUNs and DEFVARs/DEFPARAMETERs and either adjust function names to CL or define your own mini-scheme-like environment.
<aeth>
You can progressively rewrite it if you do the latter, i.e. running a Scheme environment inside of CL.
<devon>
I'm amazed I can't find a tool for this.
<aeth>
I mean.
GZJ0X_ has quit [Remote host closed the connection]
gzj has quit [Remote host closed the connection]
<phoe>
a tool for automatic rewriting? I don't think there can exist one
GZJ0X_ has joined #lisp
gzj has joined #lisp
<phoe>
mostly because of lisp-1/lisp-2 issues and because of lack of continuations in CL.
<phoe>
you could get a compiler from scheme to CL, and this is what aeth will write about in a few seconds.
GZJ0X_ has quit [Remote host closed the connection]
gzj has quit [Remote host closed the connection]
<aeth>
The problem is that compiling Scheme to CL in a semantics-preserving way isn't just going to MACROEXPAND-1 you idiomatic CL.
gzj has joined #lisp
GZJ0X_ has joined #lisp
<phoe>
scheme and CL are only similar because of the parentheses and common operator name; they have different paradigms under the hood and this is what simple source translation is going to miss.
GZJ0X_ has quit [Remote host closed the connection]
gzj has quit [Remote host closed the connection]
<aeth>
There's only really two runtime incompatabilities. CL doesn't guarantee tail recursion to be optimized, while Scheme does, meaning that Scheme's idiomatic iteration relies on it while in CL it's implementation-specific, and even then relying on OPTIMIZE levels.
<devon>
LOL, sure. Punt in the face of call/cc, xref all the names to help resolve any Lisp1/2 issues, define ⟶ either defvar or defun, not too hairy.
<aeth>
And, of course, continuations, but if the program doesn't contain call/cc, then there doesn't have to be special handling.
<aeth>
And technically, both of these are "runtime-incompatabilities" only if you wanted to generate idiomatic CL.
<aeth>
Since you can emulate these without an interpreter.
nij has joined #lisp
<Bike>
so all you need to redo is the entire macro system, local and nonlocal flow control, and call syntax
<Bike>
so easy
<devon>
LOL, that's why I'm asking.
<edgar-rft>
In my experience the main problem is that in Scheme only the core language is specified, there exist many Scheme implementations that's code doesn't run on other Scheme implementations. This means thet you always have to look what Scheme implementation the code was written for.
<aeth>
Bike: On the one hand, it's < 10,000 lines of code. On the other, it's < 10,000 lines of code of Common Lisp and Scheme, not C.
<Bike>
the standard libraries are also different, scheme has its "ports" or whatever instead of streams, record types instead of structs, etc...
<Bike>
oh, and scheme programs may try to distinguish the empty list and false.
eden has joined #lisp
<aeth>
Well, (car nil) is an error in Scheme, so even CAR needs to be different. But the standard libraries mostly just have minor incompatabilities like that. You could in theory do it all at the macro level instead of defining trivial functions, but it wouldn't really give you much.
<Bike>
it's nice to be optimistic
<aeth>
#f is absolutely a good point because your Scheme program will reverse every IF to look like (if* (eq condition #f) false-path true-path) instead of (if condition true-path false-path)
<devon>
Perhaps the grass only looks greener an the Scheme side but I sense Scheme libraries are fewer but better, having glanced at an API or so.
nij has quit [Ping timeout: 258 seconds]
defunkydrummer has quit [Ping timeout: 260 seconds]
scymtym has joined #lisp
<aeth>
devon: Well, the left-pads only come later. The initial libraries of any language are all important.
<devon>
The original Scheme was implemented in MacLisp, very close to Common Lisp, e.g., RABBIT by GLS IIRC.
wsinatra has quit [Read error: Connection reset by peer]
<aeth>
And, more recently, there was Pseudoscheme for, I think, r4rs
wsinatra has joined #lisp
<aeth>
Although it was only pseudo because it didn't actually address all of the interesting incompatabilities, which have only grown since then.
<devon>
So nobody's heard of any more recent effort, not in QL anyway. I'll start with C-M-% and see how it goes.
<aeth>
For instance, #f vs nil used to just be a recommendation. Same with case-sensitivity (which you can technically do in your Scheme-in-CL, if you want to have to CAPITALIZE every foreign CL call) and even hygienic macros, which iirc were an appendix in r4rs.
<aeth>
devon: I've heard of a more recent effort, but it's not going to be useful for you if you have any deadline because it's incomplete.
<devon>
LOL, well, cool, no deadline, please tell me more.
<aeth>
I would've linked to it earlier, but I was hoping that Bike would elaborate more on why the task was impossible rather than just calling me optimistic.
andreyorst has joined #lisp
<devon>
For this particular wee chunk of code, probably easy.
<phoe>
his greatest contribution to Common Lisp library ecosystem
ebrasca has quit [Remote host closed the connection]
<aeth>
devon: If there's a Scheme library that you want to run, the best thing to do would be to run it via Airship Scheme when it's ready, so you don't have to worry about translating it. Or, if it's code, librarify it.
gko_ has quit [Ping timeout: 260 seconds]
hal99999 has joined #lisp
jibanes has quit [Ping timeout: 246 seconds]
<luis>
phoe: "left-pad is the perfect example of the new frontier of software engineering." nice
<phoe>
luis: the most important package on the Internet
<phoe>
remove it, and half of the world's software stops building!
jibanes has joined #lisp
<phoe>
;; /s
tmf has joined #lisp
<Nilby>
t-l-p is so flawlessly executed with almost no hint of sarcasm.
<devon>
Hmm, incompatible syntax… (define 2p⟵Invalid numerical syntax. [Condition of type AIRSHIP-SCHEME::SCHEME-READER-ERROR]
<aeth>
devon: chibi-scheme behaves the same way
<devon>
My vague sense of unease was not the Airship-Scheme code but skipping breakfast.
<aeth>
The issue is that R6RS specifies exactly what's an invalid number and what's a symbol. That is, 2p is invalid. Whereas R7RS leaves it up to the implementation.
<aeth>
On the other hand, both Racket and CL are a lot more lenient and permit '2p
<aeth>
(although it looks like SBCL prints '2p as |2P| so it escapes the output, but doesn't require it for the input)
Cymew has quit [Ping timeout: 256 seconds]
<lotuseater>
typing '2p gives |2P|
<lotuseater>
oh you were faster :)
notzmv has joined #lisp
nij has joined #lisp
random-nick has joined #lisp
<devon>
If R7RS affords the option, I'll make it configurable.
<aeth>
Airship Scheme can't use the host CL's reader for this because its symbol-vs-number syntax is different (e.g. Scheme has complex syntax for its complex numbers, and it has a literal infnan) and because it uses a hack to get compatible symbols.
<aeth>
It manually inverts the (hopefully just non-Unicode) case to read car as CAR and then print it back out again it as car (which as to be non-Unicode, or at least not fully Unicode, to be reversible).
<aeth>
s/which as/which has/
<devon>
We're stuck with #C(0 1) instead of 0+1i
eden has quit [Remote host closed the connection]
defunkydrummer has joined #lisp
<jackdaniel>
#i2+3 ;)
<aeth>
The thing is, 2p isn't a problematic symbol. 2389748939023.0e34p is a problematic symbol.
<aeth>
My guess is both CLs and Racket have to build both the symbol string and the number in parallel. Or they build a string and then read it into a number. Neither are necessary if you don't permit such things.
<aeth>
jackdaniel: sorry, #i is for infix
<jackdaniel>
not in my readtable ^_^
<jackdaniel>
in my readtable #i is not defined
<aeth>
jackdaniel: next thing you're going to tell me is that you don't have a #h reader macro for hash tables, either :o
<jackdaniel>
that's correct!
<aeth>
do you even reader macro?
<jackdaniel>
sure, #l(list 'literal-lambda %1), but only in repl
<aeth>
devon: In case you're wondering, I'm taking a week off from Airship Scheme now that the reader is standard (oh no, it has been a week now!) before attempting to fix the continuation passing style stuff (which will eventually provide if, lambda, and a hardcoded, inelegant define). The reader is R7RS standard, not CL standard.
<aeth>
I guess in the long run I could make it bilingual CL/Scheme, at least as an option, with a handful of exceptions, like the custom case inversion instead of case upcasing.
<aeth>
It seems like a lot of work, though, so it wouldn't be a plan for 1.0
shifty has quit [Ping timeout: 272 seconds]
shifty has joined #lisp
<aeth>
Maybe I could switch symbols to using an invert readtable case instead of manually doing it. The implementation does guarantee that it must be done in pairs (and thus can't be Unicode), which might be good enough. http://www.lispworks.com/documentation/HyperSpec/Body/13_adcd.htm
<phoe>
this part of CLHS is incompatible with unicode
<aeth>
It still has the problem of when something is a number in Scheme, but not in CL.
<aeth>
phoe: And it's the correct decision because it's the only thing that makes :invert possible.
<aeth>
Unicode case can't apply to characters, only to strings. The various issues in one line of non-portable SBCL: (values (sb-unicode:uppercase "ß") (sb-unicode:uppercase "i") (sb-unicode:uppercase "i" :locale :tr) (sb-unicode:lowercase (sb-unicode:uppercase "ς")))
<aeth>
The only issue is that sb-unicode is, well, sb-unicode. Someone needs to make it portable because the equivalents aren't as good.
drl has joined #lisp
<mfiano>
Did you know SBCL's reader also asciifies unicode?
<aeth>
By the way, the R7RS-small version of Scheme does it the wrong way, and tries to use full Unicode case algorithms on characters, which means that #\ß cannot possibly have a good upcase.
<mfiano>
(I'm not happy about that btw)
<aeth>
mfiano: Well, depending on what you mean, I guess I can't just assume that I can just use the implementation's :invert when it isn't a potential number, then.
<mfiano>
(char (symbol-name 'foo²) 3) => #\2
<aeth>
Not like it would be that good of a solution, anyway, since +foo+ is read as a potential number thanks to the + and a slight incompatability between my manual case-invert for '+foo+ vs. the implementation's :invert for 'foo+ would be really confusing
shifty has quit [Ping timeout: 265 seconds]
<aeth>
or, in this case, I guess +foo²+ vs. foo²+
nij has left #lisp ["ERC (IRC client for Emacs 27.1)"]
toorevitimirp has quit [Remote host closed the connection]
<lotuseater>
i now think to try writing some dump readmacro with three components
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
<lotuseater>
Nilby: oh this is what *READ-INTERN* is for, never used it yet
<aeth>
So I guess if I want a bilingual reader I'm going to have to reinvent readtable case (to implement my own :invert) and have my own, incompatible readtable concept.
<aeth>
Alternatively, I guess that I could use the implementation's readtable; get the readtable case from it, using the READTABLE-CASE accessor; and then manually do symbol reading based on that information.
<aeth>
All of these are questions that I don't really want to deal with before I even have the basic, standards-compliant Scheme running, though.
<Nilby>
Darn. I forgot you guys don't have *read-intern* yet. You could substitute a set of #\0 - #\9 number reader macros, but it's quite a bit more involved.
<lotuseater>
yes now I see it's not part of the standard :D never mind
<aeth>
But it creates an intermediate symbol, I think?
<aeth>
This can be problematic, although it's technically case-insensitive in Scheme so supporting both 4+i and 4+I wouldn't be incompatible
<Nilby>
*read-intern* is a function the reader calles to intern symbols. it gets passed a string
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
<Nilby>
I mean you wouldn't want to do this for real, e.g. ppcre:split is a bit heavy for a reader thing.
<Nilby>
I don't see where it creates an intermediate symbol.
<aeth>
There's probably a bunch of reader macro magic that can do exactly what I want to do (with the major issue being the semantics of certain things like mfiano's example in SBCL), but I went down that route for the initial cl-scheme (from which only standard-procedures.lisp survives) and even just doing #t and #f was hard.
<aeth>
(In that particular case, that's because they're dispatch reader macros, and that means you get to handle things like #43t. Additionally, balancing parentheses with them is a nightmare.)
<aeth>
Nilby: An intermediate string is still more than what I do. I go character-by-character and don't need to build up a string at all, except for symbols and, obviously, strings.
bendersteed has quit [Ping timeout: 258 seconds]
hiroaki has quit [Ping timeout: 256 seconds]
<Nilby>
aeth: That is quite sensible. I was just seeing how to do it for fun.
<aeth>
An advantage of our number system over Roman numerals is that you can just parse things character-by-character.
<aeth>
Parsing "IV" vs. "III" where the "I" means two different things is something that I guess could be done, but by the time you handle all of that type of syntax, you might as well just use cl-ppcre on a string
<lotuseater>
how do i catch the numarg in a dispatch macro character?
<lotuseater>
aeth: yes Romans weren't as good at math, maybe just for building stuff
<aeth>
The Romans had surprisingly advanced math that they stole from the Greeks, including a proto-calculus. This sort of thing didn't go away until centuries after the start of the empire. Everything's much harder with the wrong notation, though. Everything.
<beach>
lotuseater: It's the argument of the dispatch function.
<lotuseater>
ah hm alright
<lotuseater>
normally i do (lambda (stream char1 char2) ...) or something
<beach>
Let me see if I can find the information...
<aeth>
There are three things in notation that really changed everything in a simplifying way that really could have come up at any time in history. Arabic numerals (with positional digits), algebra (using a bunch of letters instead of prose), and s-expressions (perfectly regular syntax instead of a mix of prefix/postfix/infix/etc. in the two-dimensional (because of e.g. fractions) language of written mathematics).
<beach>
lotuseater: Last sentence of next-to-last paragraph.
<lotuseater>
ah so it's written that the reader after reading the dispatch char reads in an integer as long as the second char shows up?
<beach>
"The reader macro function associated with the sub-character C2 is invoked with three arguments: the stream, the sub-character C2, and the infix parameter P.
<beach>
lotuseater: Something like that, yes.
<beach>
Either way, the infix parameter is passed as the last argument to the dispatch function.
jibanes has quit [Ping timeout: 240 seconds]
<Nilby>
But Babylonian numbers are positional and almost homoiconic. But I love that I can do this (format t "~36r" #36rfizzle)
jibanes has joined #lisp
jibanes has quit [Ping timeout: 240 seconds]
jibanes has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
<lotuseater>
Nilby: i once did (setq *read-base* 36) and then i everything got messy :D
<Nilby>
lotuseater: Nice. That should be in a "code your way out of this" challenge.
<Nilby>
Another fun "code your way out of this" is (delete-package :cl).
<lotuseater>
yes a friend was over, we got laughing very much but didn't achieve it
<lotuseater>
he is not a lisper but recognizes and respects the power of it
<Nilby>
I wonder if there's any other language where you can do something like set *read-base*
<lotuseater>
hm sparely i think
<Nilby>
It seems like it's use is for reading data.
<lotuseater>
i have a package with functions to transform integers to base i-1 (#c(-1 1)), in default *READ-BASE* is limited to bases 2-36 but that's good so
<lotuseater>
yes you should change read-base just in lexical scopes
<lotuseater>
beach: ah yes now i recognize again, lambda lists for dispatch readmacros in Let over Lambda have (stream sub-char numarg)
judson_ has joined #lisp
Blukunfando has joined #lisp
<Alfr_>
lotuseater, (|SETF| |*READ-BASE*| a) will do the trick.
drl has quit [Quit: Leaving]
<lotuseater>
thx Alfr_ :)
drl has joined #lisp
<lotuseater>
hm if i do normal stuff after that it's stuck in base 36 o_O
<Nilby>
or #10r10 in case someone did (setf *read-base* (random 37))
<jasom>
Nilby: or just 10.
EvW has joined #lisp
<Nilby>
jasom: That doesn't seem to work.
<Alfr_>
jasom, in read-base > 10, "10" would be read to an integer with value read-base, not decimal 10.
aeth has quit [Ping timeout: 240 seconds]
<jasom>
Not "10" "10."
<beach>
lotuseater: So it works?
<Alfr_>
That should work. Nice to be reminded of the one notation I really dislike. :D
<Nilby>
Sorry, I read . as period not decimal_point
aeth has joined #lisp
<jasom>
reasonable confuse
<jasom>
*confusion
<Nilby>
I strive for reasonableness in my confusion. :)
<jasom>
I assume the "." suffix is why there is #b #x #o but not #d
froggey has quit [Remote host closed the connection]
dbotton has joined #lisp
<lotuseater>
beach: no not entirely the way expected or hoped to :)
jibanes has quit [Ping timeout: 240 seconds]
froggey has joined #lisp
jibanes has joined #lisp
banjomet has joined #lisp
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
orivej has joined #lisp
<dbotton>
Is there a way to have a non dynamic defvar? (Ie a true global in the c sense)
Fare has quit [Ping timeout: 258 seconds]
skapata has joined #lisp
<phoe>
dbotton: yes
<phoe>
(ql:quickload :global-vars)
<phoe>
this defines a global lexical variable
<dbotton>
Usable between threads?
<phoe>
AFAIK yes
<dbotton>
Great thanks
aeth has quit [Ping timeout: 260 seconds]
aeth has joined #lisp
hnOsmium0001 has joined #lisp
jibanes has quit [Ping timeout: 256 seconds]
jibanes has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
rumbler31_ has joined #lisp
jonatack has quit [Ping timeout: 240 seconds]
jibanes has quit [Ping timeout: 264 seconds]
lotuseater has quit [Ping timeout: 264 seconds]
jibanes has joined #lisp
aartaka has joined #lisp
andreyorst has joined #lisp
aartaka_d has quit [Ping timeout: 256 seconds]
mbomba has joined #lisp
jibanes has quit [Ping timeout: 240 seconds]
matryoshka has quit [Ping timeout: 272 seconds]
jibanes has joined #lisp
narimiran has joined #lisp
shifty has joined #lisp
eden has joined #lisp
matryoshka has joined #lisp
gzj has joined #lisp
jibanes has quit [Ping timeout: 260 seconds]
matryoshka has quit [Client Quit]
jibanes has joined #lisp
matryoshka has joined #lisp
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
shifty has quit [Ping timeout: 256 seconds]
EvW has quit [Ping timeout: 260 seconds]
jibanes has quit [Ping timeout: 260 seconds]
jibanes has joined #lisp
jonatack has joined #lisp
nij has joined #lisp
<nij>
Does anyone here have extensive experiences with both cl and clojure?
nij has left #lisp [#lisp]
nij has joined #lisp
<nij>
Uh internet got cut out. Not sure if my message went out..
<jackdaniel>
I can denounce a few people, but I'm not sure if they are willing to be denounced ,)
<jackdaniel>
it went
<nij>
Oh
<defunkydrummer>
nij: Uh oh, the clojure versus common lisp debate again...
<nij>
Ok.. I just hope to get some comparison between them.
<jackdaniel>
not really versus, just overlapping experience
<nij>
defunkydrummer: no I had not experience with clojure.
<defunkydrummer>
nij: you can search the r/Lisp reddit, because the comparisons between CL and clojure have been done many times over and over again
<nij>
defunkydrummer: that sounds like a legit approach.
hiroaki has joined #lisp
<nij>
Ok! Then I won't toxic this place xD
<defunkydrummer>
nij: suffice to say, i don't like benevolent dictators in my language, i like having many fully-featured implementations, and Java libs should be optional, not entangled within the language. Thus, i choose Common Lisp
<defunkydrummer>
nij: and if you need to interact between lisp and java libraries, there's a common lisp implementation called "Armed Bear Common Lisp" (ABCL) that lets you call java libs very easily; a piece of cake. So this isn't an advantage that is exclusive to Clojure.
jibanes has quit [Ping timeout: 256 seconds]
<defunkydrummer>
nij: additionally, most or all the clever constructs for functional programming/etc are also available on common lisp by simply importing libraries, so no big deal either
<jackdaniel>
that resembles comparison I've heard in the past: clojure is an opinionated language (it helps the programmer to do the right thing, while the right thing is defiend by the clojure designer opinion), while common lisp gives you a large toolbox and lets you hang yourself
<jackdaniel>
(so it is up to the programmer to execute their opinions)
<defunkydrummer>
jackdaniel: Hooray for euthanasia!
<jackdaniel>
that's not what I meant of course :_)
<nij>
Yeah I get cl is great and minimal in that sense.
<nij>
But on the other hand, I also worry the size of the community.
jibanes has joined #lisp
<nij>
jackdaniel: How about Scheme?
X-Scale` has joined #lisp
<nij>
I've heard that Scheme is more minimal than common lisp.
<jackdaniel>
if you like lego it shoudl be fine
<nij>
Does it make Scheme even less opinionated?
<jackdaniel>
I need to spend now some time with my family, so I'm going afk
<defunkydrummer>
nij: size of the community is a plus. We know each other and we support each other in brotherly love, infinte kindness, and expansive wisdom.
<nij>
xD
<jackdaniel>
I'd say that scheme is opinionated: functional programming, purity, sterile macros etc
<defunkydrummer>
nij: scheme is a great language. Used to be small but with the latest scheme spec it might not be so small today
<jackdaniel>
that said, it is offtopic here :)
<jackdaniel>
have a good evening \o
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` is now known as X-Scale
<defunkydrummer>
nij: common lisp used to be known as a very "big" language but only because it included a standard library within the language. When you compare it to the standard libraries of Python (which are part of the language as well), CL isn't big anymore. Yet its essentials provide more than what Python brings to the table, just to pick a lanugage for comparison.
jonatack has quit [Read error: Connection reset by peer]
<nij>
I see.
<defunkydrummer>
nij: in 1984, when CL was defined in a book, languages didn't come with any big standard library, only minimal stuff. CL was one of the first "battery-included" languages
<nij>
I find myself caring less and less about minimalism as I grow :(((((
<defunkydrummer>
nij: good growth
jibanes has quit [Ping timeout: 240 seconds]
<defunkydrummer>
nij: sometimes languages are designed minimal because this makes the implementation/compiler be easy to write. Those lazy compiler writers!!
<nij>
Then shouldn't I choose clojure then? I like lisp for its expressiveness.. and clojure has that too.
<phoe>
nij: that's good
<defunkydrummer>
nij: so the lazyness of compiler writers become extra effort for the everyday developer, the common man
<phoe>
clojure, compared to CL, is paradigmatically challenged
<phoe>
mostly because it has a pretty strict functional paradigm
aindilis` has joined #lisp
aindilis has quit [Ping timeout: 258 seconds]
<nij>
phoe: would you elaborate?
<defunkydrummer>
nij: Common Lisp is a very hard language to implement. Because it has a lot of powerful features. E
<phoe>
that's what makes it troublesome for me to write Clojure, I can't bend the language to my needs very easily. I can force myself to write functional code, it's just that I can't do it in the "mostly functional" style that I'm used to - where most of the code is functional and I use HOFs but I also have imperative logic, either in OO-like core or in mostly-functional but internally imperative functions
<nij>
phoe: it forces your code to be very functional?
<phoe>
nij: clojure? yes
<nij>
What are some bread and butter in cl that's not allowed in clojure, as an example?
<phoe>
CLOS
<phoe>
SETF
<nij>
Jeez.
<phoe>
reader macros ain't bread and butter but still
<defunkydrummer>
nij: and, some useful features for interactive programming. That are absent in clojure.
<phoe>
did clojure backtraces become any good now?
<ck_>
phoe: no
<defunkydrummer>
phoe: well, clojure has reader macros, but you're very limited in your choice of characters you can bind a reader macro to... The reader macro character has to start with #, if i recall correctly. Which is a big limitation!
jibanes has joined #lisp
<phoe>
defunkydrummer: TIL! I thought they were completely erased from the language, I think I mentioned Rich saying that sometime
<phoe>
oh right
<phoe>
a condition system!
<defunkydrummer>
lol
<ck_>
phoe: but you just implemented that in Java
<phoe>
it doesn't have a condition system, just dumb Java exceptions
<defunkydrummer>
nah, but nobody needs a condition system...
<phoe>
ck_: yes, but not in Clojure
<phoe>
I didn't say it's impossible to implement
<phoe>
I said that Clojure considered it unnecessary
<ck_>
"not allowed in Clojure" was, I thought, the question you were asking
<defunkydrummer>
nij: the CL condition system is an awesome feature of CL. So awesome, some people even write books about it. And publish them on Apres.
<ck_>
since Clojure is a Java library technically, your implementation allows it
<phoe>
ck_: no, more like, which features of CL are not present in Clojure
<phoe>
there is a condition system available as a library for Clojure but that's still kinda eh
<ck_>
phoe: s/asking/answering/ sorry
<phoe>
but yes, it's possible to get a condition system in Clojure as a Java library; clojure macros would even make the syntax bearable!
<phoe>
.....I actually need to do that sometime
<ck_>
anyway I'd like to add to the list: the Clojure printer doesn't resolve circular structure
<nij>
ok......... how about JVM? I know little about it. My impression is that JVM is inevitable to deal with in "practical jobs". Can CL deal with it nicely?
<ck_>
nij: there's ABCL
<varjag>
jvm is legacy now
<Nilby>
JVM is by no means inevitable.
<ck_>
I don't know about 'nicely' though.. and also what you mean by "practical jobs"
<defunkydrummer>
nij: tons of practical jobs outside the jvm. The JVM is just a virtual machine. A big part of the computer servers and programs right now on the internet are NOT running on the jvm.
<defunkydrummer>
nij: for example the two most popular programming languages right now are Python and Javascript, and both have zero thing to do with the JVM
<varjag>
containerization killed vms
<defunkydrummer>
nij: That being said, the JVM is a virtual machine that runs Java bytecode and in this task it is extremely efficient. So it is a very good virtual machine, with very good garbage collectors, optimizations, etc. Good stuff.
<phoe>
defunkydrummer: "some people even write books about it"
<phoe>
touche
<ck_>
phoe: you should check it out
<phoe>
OK, I will.
<defunkydrummer>
phoe: and some people even buy those books!!
<phoe>
defunkydrummer: madmen
<defunkydrummer>
phoe: oh please don't get me started on my doctoral thesis: "Insanity in the Common Lisp Ecosystem"
<Nilby>
lol
<phoe>
defunkydrummer: I am both curious and scared of this thesis
<phoe>
let's discuss it, but on #lispcafe
jibanes has quit [Ping timeout: 240 seconds]
<defunkydrummer>
nij: But clojure isn't a bad language when you compare with other popular languages like Python. Compared to most popular languages, it's good stuff. Very good stuff. However when compared with common lisp, there are things that are missed.
<nij>
lol
<phoe>
no, that's serious
jibanes has joined #lisp
<Nilby>
"10 signs you may have caught a Lisp related mental illness"
<defunkydrummer>
LOL
jibanes has quit [Ping timeout: 246 seconds]
jonatack has joined #lisp
jibanes has joined #lisp
eta has quit [Ping timeout: 260 seconds]
<defunkydrummer>
nij: I think it's very good that Clojure exists, because it has been a source of some ideas that then were implemented afterwards into Common Lisp.
<ck_>
I agree, arrows are good for example
<nij>
Arrows? As the arrows in haskell?
<defunkydrummer>
nij: also, it gives companies where using Common Lisp scares the managers, an alternative to use some of the power of lisp without shocking anybody
<nij>
defunkydrummer: this is uplifting.
<defunkydrummer>
nij: i'd leave the arrow work to the indians. They know how to use them well.
<ck_>
nij: Clojure calls them "threading macros", -> and ->> are thread-first and thread-last
* nij
wants LISP TO SPREAD!
<defunkydrummer>
nij: lisp isn't butter or margarine
<ck_>
nij: it is spreading and has for a long time. The influences are far and wide
<ck_>
defunkydrummer: I can't believe it's not butter!
<nij>
ck_: I want parenthesis to spread!
<defunkydrummer>
nik: yeah, lisp influences are very very strong into Python, javascript... the most popular languages right now
<phoe>
nij: arrows as in Clojure
<phoe>
arrow macros, also known as threading macros.
<defunkydrummer>
phoe: i'd leave the threading work to the tailors. They know how to thread those tiny threads well.
<phoe>
you should be able to understand the basic mechanism of how they are supposed to work from that.
<defunkydrummer>
phoe: and by the way let's leave the channel work to the civil engineers
<phoe>
defunkydrummer: channel work? what do you mean
<defunkydrummer>
phoe: i'm doing a pun on threads, channels and other concurrent constructs
<phoe>
:D
<defunkydrummer>
:/
<phoe>
I understand now
<nij>
Besides threadings, are there other inspiring notions?
<curiouscain>
:^)
<phoe>
sorry, I'm still a bit tired
<defunkydrummer>
phoe: i see...
<nij>
reducers and transducers? (I'm still reading about them)
<defunkydrummer>
leave the transducers to the electronic engineers
<defunkydrummer>
nij: the problem is, Clojure introduces some slang for things that are better known by other names. I'd say this adds unnecessary difficulty
<nij>
oh oh ok.
<ck_>
oh yes .. in a way it is a good thing that Common Lisp has no single figure at the head of the organization
<defunkydrummer>
nij: to put a simple example, on ALL lisps except Clojure, the ATOM is exactly the same concept in all those lisps. Not in Clojure. :S
<nij>
I'm just curious. This is not particular about clojure.
<nij>
I would like to collect many powerful "utilities".
<nij>
(Like monads.)
<nij>
(in mathematics.)
eta has joined #lisp
<defunkydrummer>
ooohh we have a HASKELLER here!!
<harlchen>
>>=
* defunkydrummer
presses the red button
* nij
kicks himself out!
<phoe>
monads in CL don't really work
<nij>
no no no no no
<nij>
I don't mean monad in haskell sense.
<phoe>
ooooh
<nij>
I mean the mathematical concept.. is really great.
<nij>
(well at the end they are the same thing)
<nij>
It's a notion that captures lots of thoughts in a slick way.
<defunkydrummer>
nij: and now that we're at it, let's also leave the purity for the chemists
<nij>
If you know about cohomology.. you'd appreciate more.
<nij>
ok so besides threading.. what can I learn more?
<defunkydrummer>
nij: and let's leave the "lazy evaluation" to careless teachers
<defunkydrummer>
nij: i'm just joking while I wait for my food to arrive
<nij>
loll
<defunkydrummer>
nij: a nice introductory book to Common Lisp is "Practical Common Lisp" which can be read for free online. Which is a proof that Lispers are nice people.
<nij>
haha
<phoe>
defunkydrummer: hah
<nij>
defunkydrummer: plz. Are there more slick notions that are nice to learn?
<phoe>
slick notions, you mean syntax tricks?
<nij>
Those that help you express yourself in a slicker way.
<defunkydrummer>
Common Lisp: The language for Nice People (Trademark)
<ck_>
paip is online now as well, isn't it
<phoe>
Gentle is online, too
<defunkydrummer>
ck_: i don't know... but that's a GREAT book
<phoe>
it's good especially for people who have not programmed much
<phoe>
and it starts from the very very beginning, so, hmmmmm
<defunkydrummer>
nij: Take note: Paradigms In Artificial Programming: Case studies in Common Lisp, by Peter Seibel
<phoe>
nij: if you're a mathematician, and you want to get to the bottom of all things, I wonder if you could benefit from gentle
<defunkydrummer>
minion: tell nij about PAIP
<minion>
nij: PAIP: Paradigms of Artificial Intelligence Programming. More about Common Lisp than Artificial Intelligence. Now freely available at https://github.com/norvig/paip-lisp
<phoe>
minion: tell nij about gentle
<minion>
nij: please look at gentle: "Common Lisp: A Gentle Introduction to Symbolic Computation" is a smoother introduction to lisp programming. http://www.cs.cmu.edu/~dst/LispBook/
<defunkydrummer>
minion: tell nij about life, the universe and everything
<nij>
PAIP yes the huge book
<minion>
nij: you speak nonsense
<defunkydrummer>
lol
<ck_>
:o
<phoe>
minion: wait what
<minion>
watch out, you'll make krystof angry
<phoe>
oh shit I never thought I'd see the way when minion gets aggressive
<phoe>
s/way/day/
<defunkydrummer>
nij: PAIP may be huge but it's rich in content, great book. Peter seibel is the director of AI research at Google!
dbotton has joined #lisp
<defunkydrummer>
minion: will you help me in spearheading the nascent movement to make Common Lisp a top 5 programming language by 2040? I believe this is eminently achievable given proper approaches.
<phoe>
okay defunkydrummer I think it might be time to calm down a bit
<defunkydrummer>
sorry dad
<phoe>
no problem son
<nij>
loll
<phoe>
let's just not abuse minion too much. it might be sentient.
<defunkydrummer>
i got carried away by the emotion of trolling minion
<defunkydrummer>
well back at clojure
<phoe>
and the last thing you want is a sentient bot who knows who you are and what is your IP address.
<ck_>
are you (eval-when '(:compile-toplevel))'ing yet, son?
<defunkydrummer>
i congratulate every developer that chooses clojure over many other languages. It's a step forward. A stepping stone for the Real Deal, the Uncut Lisp
<defunkydrummer>
ck_: wait, i'm your son too as well?
<phoe>
defunkydrummer: well, Java was originally a stepping stone for Lisp... it kinda worked
* defunkydrummer
is atreyu -- son of the people
* phoe
gently nudges the familial relationships to #lispcafe
* defunkydrummer
goes away to the lisp coffeeshop
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
lotuseater has joined #lisp
nij has left #lisp ["ERC (IRC client for Emacs 27.1)"]
<defunkydrummer>
bij: I hope you can read PAIP or PCL and get a good idea of how to use the language. I'd say PCL is an easier read
<defunkydrummer>
nij; sorry, NIJ not BIJ
imode has joined #lisp
<defunkydrummer>
nij: there are many books of course.
<lotuseater>
but not just so many all of them are very good
<lotuseater>
sry, without NOT
<lotuseater>
look at how much dozens of bad books for other stuff is out there
housel has quit [Ping timeout: 256 seconds]
olle has joined #lisp
EvW has joined #lisp
ggole has quit [Quit: Leaving]
andreyorst has quit [Ping timeout: 240 seconds]
rixard has quit [Read error: Connection reset by peer]
rixard has joined #lisp
aeth has quit [Ping timeout: 264 seconds]
aeth has joined #lisp
Steeve has joined #lisp
rgherdt has quit [Remote host closed the connection]
aindilis` has quit [Remote host closed the connection]
aindilis has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
judson_ has joined #lisp
<scymtym>
mfiano: i don't whether this was said already, but after (setf (sb-ext:readtable-normalization *readtable*) nil) you get (char (symbol-name 'foo²) 3) => #\SUPERSCRIPT_TWO
orivej has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
<scymtym>
*don't know
mrchampion has quit [Ping timeout: 240 seconds]
mrchampion has joined #lisp
nij has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
<lotuseater>
no, I'm German, but mathematicians names must be written correct :)
<ane>
heh, did you know it should be written Erdős, not Erdös
<defunkydrummer>
according to the lisp demographics, german might as well be the #2 official language of the Lisp community
<lotuseater>
yes I meant that but don't have it in my layout. in TeX you can do \def\erdos{Erd\H os}
<ane>
ö is a letter in its own right, by adding the acute accent to a hungarian vowel like á makes it a loong vowel. so, ö has its long variant, ő
<lotuseater>
defunkydrummer: oh cool, but not in companies using it
<lotuseater>
yes it's something like plural for status, i think in latin it's u declination, so becomes u with bar on top
<ane>
but I agree with you, Erdös is good, Erdos is not
<lotuseater>
for here it's totally ok
<lotuseater>
but sorry i didn't want to go offtopic, have no lisp question atm
rumbler31_ has joined #lisp
drl has quit [Quit: Leaving]
rumbler31_ has quit [Ping timeout: 258 seconds]
shka_ has quit [Ping timeout: 265 seconds]
jibanes has quit [Ping timeout: 256 seconds]
wsinatra has quit [Ping timeout: 258 seconds]
vaporatorius__ has joined #lisp
vaporatorius has quit [Read error: Connection reset by peer]
jibanes has joined #lisp
rumbler31_ has joined #lisp
Fare has joined #lisp
hal99999 has quit [Ping timeout: 240 seconds]
gaqwas has quit [Ping timeout: 240 seconds]
rumbler31_ has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 260 seconds]
akoana has joined #lisp
PuercoPop has joined #lisp
rumbler31_ has joined #lisp
bjorkint0sh has quit [Quit: Leaving]
Nilby has quit [Read error: Connection reset by peer]
surabax has quit [Quit: Leaving]
noobineer has quit [Ping timeout: 265 seconds]
mokulus has joined #lisp
scymtym has joined #lisp
noobineer has joined #lisp
olle has quit [Ping timeout: 256 seconds]
zulu-inuoe_ has quit [Read error: Connection reset by peer]
jibanes has quit [Ping timeout: 256 seconds]
jibanes has joined #lisp
Steeve has quit [Quit: end]
Fare has quit [Ping timeout: 260 seconds]
hal99999 has joined #lisp
ebrasca has joined #lisp
gxt__ has quit [Quit: WeeChat 2.9]
jibanes has quit [Ping timeout: 264 seconds]
jibanes has joined #lisp
jcd has quit [Remote host closed the connection]
sjl has quit [Ping timeout: 260 seconds]
hal99999 has quit [Quit: hal99999]
pve has quit [Quit: leaving]
ape666 has joined #lisp
ape666 has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 260 seconds]
<lotuseater>
I wonder how complex it would be writing a game engine like that for Cyberpunk 2077 in CL :)
mokulus has quit [Ping timeout: 246 seconds]
jibanes has quit [Ping timeout: 260 seconds]
galex-713 has quit [Ping timeout: 258 seconds]
ape666 has joined #lisp
<White_Flame>
lotuseater: I don't know how much metaprogramming goes into one of those, as it appears it's a custom engine from cdpr, but lisp could be relatively simpler to write
<White_Flame>
but of course, much of the work would be getting a smooth frame rate and foiling garbage collection being triggered
jibanes has joined #lisp
aartaka_d has joined #lisp
frgo_ has quit []
<lotuseater>
White_Flame: yes it's custom
aartaka has quit [Ping timeout: 260 seconds]
harlchen has quit [Quit: WeeChat 2.9]
rumbler31_ has quit [Ping timeout: 258 seconds]
galex-713 has joined #lisp
<lotuseater>
John Carmack once has rewritten the wolfenstein3d engine in haskell, but I don't know how to do that stuff in lisp :( maybe combined with CEPL?
<no-defun-allowed>
It would have used some 2d library to be a "faithful" port, as it did its own rasterization/raycasting, no?
EvW has joined #lisp
<lotuseater>
ehm you ask questions :D
jibanes has quit [Ping timeout: 272 seconds]
jibanes has joined #lisp
roelj has quit [Remote host closed the connection]
<White_Flame>
wolf3d was just a simple 8-bit framebuffer
<White_Flame>
software renderer
jibanes has quit [Ping timeout: 272 seconds]
<lotuseater>
the prototype for DOOM ^^ "Mein Leben!"
jibanes has joined #lisp
<aeth>
They didn't have hardware rendering on PC until Quake 1, and even then they couldn't assume that everyone would have it so they had to ship parallel software renderers for some time, e.g. Half-Life 1 in late 1998 iirc.
<aeth>
(HL1 isn't an Id game, it's a Valve game, but it's based on Id's Quake engine)
galex-713 has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
<lotuseater>
ah cool to know
<saturn2>
if you were going to write game engine that elaborate in lisp it would probably be worth your time to extend your lisp implementation with arena-based memory management
<Xach>
quake 3 arena memory management?
natter has quit [Remote host closed the connection]
<lotuseater>
saturn2: can you explain a little further plz?