quazimodo has quit [Remote host closed the connection]
borei has joined #lisp
quazimodo has joined #lisp
elderK has quit [Quit: WeeChat 2.8]
stux|RC-- has joined #lisp
stux|RC has quit [Ping timeout: 256 seconds]
Ekho has quit [Ping timeout: 256 seconds]
Ekho- has joined #lisp
Ekho- is now known as Ekho
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 240 seconds]
edgar-rft has quit [Quit: Leaving]
userself has quit [*.net *.split]
fwoaroof[m] has quit [*.net *.split]
cairn has quit [*.net *.split]
physpi has quit [*.net *.split]
mgsk has quit [*.net *.split]
johs has quit [*.net *.split]
saturn2 has quit [*.net *.split]
terrorjack has quit [*.net *.split]
drmeister has quit [*.net *.split]
billstclair has quit [*.net *.split]
parisienne___ has quit [*.net *.split]
chewbranca has quit [*.net *.split]
fowlduck has quit [*.net *.split]
gendl has quit [*.net *.split]
ski has quit [*.net *.split]
yang has quit [*.net *.split]
asedeno has quit [*.net *.split]
cross has quit [*.net *.split]
banjiewen has quit [*.net *.split]
selwyn has quit [*.net *.split]
shymega has quit [*.net *.split]
mgsk has joined #lisp
banjiewen has joined #lisp
shymega has joined #lisp
saturn2 has joined #lisp
fwoaroof[m] has joined #lisp
userself has joined #lisp
physpi has joined #lisp
terrorjack has joined #lisp
cairn has joined #lisp
billstclair has joined #lisp
drmeister has joined #lisp
chewbranca has joined #lisp
parisienne___ has joined #lisp
johs has joined #lisp
gendl has joined #lisp
yang has joined #lisp
fowlduck has joined #lisp
asedeno has joined #lisp
ski has joined #lisp
cross has joined #lisp
selwyn has joined #lisp
yang has quit [Max SendQ exceeded]
MindForeverVoyag has joined #lisp
yang has joined #lisp
liamz[m] has quit [Remote host closed the connection]
kelamir[m] has quit [Write error: Connection reset by peer]
katco has quit [Write error: Connection reset by peer]
deselby has quit [Remote host closed the connection]
camlriot42 has quit [Remote host closed the connection]
cairn has quit [Read error: Connection reset by peer]
fwoaroof[m] has quit [Write error: Connection reset by peer]
userself has quit [Read error: Connection reset by peer]
gaqwas[m] has quit [Read error: Connection reset by peer]
infra_red[m] has quit [Remote host closed the connection]
kinope has quit [Remote host closed the connection]
sammich has quit [Read error: Connection reset by peer]
even4void[m] has quit [Write error: Connection reset by peer]
unl0ckd has quit [Read error: Connection reset by peer]
Gnuxie[m] has quit [Remote host closed the connection]
MrtnDk[m] has quit [Write error: Connection reset by peer]
LdBeth has quit [Remote host closed the connection]
fountainpen[m] has quit [Remote host closed the connection]
notzmv has quit [Ping timeout: 246 seconds]
terrorjack has quit [Ping timeout: 244 seconds]
natter has quit [Ping timeout: 264 seconds]
Lycurgus has joined #lisp
cross has quit [Ping timeout: 244 seconds]
cross has joined #lisp
terrorjack has joined #lisp
Gnuxie[m] has joined #lisp
notzmv has joined #lisp
<coltkirk>
im watching the little bits of lisp now and, taking really close notes
ralt has quit [Quit: Connection closed for inactivity]
karlosz has quit [Remote host closed the connection]
shangul has joined #lisp
Lycurgus has quit [Remote host closed the connection]
ahungry has joined #lisp
stux|RC-- has quit [Quit: Aloha!]
stux|RC has joined #lisp
sammich has joined #lisp
userself has joined #lisp
even4void[m] has joined #lisp
infra_red[m] has joined #lisp
cairn has joined #lisp
kinope has joined #lisp
kelamir[m] has joined #lisp
katco has joined #lisp
camlriot42 has joined #lisp
fwoaroof[m] has joined #lisp
gaqwas[m] has joined #lisp
unl0ckd has joined #lisp
MrtnDk[m] has joined #lisp
LdBeth has joined #lisp
fountainpen[m] has joined #lisp
deselby has joined #lisp
liamz[m] has joined #lisp
orivej has quit [Ping timeout: 244 seconds]
orivej has joined #lisp
karlosz has joined #lisp
MindForeverVoyag has quit [Remote host closed the connection]
MindForeverVoyag has joined #lisp
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
Alfr_ has quit [Quit: Leaving]
orivej has quit [Ping timeout: 240 seconds]
karlosz has quit [Remote host closed the connection]
mindCrime has quit [Ping timeout: 244 seconds]
shangul has quit [Remote host closed the connection]
shangul has joined #lisp
jgodbou has joined #lisp
orivej has joined #lisp
Fare has quit [Ping timeout: 246 seconds]
mindCrime has joined #lisp
mrcom has quit [Read error: Connection reset by peer]
mrcom has joined #lisp
Fare has joined #lisp
Bike has quit [Quit: Lost terminal]
Oladon has joined #lisp
Posterdati has quit [Ping timeout: 256 seconds]
Alfr has joined #lisp
Posterdati has joined #lisp
<coltkirk>
i really like Baggers, I can tell he's well spoken and passionate about lisp
space_otter has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
orivej_ has joined #lisp
<beach>
Good morning everyone!
<fwoaroof[m]>
good morning, beach
<borei>
hi beach
<borei>
question - should i expect that function performance generated by macro will be the same like performance of the function created in normal way ?
<fwoaroof[m]>
borei: a macro just transforms the input source code to a different shape
<fwoaroof[m]>
There's no difference between typing out the result of macroexpansion and using a macro
torbo has quit [Remote host closed the connection]
<fwoaroof[m]>
(performance-wise, at least)
<borei>
i was thinking the same, but macro generated function is 40% slower then standard one
<borei>
oh, one thing - generated by macro is actually closure
<beach>
If it is not the same code, performance can obviously be different.
Lord_of_Life has quit [Ping timeout: 256 seconds]
<beach>
But it has nothing to do with the macro.
<borei>
my first suspect is that macro generated function is accessing to variable defined in the "let"
<fwoaroof[m]>
Is it also possible that accessing the closed over state affects performance?
<fwoaroof[m]>
(I know non-local variable access can have a significant performance impact in python)
<beach>
Accessing closed-over variables can be slower. It depends on the compiler and how those variables are used.
<fwoaroof[m]>
I suspected that: in python, it's something like local variables are looked up by indexing into an array, global variables are looked up in a hash-map
<fwoaroof[m]>
I assume a good CL compiler is a bit smarter than this, though
<aeth>
Well, it's more complicated in CL because only dynamic/special variables or constants are portably global, although other globals might exist.
<beach>
fwoaroof[m]: But a closed-over variable is not global.
<beach>
For special variables, you can have deep binding or shallow binding. With shallow binding, and if your implementation uses threads, each variable has a current-value slot, probably in the reified thread object. With deep binding, you have to search the dynamic environment for the latest binding.
<beach>
But the closed-over variable is not special either.
<beach>
The global value of a special variable (which is shared among all threads) a typical implementation has a slot in the symbol for it.
orivej has joined #lisp
orivej_ has quit [Ping timeout: 264 seconds]
<fwoaroof[m]>
Sorry, I meant "non-local" variables
<beach>
A closed-over variable becomes part of the static environment of the function. And the static environment is passed as an implicit argument to the function. In the worst case, the value would then be kept inside a "cell" in the static environment. So you have two memory accesses to reach it, whereas an argument may be passed in a register.
<beach>
But if the closed-over variable is not assigned to after creation, the cell can be avoided.
<beach>
And the compiler can pass the static environment in different ways to avoid some overhead.
<beach>
Does that make sense?
<fwoaroof[m]>
yeah
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
<borei>
my brain is about to explode
<fwoaroof[m]>
A read-only variable in the static environment could also be inlined, right?
zigpaw has quit [Ping timeout: 256 seconds]
<beach>
That's not enough of a criterion.
<beach>
Imagine (defun f (x) (lambda (y) (+ x y)))
<beach>
Here, you can have a different x for each closure created by a call to f.
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
<beach>
So even though x is read-only, it is not the same each time in the anonymous function.
bhartrihari has joined #lisp
<beach>
Therefore, it has to be looked up in the static environment.
<beach>
Once it has been accessed there, it can be put in a register of course, if that is what you mean.
<fwoaroof[m]>
I see
<fwoaroof[m]>
I don't think I was thinking clearly enough: I was thinking that, in some cases you could transform the inner lambda to something like (lambda (y) (+ 1 y))
<beach>
That would be possible only if you have something like (let ((x 1)) (lambda (y) (+ x y)))
<beach>
But that would be a very unusual situation.
<fwoaroof[m]>
Yeah, you'd have to do it after calling f
zigpaw has joined #lisp
<beach>
borei: Why?
cosimone_ has joined #lisp
<borei>
don't know, looks like im missing something very fundamental, and without it i can build full picture
cosimone has quit [Ping timeout: 246 seconds]
<borei>
im looking at the macroexpand now - main and biggest difference is how function is accessing "nodes" array
<borei>
in first case - it's just function parameter (should be just pointer)
<borei>
in second case - it's not parameter, and it's not local for the function var, so it need to looked up at higher level. higher level is "let"
<beach>
Yes, the static environment like I said.
<borei>
and based on the timing that lookup is very expensive
<beach>
Yes, like I said.
<borei>
is there an option to make that nodes variable "like local" for the function defined in macro ?
<borei>
hmm, but that is not option in terms of performance because i need to call "let" every time
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
cosimone_ is now known as cosimone
bhartrihari has joined #lisp
<borei>
that is pretty cool things - whisper of the waves
CrazyEddy has joined #lisp
Oladon has joined #lisp
<fwoaroof[m]>
borei: maybe try putting the let inside the defun?
<fwoaroof[m]>
It's not equivalent in every case, but I think it will work for your code.
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
<borei>
correct me if im wrong - let creates lexical scope - is it correct ?
<fwoaroof[m]>
Yes
<fwoaroof[m]>
Well, sort of: it binds variables
<fwoaroof[m]>
Whether or not the binding is a lexical binding depends on whether the variable has been declared special
narimiran has joined #lisp
<borei>
so with every call it will be creating lexical scope, then destroy it. i did try it yesterday. maybe was using it wrong, but result was even wors
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
mangul has joined #lisp
OpenZen has quit [Ping timeout: 240 seconds]
shangul has quit [Ping timeout: 264 seconds]
<fwoaroof[m]>
Cool, I guess you have to decide whether the performance is worth the cost of passing an extra argument around
<fwoaroof[m]>
I'm not an expert at optimizing CL, though: there maybe some way of putting a LET inside the DEFUN and then declaring nodes DYNAMIC-EXTENT to get some more speed
<fwoaroof[m]>
However, I don't really understand that declaration :)
Lycurgus has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
<borei>
actually discussion was pretty useful for me, now i understand why im getting a bit better performance introducing one more function - it allows to reduce number of lookups to static environment.
<beach>
If some object is not passed as an argument, it has to be stored somewhere in the function object, or in a place that is accessible to the code of the function. That access requires a memory access. I don't see how you can get around this.
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
<borei>
i had some illusion about lexical scope.
<beach>
I guess I should act upon the suggestion of doing a series of presentations for the online Lisp meeting, with the subject how a Common Lisp compiler works.
<fwoaroof[m]>
I just need to sit down and write a compiler for a subset of lisp
<fwoaroof[m]>
It's the sort of thing that I understand best just working through the problems
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
cosimone_ has joined #lisp
cosimone has quit [Ping timeout: 256 seconds]
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
FreeBirdLjj has joined #lisp
gravicappa has joined #lisp
cosimone_ has quit [Quit: Quit.]
niceplaces has joined #lisp
niceplace has quit [Ping timeout: 240 seconds]
Lycurgus has quit [Remote host closed the connection]
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
bhartrihari has joined #lisp
<beach>
In my opinion, programmers need to know about compiler design. Not so much in order to create fast code, but in order to avoid guessing what the compiler will do, and in the process, making their code less maintainable. But there are cases, like this one, where such knowledge is needed for creating fast code.
bhartrihari has left #lisp ["Disconnected: closed"]
technobean has joined #lisp
RedMallet has quit [Ping timeout: 240 seconds]
RedMallet has joined #lisp
mokulus has joined #lisp
ofi has joined #lisp
ofi has quit [Client Quit]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
seok38 has quit [Remote host closed the connection]
madage has quit [Remote host closed the connection]
madage has joined #lisp
diamondbond has quit [Ping timeout: 260 seconds]
technobean has quit [Quit: ERC (IRC client for Emacs 26.2)]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
ebrasca has joined #lisp
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
random-nick has joined #lisp
sunwukong has quit [Ping timeout: 240 seconds]
rogersm has joined #lisp
jonatack has quit [Ping timeout: 244 seconds]
shifty has quit [Ping timeout: 244 seconds]
<p_l>
fwoaroof[m]: dynamic-extent doesn't have to be respected, but generally it's suggestion that it's similar to stack allocation, so it's less of a speed optimization and more space optimization
<p_l>
non-consing code also tends to keep to function arguments and return values a lot, but to be honest when looking for that I'
<p_l>
I'd keep profiler handy ;)
philadendrite has quit [Quit: Leaving]
technobean has joined #lisp
gxt has joined #lisp
Josh_2`` has quit [Remote host closed the connection]
Josh_2 has joined #lisp
jeosol has quit [Remote host closed the connection]
jeosol has joined #lisp
sunwukong has joined #lisp
v88m has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
bhartrihari has joined #lisp
drdee has joined #lisp
shidima has joined #lisp
shidima has quit [Quit: leaving]
<Josh_2>
Good afternoon
shidima has joined #lisp
space_otter has quit [Remote host closed the connection]
ljavorsk has quit [Ping timeout: 260 seconds]
drdee has quit [Quit: Leaving]
narimiran has quit [Ping timeout: 264 seconds]
Bike has joined #lisp
Frobozz has joined #lisp
orivej has joined #lisp
Frobozz has quit [Quit: quit]
<Josh_2>
hmm I have a minor problem. Im trying to create my CLIM interface for an app, and all of the output is sent to *standard-output*, however I guess the backend is going to have to run in a different thread and I will have to override the default value of *standard-output* to be a different output stream so I can display the content in a different pane. Is it going to be safe for me to read from the stream on one thread and write on
flazh1 has quit [Quit: flazh1]
<Josh_2>
another without using a lock?? or am I gonna have to go replace all of my instances of format with one that grabs a lock first?
<Josh_2>
I wish to run the backend with or without my CLIM interface, so I don't want to go messing with it all that much
flazh has joined #lisp
<Bike>
if it came down to that you could just have a stream object that handles locking itself, probably, so the rest of your code wouldn't have to change
jonatack has quit [Ping timeout: 246 seconds]
orivej has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
* phoe
thinks of a world in which SIGNAL automatically placed a MUFFLE restart around the signaling site for all non-serious-conditions that would work in the same way as MUFFLE-WARNING does for warnings
<Bike>
what would that do?
<phoe>
a standard means of shortcircuiting signal handling
<phoe>
basically, "ok, I took care of this, I don't want any outer signal handlers to execute, please carry on with the standard execution flow"
<phoe>
I mean, it's trivial to write a SIGNAL* function that does exactly this, but a short discussion with someone on the Dylan condition system sparked this thought in my head
<phoe>
I don't remember if it was ioa or someone else, but I think it was #lispcafe
<jackdaniel>
Josh_2: if you use the *standard-output* from inside the display function, then you are not accessing the it from "foreign" thread
* phoe
adds it to the idea bin for the Hypothetical Future Revision™
<jackdaniel>
generally using streams asynchronously from a different thread is risky at best (i.e CCL signals an error)
<jackdaniel>
currently McCLIM streams are *not* thread safe, however I have plans to change that by scheduling asynchronous operations as events, which will be later "properly" handled in the stream-specific thread when dequeued
orivej has quit [Ping timeout: 256 seconds]
<Josh_2>
jackdaniel: well I am not using *standard-output* I have my own output-stream I have created as a slot on my frame which I wish to use in place of *standard-output* with (let ((*standard-output* output-stream ... etc
orivej_ has joined #lisp
<jackdaniel>
Josh_2: you may always define a method frame-standard-output
<jackdaniel>
specialized on your frame and returning "your" stream
OpenZen has quit [Remote host closed the connection]
lookasas has joined #lisp
Lycurgus has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
mokulus has quit [Ping timeout: 246 seconds]
justache has quit [Remote host closed the connection]
bhartrihari has joined #lisp
justache has joined #lisp
diamondbond has quit [Ping timeout: 244 seconds]
jonatack has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
arbv has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
liberliver has quit [Quit: liberliver]
kaftejiman has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
contrapunctus has left #lisp [#lisp]
contrapunctus has joined #lisp
bhartrihari has joined #lisp
bhartrihari has left #lisp [#lisp]
bhartrihari has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
mokulus has joined #lisp
rogersm has joined #lisp
rogersm has quit [Quit: Leaving...]
Codaraxis has joined #lisp
bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
orivej has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
remexre has joined #lisp
treflip has quit [Quit: WeeChat 2.6]
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
elxbarbosa has quit [Remote host closed the connection]
<phoe>
KMP has implemented a condition system in Python to convert Pythonists to the round side of the force
<phoe>
and the best thing is that I'll likely convince him to talk on OLM on the topic
<phoe>
hmmmmmmm
<fe[nl]ix>
that
<fe[nl]ix>
is wonderful
<fe[nl]ix>
:)
<phoe>
that is 1200% wonderful
bhartrihari has joined #lisp
<phoe>
your average programmer doesn't speak Lisp but they very likely speak Python to *some* extent
<phoe>
so, hey, here's SIGNAL, here's conditions, and handlers, and restarts, and the debugger
gaa has joined #lisp
<phoe>
I'm waiting for him to publish the sources so I can try and be the first one to post it on /r/Lisp
* phoe
is excited
lavaflow has quit [Ping timeout: 246 seconds]
ebrasca has quit [Remote host closed the connection]
abhixec has joined #lisp
<jackdaniel>
isn't it just another feature from Lisp cross-polluting to other languages? I mean - when people encounter the garbage collector they don't think "wow lisp", they think "wow java"
<phoe>
obviously it is
<jackdaniel>
(or anonymous function or whatever has been adopted in X language; I don't understand excitement, unless you are happy that python will improve because you are a python programmer)
<jackdaniel>
because [for instance] you are *
<phoe>
sure, I like hearing about this kind of stuff where nice ideas migrate into wider ecosystems
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<fe[nl]ix>
jackdaniel: you mean cross-pollinating ?
<jackdaniel>
yes, thanks for the correction
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
v88m has joined #lisp
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
sunwukong has quit [Ping timeout: 240 seconds]
lavaflow has joined #lisp
diamondbond has joined #lisp
orivej has quit [Quit: No Ping reply in 180 seconds.]
orivej has joined #lisp
narimiran has joined #lisp
dominic34 has quit [Ping timeout: 256 seconds]
Lycurgus has quit [Remote host closed the connection]
ayuce has quit [Remote host closed the connection]
<mfiano>
now you can still use COUNTING, what the synonym points to
cosimone has joined #lisp
<dlowe>
clause synonyms are a loop feature I could happily done without
shifty has quit [Ping timeout: 256 seconds]
<flip214>
mfiano: ah, thanks, good to know!
<flip214>
but that might interfere with other libraries' use of ITERATE, sadly
jw4 has quit [Read error: Connection reset by peer]
jw4 has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
jw4 has joined #lisp
Fare has quit [Ping timeout: 260 seconds]
<Alfr>
Should it be there in the first place? From iterate's manual section 2.3: "However, when there is a conflict with Common Lisp, only the present-participle form may be used (e.g. unioning). This is to prevent iterate clauses from clashing with Common Lisp functions."
<mfiano>
It should not. There was an SO answer about this question recently that suggested reporting a bug to either update the documentation, or deleting the synonym. I'm unsure if that was ever realized though.
Fare has joined #lisp
<Alfr>
Getting rid of that in the docs would be bad, that would then also make reduce harder to access and maybe also other things.
<mfiano>
"I've sent a bug repot to the mailing list and cc'd you. Thanks for explaining this to me!". So it has been reported, but you know how it goes with a lot of Lisp libraries. Bus factor of 1 or less.
diamondbond has quit [Remote host closed the connection]
diamondbond has joined #lisp
<Alfr>
mfiano, it's not that lispers don't know how to fix it, but more that it's (at least to me) unclear whether it's still actively maintained. Of course, apart from this and the documented limitations which boils down to the need of a better code walker, I've never noticed it to break, i.e. not much maintenance required.
<phoe>
> unclear whether it's still actively maintained
<mfiano>
That was what I implied by "bus factor of 1 or less"
wsinatra_ has joined #lisp
wsinatra has quit [Quit: WeeChat 2.9]
<Alfr>
mfiano, we wouldn't lose the ability to maintain it, if he/she got hit by a bus ... were we to know that fact.
<phoe>
I guess that us lispers kinda grew used to life with the fact that we live on big piles of Heisenberg-abandoned code that gets unburied and refreshed now and then when it's necessary
<Alfr>
Hm ... that sounds a little morbid. :/
<phoe>
there are notable exceptions and lively projects
gaqwas has quit [Remote host closed the connection]
<phoe>
but there's a ton of code that just stopped getting commits at some point of time
<mfiano>
It's both a blessing and a curse for Lisp.
<phoe>
this isn't strictly about Lisp, but it's definitely visible in the Lisp community because there's few people in the community in general compared to languages considered mainstream nowadays
<Alfr>
phoe, which also implies that such code is quite stable and usable.
<mfiano>
A blessing, because Lisp being as flexible and expressive as it is, allows a single developer to mold the language to their domain. After all, code is just a projection of ones' own mind.
<phoe>
Alfr: yes, that's the part that mfiano called a "blessing" up above
<phoe>
but then imagine that you do finally find a bug in there
<phoe>
and when you find a bug
<phoe>
who you gonna call?
<Alfr>
phoe, some libraries also are at some point "finished" as in having implemented all they purport to do.
<mfiano>
So it's no wonder why Lispers don't work together that well. It's often easier to express ideas suitable for themself rather than conform to someone elses'.
<phoe>
SHARP-LISPERS
* phoe
hides for the teerrible pun
kaftejiman has quit [Remote host closed the connection]
<mfiano>
"finished" is a funny term to use for software.
<Alfr>
phoe, fork locally and change it should I really need that change, but usually I'll just work around it; especially when it's something as commonly used as iterate.
<Alfr>
mfiano, I'd be also quite reluctant to publicly fork a repo just for what I deem to be a bug.
<mfiano>
Software is finished when it does what it intends to do correctly, and without any bugs. But the number of bugs is proportional to the number of users, and their funny input and use-cases. If you ever think you're "finished", just (incf *users*).
<aeth>
ITERATE is commonly used? I haven't really seen it in use and I've tried to use it before, but it has this sort of uncanny valley effect where it's close enough to LOOP that I come to it with my LOOP expectations, but different enough that few of those LOOP expectations work, making it a library that's not very easy to use ime.
<phoe>
Alfr: so basically you don't push it upstream
<phoe>
if you do this instinctively then I can imagine there's other people who do the same because it's impossible to effectively update an upstream project that has no maintainer
abhixec has quit [Ping timeout: 264 seconds]
<Alfr>
phoe, if I can establish contact w/ maintainers and they say that they'll accept changes, I do.
toorevitimirp has quit [Remote host closed the connection]
<phoe>
Alfr: then such a project is not unmaintained
<Alfr>
phoe, but in my experience I sometimes simply can't even reach them.
<phoe>
see several fukamachiware projects which have had open PRs and issues for months if not years; even though the author is active and the projects are commonly used, they are effectively abandoned because no one maintains them
toorevitimirp has joined #lisp
<phoe>
I use them as examples because they're both prominent in their popularity and notorious for their almost-working-ness and impenetrable code
<mrcom>
Iterate also has some issues with type declarations, and it would be nice to get rid of the reader macros (messes up source-code location tracking in SLY--general SBCL issue?).
<mfiano>
Yes, fukamachiware is notorious for being unmaintained with an active developer.
cosimone has quit [Remote host closed the connection]
<phoe>
and that's actually something achievementworthy
<phoe>
I mean, it's not trivial
<Alfr>
aeth, maybe it's just me using it all over the place, I guess I really like iterate for having less ordering requirements for its clauses.
cosimone has joined #lisp
<mfiano>
I have years-old issues there. I couple years ago I just decided to refuse to use any of them because of it. They simply do not work as intended for my use-cases, and the coding style is painful for me to patch myself without taking too much time away from problems higher up on my list.
<mfiano>
It'd be easier to rewrite myself. That's back to the "blessing" above.
<phoe>
mfiano: issues with what exactly?
<aeth>
heh, I have some issues from me from 2 years ago in my own game engine :-p
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
<mfiano>
clack, sxql, datafly, cl-dbi, to name a few. Show-stopper bugs that made me write my own things, though I do not do much web development these days anymore, anyway.
<aeth>
(And if I was more consistent about using issues in my game engine, I'd probably have several dozen issues dating back 4 years.)
<phoe>
oh, yes
<phoe>
that's the "mostly working" part
<phoe>
it works until you want to actually use it for something nontrivial
<phoe>
and then you try to figure out what has broken
<aeth>
I'd argue most libraries are in that state
<phoe>
sure, but some of them are redeemable, e.g. by being maintained and/or maintainable
<phoe>
fukamachiware is famous for being neither
<mfiano>
and are maintained with forethought instead of retrofitting features and bug fixes.
narimiran has quit [Ping timeout: 265 seconds]
theseb has quit [Quit: Leaving]
cosimone_ has joined #lisp
<phoe>
that's the third one
<phoe>
I can agree with that
<phoe>
so I have a question then
<mfiano>
I don't mean to sound so critical of other peoples' work. It's just that one of the major reasons I use CL is because it's easier to sculpt things myself with regard for my particular domain.
<phoe>
do we lack the people to fix that state of matters? do we lack the organization? do we lack discipline or money or what
<aeth>
money
cosimone has quit [Ping timeout: 260 seconds]
niceplace has quit [Ping timeout: 260 seconds]
<aeth>
e.g. the popular web libraries in other languages are usually well-maintained because people use them professionally
<mfiano>
I think we lack the desire, because of the ease of rolling your own and bending the language to your own thought processes.
tristero has joined #lisp
niceplace has joined #lisp
<mfiano>
Lisp is the lone wolf's language, which again, is a blessing and a curse.
<phoe>
aeth: I don't think it's the issue with money, I don't think the average or median of wealth and/or incomes is on the poor side when it comes to lispers
<phoe>
I was thinking that we could collectively organize something if we really wanted to
<phoe>
and the "if we really wanted to" kinda brings us back to the question I asked
<mfiano>
I think the issue is the "really wanted to" part
orivej_ has joined #lisp
MindForeverVoyag has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 240 seconds]
<phoe>
then again mfiano's answer is not really an answer in my opinion, because it's more than possible to write software collectively in Lisp and there's dozens of examples of that, and it's possible to write software that is maintainable even after being abandoned by its original authors and then successive maintainers
<mfiano>
I don't speak for everyone of course, but I think that in addition to the low bus factor, there is also a very low er count for the majority of Lisp software.
<aeth>
phoe: emphasis on "people use them professionally", not on "money"
<mfiano>
user count*
<mfiano>
Relative to the number of Lisp users that is
<phoe>
aeth: low adoption of Lisp in professional circles, then? I guess I can dig that
<aeth>
money more as money flowing to people through the project (probably indirectly) is what I had meant
<Josh_2>
(incf mfiano) :P
<phoe>
but if new languages and paradigms appear from the level of zero professional adoption, then in theory it's also a question why Lisp with its strengths doesn't manage to do that
<phoe>
I was thinking if it's some sort of a question of bringing the software that we have from its current diaspora into one collective place
<mfiano>
Yes professional use is another factor, and Eric Normand and others have talked about the reasons extensively.
<phoe>
but we have Quicklisp
<phoe>
so we have Quicklisp and still that isn't the full solution; what is the next step?
<mfiano>
Convince companies that they don't need to hire Java boilerplate data entry specialists in drones because they are cheap and expendable?
MindForeverVoyag has joined #lisp
<phoe>
I wonder if we could listen to Eric Normand and learn something from the world of Clojure that grew really nice and well
<phoe>
Clojure ain't Java
* phoe
thinks aloud
<mfiano>
Java's success is mostly because developers can sneak modules into existing Java codebases seamlessly.
<phoe>
ABCL though
<dlowe>
Java's success is mostly from billions of dollars of research and marketing on Sun's part
<mfiano>
I think performance and the lack of backing by a company such as Cognitect is the biggest concern there
theseb has joined #lisp
mindCrime has joined #lisp
<dlowe>
Cognitect was just acquired by Nubank
<phoe>
which kinda proves its success
<dlowe>
anyway, if you want people to use something like a programming language, you have to put it between them and something they want
<dlowe>
for 99.999% of programmers, that's a guaranteed job
<phoe>
so we gotta start a Lisp shop or something and focus on marketing?
<dlowe>
a) profit! b) ??? c) lisp popularity
<phoe>
wait, did you get the order right on that one
<dlowe>
sadly yes
<dlowe>
most new languages that become widely successful get corporate sponsorship
jeosol has joined #lisp
<dlowe>
perl being a curious and temporary exception
<aeth>
dlowe: If by "put it between them and something they want", you mean "require the usage of that language to enter some ecosystem", that definitely works, e.g. JavaScript, C#, or any language by Apple
<phoe>
aeth: there's languages that gain popularity without such dirty tactics
<aeth>
dlowe: Perl failed because Perl 6 was even more of a failure than Python 3 in driving away existing users and not offering a clear upgrade path (Python eventually recovered, but was probably set back 5 years)
<aeth>
phoe: Some are just for one library (in the case of Ruby, Rails) and some are for quite a few libraries (Python), but for the most part, people use a new language when the choice has been made for them (even Emacs Lisp's popularity to some extent)
<aeth>
Arguably Python's shifting more in this direction because of machine learning libraries like Tensorflow
<aeth>
(As in, required rather than just offering better libraries)
v3ga has quit [Ping timeout: 244 seconds]
<phoe>
I still don't think that's the whole story
<mfiano>
I meant to say "Clojure's success" above, not Java's
<phoe>
mfiano: yes, I guessed
<phoe>
I assumed it's a terrible pun on my "Clojure ain't Java" posted two lines above
<aeth>
phoe: I wouldn't call it "dirty tactics", either. I mean, when Microsoft or Apple or Google does it, they're trying to push for more control, but it's a concept that works in general and includes e.g. JavaScript or even C++. Some domains just force you to use the language, generally to be involved in some ecosystem.
<phoe>
aeth: agreed. (though the domain of programming for corporate ecosystem X or Y or Z is still dirty gatekeeping in my opinion)
<aeth>
phoe: To be fair, though, Microsoft did try some language-agnostic approaches like COM.
rwcom3417491164 has joined #lisp
<Josh_2>
is the clim channel #clim ?
<phoe>
Josh_2: t
<Josh_2>
thanks
rwcom341749116 has quit [Ping timeout: 240 seconds]
<phoe>
aeth: I think that we shouldn't go into this alley because we have no big ecosystem of Lisp software or Lisp-related domain that might act as a reason for people to learn Lisp for
<phoe>
and the last somewhat successful Lisp-based OS died shortly after hardware it was designed for
<MetaYan>
phoe: Not the last.
<aeth>
phoe: I think that this is the only "alley" one can go down. The secondary and tertiary libraries aren't going to really take off without primary libraries/frameworks/applications/whatevers that drive people to the language.
<phoe>
MetaYan: oh? there was something after OpenGenera that achieved some commercial success?
<MetaYan>
There is one being built.
<phoe>
MetaYan: oh, I'm aware of that; I'm not taking it into account yet though
<phoe>
aeth: hmmmm.
<MetaYan>
What is commercial success when compared to hapiness?
<aeth>
phoe: I personally think that the main place where any language can attract lots of new programmers is probably games. People will learn any language (Java, Lua, C#, custom proprietary languages, etc.) to mod their favorite games and they're usually too young to know better (i.e. too young to focus just on the most marketable language)
<phoe>
what is happiness if it is conditioned by programming languages one uses
<MetaYan>
Is anyone stopping anyone from using Lisp?
<mfiano>
phoe: I think one of the best things we as Lispers can do to improve onboarding, is to have better tooling, starting first with SLIME/Sly equivalent for other editors, but in addition, extending asdf to allow versioned/package-renamed dependencies (however possible that may be) for more reproducible builds outside of the near-bleeding edge Quicklisp dist, etc
<aeth>
MetaYan: bosses generally are :-p
<White_Flame>
MetaYan: on the job? yes
<MetaYan>
Anyone can always start their own company using the language of choice.
<White_Flame>
sure anyone can start a company. Getting a market & customer base is another thing
<aeth>
Anyone with the ability to go months/years before seeing their first paycheck
<phoe>
MetaYan: that's technically correct advice that I consider to be of little practicality
<phoe>
aeth: mfiano: I'll think about these when I go to sleep
<mfiano>
Lisp has a pretty high learning curve even if you discount the learning of a [probably] new editor, configuring it, etc. Emacs is nice and all, but C++ doesn't require MSVC for effectiveness
wsinatra has joined #lisp
luckless has quit [Remote host closed the connection]
<aeth>
I think tooling follows adoption, not the other way around, and some decently popular languages (like Lua) have terrible tooling, but people still use it because the games they want to script use it.
<phoe>
I assume that you can't really write Lisp in a notepad
<mrcom>
I think perhaps Lisp is not as well suited for the niches filled by more mainstream languages.
<phoe>
...or you can, if you believe enough
<aeth>
phoe: you can, it just won't look pretty
wsinatra_ has quit [Ping timeout: 246 seconds]
<mfiano>
That is true, however I can't even count the number of newcomers to the language that gave up during the learning of Emacs
<mfiano>
At least the ones I helped anyway
karlosz has quit [Quit: karlosz]
<phoe>
(incf mfiano)
<phoe>
emacs is a major scarecrow
<MetaYan>
I can compare the joy of getting Mezzano running on hardware the other day with the aversion to even touching the computer at my last programming gig - which was digging in someone else's spaghetti code in VB.
<mrcom>
And conversely, there are many niches for which Lisp is much better suited.
<Gnuxie[m]>
There isn't much of an 🆑 ecosystem relative to other languages, that includes both libraries and a labour pool and other than supposed efficiency, the perceived (gains?) of taking CL (as a corperation) doesn't out weigh the risks
wsinatra has quit [Ping timeout: 246 seconds]
<mfiano>
Then you get the ocassional newcomer that uses Notepad++ complete with dangling parens (usually a student that was improperly introduced)
<mfiano>
and quickly give up because they aren't utilizing the interactive and introspective workflow Lisp was designed around
<Gnuxie[m]>
plus, you would also have to fight all the educational institutions too if you went with 🆑, since they are churning out people to write glue in Java, everything is against you
<mrcom>
Large corporate code bases tend to be structurally.. not complex, but very wide. Lots of elements with specific business-logic, but not as complex algorithms.
<bitmapper>
realistically i'd go with haskell or standard ml if it was for education
wsinatra has joined #lisp
ahungry has quit [Remote host closed the connection]
<MetaYan>
Even if I'm far from profocoent in Lisp, I'm tinkering with my own webserver in pure Lisp and even if it's a slow process, I find great joy (and of course occasional frustration followed by even greater joy) of using Common Lisp interactively.
<MetaYan>
proficient
<mrcom>
Corporate code needs fairly rigid APIs. It takes a lot of effort to make Lisp code rigid. Great for small teams or single developers, but not so much for large groups of teams.
dominic34 has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<aeth>
You can enforce rigidity by requiring the use of certain custom macros, while also requiring any new DEFMACRO to be justified.
<phoe>
mrcom: that's why Google Style Guide for Lisp exists
<mrcom>
For example, even the simple concept of 'no value specified' is a big deal in the corporate world.
<phoe>
MetaYan: touche
<mrcom>
I'm not talking style. I'm talking loose data structures with complex graph walks.
<Gnuxie[m]>
Does it really 'take a lot of effort'? It takes 'effort' to enforce consistency and expectation in APIs in every other language
<mrcom>
You can't even, really, specify 'this is a list of X' in Lisp.
<mrcom>
That's good for some things, especially the flexible problems we like to throw Lisp at.
<MetaYan>
mrcom: Isn't that part of the beauty?
<mrcom>
Yes, it is. For some problems.
<mrcom>
Not so much for a payroll system.
<MetaYan>
If people want to have payroll systems in COBOL, then who's stopping them?
<phoe>
argumentum ad cobolum doesn't really work here, cmon
<mrcom>
COBOL actually isn't a bad language for simple payroll.
<bitmapper>
i mean it is
<aeth>
mrcom: List? Easy since you just write your own cons. Vector? Now that's much harder because :element-type is almost certainly only going to work on simple, immutable types like numbers and characters.
<bitmapper>
but it's not the worst thing you could choose
<bitmapper>
far from it
<mrcom>
aeth: What I mean is, you can't say '(declare (type (list foo) x))'
<mrcom>
Where it's absolutely guarenteed that X will only ever contains foos.
<bitmapper>
what do you think stuff like coalton is for
<aeth>
mrcom: but you can write your own custom sequence consisting of a custom cons-like object that can only contain foos.
OpenZen has joined #lisp
<aeth>
mrcom: You cannot do that for vectors/arrays... I mean, I guess you could, but it's much more complicated.
<mrcom>
aeth, you can, but it's a lot of work, and not what Lisp is best suited for.
<Gnuxie[m]>
that's such an irrelevant nitpick
<mrcom>
Lisp is much happier with problems where 'most of the time it's a foo, but once in a while we really need a bar in there.'
<mrcom>
That gives Java-ish languages fits.
<MetaYan>
mrcom: :) Beauty.
<aeth>
mrcom: I mean, Java and C++ both have a richer set of built-in collections
<mrcom>
MetaYan: I agree. I really enjoy working on those kinds of problems.
<bitmapper>
no
toorevitimirp has quit [Ping timeout: 264 seconds]
<bitmapper>
ah, java
<bitmapper>
yeah, i was about to say you can represent 'most of the time it's a foo, but once in a while we really need a bar in there.' with algebraic data types
<mrcom>
aeth: yes, with rigid types. Rigidity makes it easier for large groups to work together.
<mrcom>
And algebraic data types are not what the corporate world runs on.
<aeth>
mrcom: CL's type system is better, you can restrict things *at the type system level* to e.g. be (integer 5 32)
<aeth>
It's just that typed collections aren't particularly well-supported
toorevitimirp has joined #lisp
<mrcom>
aeth: Yes, quite true. But in quirky ways.
terpri__ is now known as terpri
<aeth>
And implementations like SBCL often treat types as just performance declarations, meaning (integer 5 31) might be treated as (integer 0 31)
<mrcom>
Corporate hates quirks. *I* hated quirks when I was managing those kinds of projects.
<bitmapper>
mrcom: i mean, most languages have algebraic data types
<mrcom>
Not in their philosophy.
<MetaYan>
mrcom: What are you playing with now?
EvW has joined #lisp
diamondbond has quit [Remote host closed the connection]
<mrcom>
I've been working on a Quixote project for the last couple of years. Complex graphs, fairly simple nodes, lots of complex transformations.
gravicappa has quit [Ping timeout: 256 seconds]
<MetaYan>
Using Lisp?
xrash has joined #lisp
xrash has quit [Excess Flood]
<mrcom>
Yep. Having a ball.
<mrcom>
But it's very, very much a research project. Not suitable for development by a group of people.
diamondbond has joined #lisp
<MetaYan>
Aha, you mean like the windmill guy. I went off searching for some documentation about a system called Quixote.. :)
<mrcom>
bitmapper: What I mean, is that object-orientated languages do have polymorphic types, but the philosophy is get more and more grumpy as the objects become for homogeneous.
<mrcom>
s/homogensous/heterogeneous/
toorevitimirp has quit [Quit: Konversation terminated!]
<stylewarning>
algebraic data types ARE what the corporate world runs on, it’s just not obvious from the ludicrous tangle of abstract Java classes or void pointers in C
Harag has joined #lisp
<mrcom>
Yes, correct from an implementation standpoint, but that's like saying binary numbers are what they run on.
EvW has quit [Ping timeout: 272 seconds]
<mrcom>
To a very large extent, proper architecture of large systems is dedicated to seeking out and destroying differences.
<stylewarning>
It’s the opposite, it’s like they’re working with and juggling binary numbers and me saying “well actually they’re working with integers if you can See The Matrix”
<mrcom>
MetaYan: Yes, I'm tilting at some windmills :)
<MetaYan>
mrcom: Sounds nice, your project. Why the worries about the "corporate world"?
gaqwas has quit [Remote host closed the connection]
<mrcom>
stylewarning: Yes, you see a sequence, but commercial projects want an array. Or maybe, if you can't avoid it any other way, a linked list. But not both.
<mrcom>
MetaYan: Just some thoughts about "why is Java popular but Lisp isn't".
<phoe>
mrcom: nah, some of them just want a c++ iterable, which might be a sequence or a hash table or whatever other data structure
<MetaYan>
I'm asking, and trying to stay on topic here in the Lisp channel, because Lisp is somehow very different to what the "corporate world" is, at least for me. And there's no reason to bend Lisp into that, but just keep Lisp on the right track, and the "corporate world" will eventually change its ways. From rigidity to flexibility, and all that.
<phoe>
and it's possible to iterate over a Lisp sequence, even more so that the order of iteration is known
<mrcom>
phoe: True. But not a NULL.
<phoe>
mrcom: why? NIL is a valid list
<stylewarning>
mrcom: Lisp isn’t popular for much simpler and prosaic reasons than type system choices
<mrcom>
phoe: Yes, in Lisp. Which is the point I was trying to make. In Java it's a pain in the keister.
<phoe>
stylewarning: I actually want to hear your opinion on that
<stylewarning>
phoe: my opinion is kind of boring, but I think there are two reasons: the tooling isn’t in the style people want it to be, and there’s no consistent education around Lisp to fuel a job ecosystem
<mrcom>
And the reason it is a pain is because Java-friendly problems don't want special cases. A zero-length iterable is fine. A 'not there' value is a trouble spot.
<stylewarning>
Having to (in practice) use emacs and paredit and separately download a Lisp is a huge roadblock and nobody is excited about it
<phoe>
stylewarning: the latter project could be solvable by something beach has been thinking of as of late
<phoe>
stylewarning: wait a second, separately download a Lisp
<phoe>
you mean `apt download sbcl`?
<stylewarning>
People love downloading a fat 200 MB IntelliJ IDEA or pycharm or ....
<phoe>
s/download/install/
<stylewarning>
and love opening it up and seeing all the options for configuration in front of their eyes
<phoe>
oh, I see
<stylewarning>
Even clojure people have managed to come out with 3 (or more?!) dedicated IDEs
<stylewarning>
This signals hacky dork heaven that probably doesn’t even work
<stylewarning>
Of course, there’s another meta-discussion about what people prioritize and “what matters in life”, but these are my observations
<mrcom>
Developing in Emacs is, at heart, text editing. Maybe expression editing. Not a lot of semantics. (For example, 'rename this variable everywhere' is awkward.)
<phoe>
so one of the big reasons is the editor
<phoe>
I need to agree
<stylewarning>
phoe: it’s even bigger than the editor, it’s the first impression
<phoe>
as mentioned earlier, https://lisp.org gives a weird first impression
<aeth>
it doesn't help that paredit doesn't even work unless you (setq paredit-space-for-delimiter-predicates '((lambda (endp delimiter) nil))) because of the incorrect personal tastes of whoever happens to maintain paredit
fsmunoz has joined #lisp
* phoe
goes to sleep to think about all that
<mfiano>
stylewarning's real world opinions are shared by me for sure. It's nice he was able to describe so concisely what I have been trying to for such a long time
xrash has joined #lisp
<aeth>
defaults being trash isn't just a thing in the Lisp ecosystem, it's a thing in the entire Unix one
<fsmunoz>
greetings
gaa has quit [Read error: Connection reset by peer]
<bitmapper>
stylewarning: cursive is just an intellij plugin
gaa has joined #lisp
<bitmapper>
however, i think a lisp editor using MPS would be very interesting
<MetaYan>
MPS?
<bitmapper>
most people joke about it being a terrible form of metaprogramming
<bitmapper>
when it isn't really that
<bitmapper>
it's an ide for making ides based on structural/projectional editing
<MetaYan>
An IDE for making IDEs sounds fun.
<stylewarning>
The meager good news is that this is a solvable problem and has been solved many times in history. The only thing stopping it from happening is the existence of exactly one motivated and talented hacker.
<bitmapper>
it is actually good fun
<mrcom>
Emacs UX is... jaw-droppingly bad. Common things are not simple. Obscure things are short key sequences (^h ^o -- Why do I need a key sequence bound to "describe distribution"?)
<aeth>
Because GNU is a religion
<bitmapper>
thankfully you don't need to use java very often
<bitmapper>
and when you do, it's a version of java that they made a little more enjoyable to write
<bitmapper>
also, like, structural java editor
<aeth>
to be fair though C-h is help
<mrcom>
However--Emacs + packages is zeroed in on some things that IDEs don't think about.
gaa has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
<fsmunoz>
For a moment I was thinking of a Java editor based on Lévi-Strauss and Lancan. And it sort of made sense tbh.
<aeth>
Emacs's C-h isn't too different from Alt+h in, say, Firefox, except there, you're bringing up the menu bar so you can actually see what your options are if you don't know them ahead of time without having to C-h ?
<aeth>
It would be interesting to have a visual exploration of keyboard shortcuts throughout the entire system in a CL Emacs
<mrcom>
So *why* is Emacs so entrenched in Lisp development?
<Josh_2>
bitmapper: what on earth is that?
<bitmapper>
java
<mrcom>
I think it gets back to the problem space.
<Josh_2>
the horror
<aeth>
Emacs Lisp is close enough to Common Lisp that Common Lispers don't mind writing it as much as, say, Java or Perl
<mrcom>
Coding in Lisp isn't about renaming variables.
<mrcom>
Or changing data types.
<mrcom>
It's dealing with more complex algorithms than is typical in large-scale projects.
<MetaYan>
One thing that speaks against using Emacs for Common Lisp is that it's referring to the latter as "Inferior Lisp". Just that should be a warning.
<mrcom>
And it's hard to have an IDE help you with that kind of editing.
<Josh_2>
lul
<Harag>
I dont think its just editor and tooling, last year or the year before when I did some react-native work the installation and ide support was so bad I ended up setting up emacs to with linter etc to be able to work
<Harag>
and thousands loved dived right into react
<Josh_2>
So if you change it to "Superior Lisp" it's fine??
<MetaYan>
Well, I'm using it. Configured by hand, but also as Portacle.
<mrcom>
More popular languages are... algebra? Lisp is topology.
<MetaYan>
Josh_2: At least a bit better. Because i's something that's visible from the start and influencing on a subtle level.
<MetaYan>
Josh_2: And doesn't have to be "Superior". Just "Lisp" is fine
<aeth>
Even a CL Emacs would have to have an inferior-lisp because (1) you might be developing in a different CL than you are using for the editor, (2) the editor might be under /usr/bin/ or /usr/local/bin/ instead of $HOME, and (3) sometimes you just mess things up so badly that M-x slime-restart-inferior-lisp is the fastest solution and it's nice not to have to restart the editor, too
<aeth>
And I personally try to remember to always restart the inferior Lisp before pushing commits just in case there's a weird stale state bug, like e.g. renaming a function, but still calling the old name somewhere in my code
<aeth>
plus, you'd waste at most about 100 MB in RAM and RAM's cheap
diamondbond has quit [Ping timeout: 272 seconds]
diamondbond has joined #lisp
sjl_ has quit [Ping timeout: 256 seconds]
<aeth>
(I guess #2 is just #1, but using different versions of the same CL implementation instead of different distinct CL implementations)
rgherdt has quit [Ping timeout: 272 seconds]
pve has quit [Quit: leaving]
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
Harag has quit [Remote host closed the connection]
nirved has quit [Ping timeout: 240 seconds]
_whitelogger has joined #lisp
wsinatra has quit [Quit: WeeChat 2.8]
diamondbond has quit [Quit: Leaving]
zigpaw has quit [Ping timeout: 256 seconds]
akoana has joined #lisp
nirved has joined #lisp
zigpaw has joined #lisp
dominic34 has quit [Ping timeout: 265 seconds]
Harag has joined #lisp
<scymtym>
Josh_2: for updating a pane periodically, look at the examples/graph-toy.lisp demo. for a non-timing based source of updates (potentially in a different thread), define a custom event type, submit events from the other thread and handle them by redisplaying or repaint (whichever is appropriate in your case)
<Josh_2>
I will take a look at that thanks
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
diamondbond has joined #lisp
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
cosimone_ has quit [Ping timeout: 260 seconds]
<stylewarning>
These comparisons to algebra and topology are triggering
aadbe has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
torbo has joined #lisp
luna_is_here has joined #lisp
luckless has joined #lisp
luna_is_here_ has quit [Ping timeout: 256 seconds]
aadbe has quit [Remote host closed the connection]
sympt_ has joined #lisp
sympt has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 256 seconds]
EvW1 has joined #lisp
diamondbond has quit [Ping timeout: 256 seconds]
OMGOMG has quit [Remote host closed the connection]