umgeher3 has quit [Read error: Connection reset by peer]
umgeher3 has joined #lisp
dale has joined #lisp
MCP_ has quit [Ping timeout: 245 seconds]
mdvan has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
varjag has joined #lisp
liberiga has joined #lisp
pjb has quit [Remote host closed the connection]
umgeher3 has quit [Read error: Connection reset by peer]
umgeher3 has joined #lisp
pjb has joined #lisp
umgeher4 has joined #lisp
umgeher3 has quit [Ping timeout: 258 seconds]
quazimodo has joined #lisp
_whitelogger has joined #lisp
FreeBirdLjj has joined #lisp
ebrasca has quit [Remote host closed the connection]
karlosz_ has joined #lisp
Jeanne-Kamikaze has quit [Quit: Leaving]
FreeBirdLjj has quit [Remote host closed the connection]
SaganMan has joined #lisp
dale has joined #lisp
karlosz_ has quit [Quit: karlosz_]
esrse has joined #lisp
rdh has quit [Quit: Leaving]
pjb has quit [Ping timeout: 250 seconds]
SaganMan has quit [Ping timeout: 272 seconds]
milanj has quit [Quit: This computer has gone to sleep]
dddddd has quit [Remote host closed the connection]
alexanderbarbosa has joined #lisp
igemnace has quit [Quit: WeeChat 2.5]
<PuercoPop>
fouric: not w/o modifications but none of them are a road-blocker
EvW has quit [Ping timeout: 250 seconds]
mdvan` has joined #lisp
superkumasan has quit [Ping timeout: 245 seconds]
black_13 has joined #lisp
<black_13>
is there a constant in lisp such as #t ?
mdvan has quit [Ping timeout: 258 seconds]
mdvan` has quit [Ping timeout: 244 seconds]
Oladon has quit [Quit: Leaving.]
superkumasan has joined #lisp
ltriant has quit [Ping timeout: 258 seconds]
notzmv has quit [Ping timeout: 244 seconds]
<edgar-rft>
black_13: in Common Lisp it's just simply t (without the #)
<black_13>
an s-expression is not necessarily correct lisp
<black_13>
i ask
<edgar-rft>
it's true, an s-expression is not necessarily correct lisp, but what exactly is the question?
lucasb has quit [Quit: Connection closed for inactivity]
<black_13>
i am toying around with writting a s-expression parser
<black_13>
i want to make tree based on s-expressions
Josh_2 has quit [Remote host closed the connection]
varjag has quit [Ping timeout: 244 seconds]
abhixec has joined #lisp
Oladon has joined #lisp
MCP_ has joined #lisp
ltriant has joined #lisp
ltriant has quit [Ping timeout: 268 seconds]
Necktwi has quit [Ping timeout: 268 seconds]
Necktwi has joined #lisp
CloseToZero has joined #lisp
noobineer has joined #lisp
noobineer has quit [Read error: Connection reset by peer]
<beach>
Good morning everyone!
noobineer has joined #lisp
<ck_>
Good morning, beach
noobineer has quit [Read error: Connection reset by peer]
noobineer has joined #lisp
torbo has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
noobineer has quit [Read error: Connection reset by peer]
ltriant has joined #lisp
noobineer has joined #lisp
notzmv has joined #lisp
gravicappa has joined #lisp
<beach>
black_13: What is the purpose of your S-expression parser, and why do you need to write one?
<beach>
black_13: The reason I am asking is that Common Lisp comes with a built-in S-expression parser. It is called READ.
froggey has quit [Ping timeout: 245 seconds]
froggey has joined #lisp
jack_rabbit_ has quit [Ping timeout: 276 seconds]
myrrh has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
sindan has quit [Remote host closed the connection]
sindan has joined #lisp
Arcaelyx has quit [Ping timeout: 245 seconds]
ioseph has joined #lisp
Oladon has quit [Quit: Leaving.]
ealfonso has joined #lisp
wusticality has quit [Ping timeout: 272 seconds]
lavaflow has joined #lisp
dtornabene has joined #lisp
<dtornabene>
good morning
<LdBeth>
Hello dtornabene
dtornabene has quit [Remote host closed the connection]
dtornabene has joined #lisp
<dtornabene>
hello LdBeth
wusticality has joined #lisp
ioseph has left #lisp ["WeeChat 2.3"]
wusticality has quit [Ping timeout: 258 seconds]
myrrh has left #lisp ["ERC (IRC client for Emacs 26.2)"]
Inline has quit [Quit: Leaving]
vlatkoB has joined #lisp
flamebeard has joined #lisp
sellout- has joined #lisp
Kundry_Wag has joined #lisp
JohnMS_WORK has joined #lisp
Kundry_Wag has quit [Ping timeout: 246 seconds]
ealfonso has quit [Ping timeout: 250 seconds]
dale has quit [Quit: My computer has gone to sleep]
sellout- has quit [Ping timeout: 248 seconds]
zaquest has joined #lisp
schweers has joined #lisp
_jrjsmrtn has quit [Ping timeout: 244 seconds]
__jrjsmrtn__ has joined #lisp
jprajzne has joined #lisp
ltriant has quit [Ping timeout: 272 seconds]
gravicappa has quit [Ping timeout: 245 seconds]
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
ltriant has joined #lisp
MCP_ has quit [Remote host closed the connection]
MCP_ has joined #lisp
frgo has quit [Ping timeout: 246 seconds]
manualcrank has quit [Quit: WeeChat 1.9.1]
__jrjsmrtn__ has quit [Ping timeout: 246 seconds]
milanj has joined #lisp
pjb has joined #lisp
dtornabene has quit [Quit: Leaving]
ltriant has quit [Quit: leaving]
ggole has joined #lisp
White_Flame has quit [Ping timeout: 245 seconds]
black_13 has quit [Ping timeout: 260 seconds]
frgo has joined #lisp
test21 has joined #lisp
test21 has quit [Remote host closed the connection]
mingus has joined #lisp
knicklux has joined #lisp
knicklux has quit [Remote host closed the connection]
liberiga has quit [Quit: Leaving]
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life has joined #lisp
HDurer has joined #lisp
test124 has joined #lisp
hhdave has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
White_Flame has joined #lisp
test124 has quit [Remote host closed the connection]
kaun_ has joined #lisp
oni-on-ion has joined #lisp
ioseph has joined #lisp
shka_ has quit [Ping timeout: 246 seconds]
ioseph has left #lisp ["WeeChat 2.3"]
JohnMS has joined #lisp
esrse has quit [Ping timeout: 245 seconds]
JohnMS_WORK has quit [Ping timeout: 258 seconds]
Lycurgus has joined #lisp
rozenglass has joined #lisp
jmercouris has joined #lisp
pillton has quit [Read error: Connection reset by peer]
random-nick has joined #lisp
MCP_ has quit [Ping timeout: 248 seconds]
milanj has quit [Quit: This computer has gone to sleep]
gravicappa has joined #lisp
puchacz has joined #lisp
puchacz has quit [Client Quit]
zotan has quit [Ping timeout: 244 seconds]
jmercouris has quit [Ping timeout: 272 seconds]
zotan has joined #lisp
alexanderbarbosa has quit [Remote host closed the connection]
jmercouris has joined #lisp
alexanderbarbosa has joined #lisp
Ricchi has quit [Remote host closed the connection]
dpl has joined #lisp
etwert has joined #lisp
libertyprime has joined #lisp
kaun_ has left #lisp [#lisp]
igemnace has joined #lisp
dddddd has joined #lisp
jmercouris has quit [Remote host closed the connection]
jmercouris has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
orivej has joined #lisp
<no-defun-allowed>
Silly question: when quickloading something, what do all the dots signify (other than looking nice)?
themsay has quit [Ping timeout: 246 seconds]
scymtym has quit [Ping timeout: 245 seconds]
<jackdaniel>
I think it is bound to a macroexpand-hook so each macroexpansion shows a dot
orivej has quit [Ping timeout: 248 seconds]
<no-defun-allowed>
Ah yeah, I was guessing something like each top level form, but that seems easier to track.
etwert has quit [Ping timeout: 244 seconds]
<jmercouris>
interesting......
<minion>
jmercouris, memo from pjb: You need a reader macro, you cannot do it with a macro (because then you won't need what symbols were qualified). You cannot use #. because you need the input stream; when loading or compiling a file, *standard-input* is not set to the source stream!
<minion>
jmercouris, memo from pjb: https://pastebin.com/qJTUxwYc (note: !?{}[] as (dispatching) reader macros are reserved for the user, so don't use them in code published in quicklisp)..
<jmercouris>
oh, I see
<no-defun-allowed>
Yep, does seem to be like that. I wrote a little system that just prints out the macroexpand-hook and it is in quicklisp-client::macroexpand-progress-fun
<LdBeth>
Well, I guess one can just copy the readtable
alexanderbarbosa has quit [Remote host closed the connection]
jmercouris has quit [Ping timeout: 272 seconds]
wigust has joined #lisp
wigust- has quit [Ping timeout: 258 seconds]
<Xach>
no-defun-allowed: it's meant as a primitive quiet indicator of progress.
zagura has quit [Ping timeout: 246 seconds]
<Xach>
no-defun-allowed: no output at all for minutes could be alarming - has something failed?
<Xach>
but the full output of sbcl i find too much most of the time
<no-defun-allowed>
Xach: It does that very well, but I was wondering what each dot "means".
<Xach>
it means something is happening
<Xach>
i don't think much more can be drawn from each one
<no-defun-allowed>
Right then.
<no-defun-allowed>
Can you eyeball it and say something like "that system has a lot of dots, it's pretty big"?
<LdBeth>
It could be something just emitted “function FOO is compiled”
SaganMan has joined #lisp
<no-defun-allowed>
(I ask since I loaded up CLIM, which loaded flexichain, and it scared the crap out of me because I intend to refactor it, and it put a lot of dots.)
<LdBeth>
So it can also be “unused variable p”
atgreen has quit [Ping timeout: 276 seconds]
amerlyq has joined #lisp
dmiles has quit [Read error: Connection reset by peer]
milanj has joined #lisp
dmiles has joined #lisp
orivej has joined #lisp
etwert has joined #lisp
themsay has joined #lisp
jmercouris has joined #lisp
SaganMan has quit [Ping timeout: 258 seconds]
CrazyEddy has joined #lisp
rozenglass has quit [Remote host closed the connection]
zagura has joined #lisp
__jrjsmrtn__ has joined #lisp
zagura has quit [Ping timeout: 248 seconds]
werrwer has joined #lisp
etwert has quit [Read error: Connection reset by peer]
scymtym has joined #lisp
j0nd0e has joined #lisp
zagura has joined #lisp
dgfhdfg has joined #lisp
werrwer has quit [Quit: Leaving]
j0nd0e has quit [Ping timeout: 245 seconds]
EvW1 has joined #lisp
zagura has quit [Ping timeout: 272 seconds]
Kundry_Wag has joined #lisp
schweers has quit [Ping timeout: 250 seconds]
pfdietz has joined #lisp
libertyprime has quit [Quit: leaving]
zagura has joined #lisp
EvW1 has quit [Remote host closed the connection]
EvW has joined #lisp
zagura has quit [Ping timeout: 245 seconds]
zagura has joined #lisp
<pfdietz>
The quicklisp macroexpand hook also prints the package name when a defpackage form is encountered, when a file being compiled.
milanj has quit [Quit: This computer has gone to sleep]
<ck_>
it would be fun to make this into a complexity measurement
<ck_>
quick, write the paper! "On Extending Software Metrics: Beyond Cyclometric Complexity. The Quicklisp-Dot"
<ck_>
now if you would excuse me, I have to tackle this 512-dot problem
<pfdietz>
There was an effort once to connect software complexity metrics to bug count. As I recall, the only interesting correlation was with code size.
pfdietz has quit [Remote host closed the connection]
alexanderbarbosa has joined #lisp
saravia has joined #lisp
t58 has joined #lisp
EvW has joined #lisp
<warweasle>
I've become the "the lisp guy". Every time a "new" idea shows up on /r/programming...I mention how lisp had it decades ago. Apparently they hate lisp there.
alexanderbarbosa has quit [Remote host closed the connection]
<beach>
No doubt because they know very little about it. That's the usual reason.
<jmercouris>
I think fundamentally a huge barrier to Lisp's adoption is indeed the absence of a GUI toolkit
<jmercouris>
at least a free toolkit
<jmercouris>
web frameworks exist, then again, Python doesn't have a good GUI toolkit, and it has proliferated like crazy
<jmercouris>
so that is not a good reason, maybe it is marketing...
<warweasle>
What I wouldn't give for something between emacs and unreal engine.
<warweasle>
With common lisp. Elisp never clicked for me.
<p_l>
jmercouris: Python put *a shitton* into docs
<jmercouris>
Elisp is a disease in the Lisp community
milanj has joined #lisp
<p_l>
jmercouris: looking back in time, Python ~2002 gave people the equivalent of paying for boxed set of MCL or Genera back in 1990, in the form of attached docs
<p_l>
not in quality of environment or anything else
<p_l>
but in the "the box comes with three-ring binders / books full of docs, a self-guide tutorial, and a good enough set of basic libs"
<warweasle>
It's such a same considering lisp is so nice.
<beach>
jmercouris: I don't believe for a second that the existence of a GUI toolkit for Common Lisp would have any significant impact on its adoption. Strong psychological forces are at work here, and a GUI toolkit can't compensate for those.
Kundry_Wag has quit [Ping timeout: 248 seconds]
<mason>
Eh? No GUI toolkit? What about Smoke/Qt?
<p_l>
beach: *some* psychological forces, yes
<beach>
jmercouris: The easiest thing to do is to stop desiring more widespread adoption. I am convinced there is nothing we can do as Common Lisp developers to change it. It would have to be changed in university education, and even that may be too late.
<p_l>
beach: it's easier to target new people, though
<p_l>
beach: I'd say availability of a *complete* environment, one where people actually worked to keep that completeness, would drive a lot. But all such projects are expensive
<beach>
p_l: I seriously doubt it. I have studied the psychological forces involved and I have a pretty good understanding of their force.
<warweasle>
A good gui would help a lot.
<mason>
What's wrong with CommonQT?
<p_l>
warweasle: "good" is not enough. You'd need to get something akin to Delphi experience
<p_l>
beach: do you have any writeup?
<beach>
I do.
<beach>
Hold on a sec...
<warweasle>
Some of those that work forces, are the same that write python.
<beach>
mason: The semantic gap between a language such as Common Lisp and a language such as C++ is so great that debugging becomes complicated and it influences in negative ways the programming style.
<p_l>
mason: have you ever used Delphi?
<warweasle>
p_l: Lisp will mutate to that. That's its best ability. To modify itself to become better.
<mason>
beach: Alright, so something native from the ground up is the goal then...
<mason>
p_l: I haven't.
<warweasle>
Until then I just ECL and then translate everything to C in the end.
<p_l>
warweasle: I heard MCL was a step-down from Delphi when it regards GUI. And it was goddamn good for lisp environment
<beach>
mason: Some people are working very hard as we speak to make it happen.
EvW has quit [Ping timeout: 264 seconds]
<warweasle>
beach: Which thing?
<beach>
"something native from the ground up"
<mfiano>
Interesting McCLIM hasn't been brought up, being as powerful as it is and local to Common Lisp.
<p_l>
this reminds me that I need to look up if Garnet is operable
<beach>
mason: It is already usable, but it has some of the same problems as Common Lisp itself, in that it requires people to change the way they have traditionally worked.
<aindilis>
what about more articles in places like GNU/Linux Journal?
<aindilis>
oops srry about the GNU, auto added
<p_l>
aindilis: that assumes people read them
<p_l>
different world today
<warweasle>
beach: I think we need to start thinking in new ways. Like why is my text editor, language and compiler all separate?
<p_l>
aindilis: the kind of people that read actually insightful technical press is already the 1%
<beach>
warweasle: That is being dealt with as well, but resources are scarce.
<aindilis>
warweasle: well you probably don't want to rule out their use of other programming languages, right?
<warweasle>
Imagine being able to make a C function, test it in your editor with some lisp and slowly create your project that way.
<jackdaniel>
warweasle: I've made a hack "eclrepl" for that
<p_l>
warweasle: play around with Pharo
<jackdaniel>
it requries more work of course, but it works for interactive testing C functions
<warweasle>
jackdaniel: I did something similar...but it's weird that emacs is a completely separate piece.
<jackdaniel>
I have even implemented c99 grammar, but I've stopped at the preprocessor
<jackdaniel>
and scymtym took it and actually parsed stdio with success, what is a huge "wow", because C preprocessor is a mess
<warweasle>
There is that new fancy compiler. but it's been a while since I've looked into it.
Kundry_Wag has joined #lisp
<jackdaniel>
(he first written the preprocessor part which my implementation was missing)
<mason>
beach: Well. That's good to hear, though. :)
<jackdaniel>
and regarding CLIM, we are moving forward with determination and stable progress
<mason>
beach: Public project? Or not until it's complete?
<beach>
warweasle: There are plans for an IDE with a very capable text-editor part that can analyze Common Lisp code in ways that are currently not possible, with a real debugger in which you can set breakpoints even in code that is itself executed by the debugger.
<aindilis>
what about a marketing campaign?
<p_l>
unfortunately some of the best options for that are these days mostly clojure
<beach>
warweasle: And an inspector that blows the SLIME inspector out of the water.
<mfiano>
I prefer the SLy inspector using "stickers" for debugging
<beach>
The inspector already exists, in fact.
<aindilis>
what about making the Common Lisp static/dynamic analysis stuff a separate API that can be accessed by multiple editors?
<mfiano>
It would have to be better than stickers for me to switch. That blows SLIME debugging out of the water
<aindilis>
such as Emacs/SLIME
<beach>
mason: You have to be patient about some initial version.
atgreen has joined #lisp
<beach>
aindilis: That is being worked on as well.
<beach>
I forget the name of the interface, CLI maybe?
<beach>
But that interface can't handle everything we need for Common Lisp.
<scymtym>
beach: you mean language server protocol (LSP)?
Kundry_Wag has quit [Ping timeout: 272 seconds]
<aindilis>
ha!
<beach>
Ah, yes, thanks.
<aindilis>
I was trying to remember that
cosimone has joined #lisp
<beach>
To analyze the contents of a text-editor window, we need to do several things that aren't possible (or at least not simple) with current Common Lisp implementations.
<mfiano>
Yes, LSP alone wouldn't be enough for Common Lisp. You would also need the DAP protocol, and additional editor specific functionality since LSP is not really suitable for interactive languages. Once you start adding editor specific functionality though, you no longer have what makes LSP useful - portability.
<beach>
First, we need to read the code, preserving the source information.
<beach>
Then we need a compiler that can handle incremental first-class environments, so that we can back out side effects when the code changes.
<beach>
But that is being worked on as well. :) In fact, most of such a compiler already exist.
<aindilis>
is there any documentation central for CL?
manualcrank has joined #lisp
<Xach>
aindilis: no
<ck_>
there's a couple of documentation aggregators
<beach>
And that compiler has sophisticated CLOS protocols that makes it possible to adapt to several implementation. We just need the manpower to make it happen. Or alternatively, significantly more time.
rozenglass has joined #lisp
<warweasle>
If only I had the money to give lisp a boost. Like unreal did to blender.
<beach>
warweasle: Money is not the problem. Manpower is.
<p_l>
aindilis: Xach's l1sp.org been pretty useful for me
<p_l>
beach: money can be turned into manpower, though
<beach>
p_l: Not as easily as one might think. Not for this kind of work.
<LdBeth>
Hire Lispers?
<warweasle>
I think there are enough lispers already...We just don't work together well.
cosimone has quit [Quit: WeeChat 2.4]
<p_l>
beach: I'd say fifty/fifty. The problem is that it's non-trivial amount of money, and some of the skills necessary are kinda low availability on the market due to general IT stupidity
<beach>
LdBeth: Most of the work I need done requires someone who is an expert in CLOS, in compiler design, and in software engineering, I am sure there are Lispers out there that correspond to that list of requirements, but they are very likely employed, have families, houses, friends, etc.
<warweasle>
p_l: I agree with you. I have to use ECL as a sort of scaffolding to develop C and C++.
cosimone has joined #lisp
<mfiano>
It's non-trivial to have a central documentation repository that doesn't just scrape docstrings. Quickdocs for example doesn't include #'(setf documentation) documentation. A near-complete solution can only be realized at compile time. Heck, #'documentation is a generic function and could change according to the local environment or at runtime.
Bike has joined #lisp
<warweasle>
Also, lisp has security issues.
<p_l>
for general CL betterment, there's a ton of ancilliary work that is unrelated to advanced programming itself
<warweasle>
I would love to see a safe subset of lisp.
<p_l>
warweasle: what kind of security are you thinking about?
FreeBirdLjj has joined #lisp
<beach>
warweasle: That is being worked on as well.
<p_l>
the likes of SPARK are special dialects of their host languages for a reason
<warweasle>
p_l: Imagine a subset of lisp that you could use like javascript.
<beach>
warweasle: See out paper on first-class global environments. Also see the WSCL project.
<p_l>
warweasle: that's absolutely a downslide in security
<warweasle>
With maybe a (with-safe-code ....)
<p_l>
warweasle: falls under DSL/small-language work
<p_l>
and implementing lisp in lisp
<p_l>
hell, you'd probably get mostly there by copy-pasting Norvig's Scheme implementation
<warweasle>
p_l: Yes, but it's deceptively tricky to write safe code.
<beach>
So if anyone wants to take a chunk of this effort, that would be great.
smazga has joined #lisp
<p_l>
it was more of a backhanded answer that there was zero security in what you mentioned
<mfiano>
You would need to write your own reader and also takes some of the idea's from beach's paper to secure it.
<warweasle>
beach: What exactly are you working on?
<LdBeth>
mfiano: one has to assume there’s a period of time the system is stable and documents can be retrieved
<beach>
warweasle: SICL, Cleavir, McCLIM a bit, WSCL, Clordane, Second Climacs.
atgreen has quit [Ping timeout: 246 seconds]
<warweasle>
beach: I wish I had time to help on something. But I'm trying to start something for myself.
jprajzne has quit [Quit: Leaving.]
<beach>
warweasle: Oh, I fully understand. I am just explaining why progress is slow.
Kundry_Wag has joined #lisp
<aindilis>
I have omega number of projects going on, and omega + 1 = omega, so it wouldn't be any more work for me
<beach>
aindilis: Yes, exactly the same for others.
<beach>
It is getting better though. Several people are pitching in.
<beach>
But, let me say this again, even when we have something decent, it won't have any significant impact on the number of people using Common Lisp.
<aindilis>
beach is there anything that would?
<aindilis>
I suppose you must mention a strategy in your writeup?
<mfiano>
LdBeth: Correct. Any solution for fetching documentation is a partial one though. To be complete it has to be pushed by the author to a central repository, not the other way around, in order to better deal with foreign dependencies not available on the central repository, etc.
<beach>
aindilis: Only a deep transformation about what is taught at universities. And that's not going to happen because the teachers an insufficiently trained as well.
<aindilis>
I do have a text -> concordance wiki system I wrote that could aggregate links to mentions things like SICL, Cleavir, McCLIM a bit, WSCL, Clordane, Second Climacs, etc into a Wiki, maybe even google them for additional mentions, and then disambiguation of multiple denotations?
<LdBeth>
mfiano: it seems a distributed system could help
<aindilis>
also is there a conference, a foundation and an author index?
<warweasle>
beach: I had an idea using an sexp-based diff tool to create something similar to git. We could build documentation, annotations, etc into the system.
<warweasle>
As a bonus, this system could be used as an editing tool...like the heart of a distributed text editor.
<LdBeth>
warweasle: data structure diff
<warweasle>
YEs. But sexp aware.
<warweasle>
With comments.
<aindilis>
warweasle: git is insufficient? replicating something as complex as git would be difficult I would think
<LdBeth>
But sexp is not very ideal once reader macros are involved
<aindilis>
it would be cool to have an index of who has what projects, and to see where people are aligned and could team up
<warweasle>
Git is just diff and patch with hashing. This would allow you to create documents within documents.
<warweasle>
It could also use encryption to allow different levels of access.
<warweasle>
So I could let you work on a part of my project but see the rest.
<aindilis>
the main innovation was using RTE (recognizing textual entailment) / NLI (natural language inference) to figure out which goals were identifical
<aindilis>
*identical
<warweasle>
My end idea was to use "safe-lisp", this sexp-database/revision mangager interface and some gui tools to create new applications based on your data. As you need them.
<LdBeth>
warweasle: seems you misunderstand some concept that distributed VC uses
<warweasle>
You need a spreadsheet? It's just a bunch of tiny rich text boxes...
<beach>
warweasle: Such a diff tool sounds quite useful.
Lycurgus has quit [Quit: Exeunt]
<warweasle>
I might still have it...
<aindilis>
is QuickLisp the closest thing to CPAN?
sjl has quit [Client Quit]
<LdBeth>
aindilis: yes
<Xach>
aindilis: and yet still so far away
<LdBeth>
warweasle: you’ve mentioned safe-lisp, what’s the standard to be “safe”?
<warweasle>
I think I lost it.
<aindilis>
damn
<dlowe>
these days the standard to be safe is to not access memory or branch :p
<warweasle>
LdBeth: Similar to basic javascript. It can't interact with anything outside itself. Unless you plug in something like a DOM or some other connection.
<warweasle>
Anyway, it was just a recursive diff function. But I couldn't figure out how to work with comments.
<mfiano>
warweasle: You need more than that to be safe.
mindCrime has joined #lisp
<warweasle>
I could apply a "diff" command which was just a list of what to change in a tree.
<aindilis>
I keep a large Knowledge Base in Cyc of people on IRC and what they're working on...
Inline has joined #lisp
<warweasle>
mfiano: I meant to use it like javascript. But in a 2D AND 3D world.
Kundry_Wag has quit [Read error: Connection reset by peer]
<aindilis>
beach: do you think better organization is critical to the expansion or at least mantainence of the community?
<mfiano>
Quite easy to bring the whole image down, just by reading it something like 1d999
<mfiano>
it=in
<warweasle>
End the end I wanted to create a single application which could replace all others.
<LdBeth>
warweasle: I had similar plans on diff, but I choose a “flat” representation instead of trees(or linked list), and comments can be preserved well even they’re multiline
zgasma has joined #lisp
<mfiano>
Safe input can't be parsed by cl:read
<beach>
aindilis: I think the community is doing quite well, and it appears to be adding a few people regularly. What I think we ought to do, but it is hard to obtain, is to factor more work so as to avoid duplicate effort.
<LdBeth>
Although diff is not my first concern, the intention is to be compact and share as much as possible
<warweasle>
The basic idea is there are only a few "basic" interaction types. Text, rich text, vector graphics, etc. But embedding them into complex documents, you don't need new apps anymore. The app will form around your data.
smazga has quit [Ping timeout: 248 seconds]
<aindilis>
that's good to hear the community is doing well
sjl has joined #lisp
<aindilis>
Lisp is critical to the success of my main interest, symbolic AI
Josh_2 has joined #lisp
<LdBeth>
beach: persuading others is a hard social process
<aindilis>
I'm interested in learning how to persuade others both for the sake of lisp and other similar ecosystems I rely on but mostly since my project for the last 20 years has had no new members
<warweasle>
I wish I had the time to rip into Godot and pull it into lisp.
anaphoric has joined #lisp
<beach>
aindilis: Given what I now know about the psychological forces behind this issue, I think you can basically forget about persuading others to change their ways.
<aindilis>
beach: you can't persuade me to
<aindilis>
j/k
<aindilis>
yeah that's my conclusion
<LdBeth>
Show them what lisp can do
<beach>
LdBeth: Won't work.
<aindilis>
I have two printouts on my wall: "Slow and steady wins the race", and "Show people something that works"
<Xach>
You must simply live with the smug pleasure of being correct in a sea of ignorance!
<Xach>
that is worth more than gold
<warweasle>
Xach: I would rather exchange it for gold.
<aindilis>
:) is there any shared hosting that I can use to host some lisp related infrastructure work? I lost 9 hard drives last year and that's my main deterent from working more on these things?
atgreen has joined #lisp
<warweasle>
I use linode.
<Xach>
warweasle: that is, how you say, trop gauche
<Xach>
aindilis: i use ovh and a dedicated server and i like it.
<beach>
aindilis, LdBeth: Most people who need convincing have a very long-term investment in something significantly different. They are often experts in their group, and enjoy a lot of prestige.
<beach>
When they are confronted with the possibility that their investment was the wrong one, they react by denying that possibility. They may even use ridicule and even stronger tactics to avoid that anyone in their group may want to test the better thing.
<beach>
If not, they may risk losing the prestige. This is not a conscious reaction. They basically can't help it. They firmly believe that they are right and that the person trying to persuade them is totally wrong.
<warweasle>
Xach: Are you speaking in French again? I don't like it when the voices in my head do it either.
<aindilis>
beach: ah
<warweasle>
Stoopid voices...always thinking they are better than me.
<LdBeth>
Principle no.1 don’t judge a book by its cover
xkapastel has joined #lisp
<aindilis>
one thing that could be done is iterate over ghtorrent extracting the urls of projects that list Lisp as their primary language
dale_ has joined #lisp
<aindilis>
and then you could use NLP text classification to classify the projects into preexisting folksonomies like debtags or sourceforge's classification
dale_ is now known as dale
<aindilis>
it might be nice to have such services be language agnostic
jmercouris has quit [Remote host closed the connection]
<beach>
aindilis: For example, I just saw a recent paper by Adams on reading and writing floating-point numbers. There have been work in the past, but this one claims to be much better. Now every Common Lisp implementation needs those routines.
<beach>
But you can be sure that most implementations use their own code, perhaps their own technique as well, and possibly even a technique that is not as good as the published ones.
<aindilis>
is that the one about using upper and lower bounds?
flamebeard has quit []
<beach>
So taking those articles, writing portable Common Lisp code with the techniques, comparing them and making the code available, would make it possible for many Common Lisp implementations to use this code and avoid duplicate maintenance.
<beach>
I haven't read the latest one yet.
<aindilis>
so what the catch with writing portable CL code here?
<beach>
Ryũ: Fast Floating-to-String Conversion, by Ulf Adams (Google Germany).
<beach>
No catch. It is just that it is likely that every implementation has its own.
<beach>
The reason I am suggesting this one is that I don't think there is a catch.
<aindilis>
ah, now I understand, with the number of different versions of CL out there, you have this problem. I come from Perl originally so we didn't have that problem
<aindilis>
are there any versions of CL that are kind of iconoclasts?
<aindilis>
that break the standards?
<aindilis>
or do things their own way for the most part
<aindilis>
for instance, I heard it can be hard to get things running on SWI-Prolog to run on other Prolog, another language which has this kind of fractionalization
<beach>
They all have their specificities, but something like reading and writing floating-point is typically done in portable Common Lisp code.
<beach>
CLISP is written in C and uses a bytecode interpreter which makes it very portable but not that fast. ECL compiles to C and interoperates with C very easily. SBCL generates fast native code, CCL has a fast compiler. Clasp interoperates with C++. etc etc.
atgreen has quit [Ping timeout: 244 seconds]
<aindilis>
yeah that belongs in documentation central
FreeBirdLjj has quit [Remote host closed the connection]
<beach>
That is definitely a risk.
zulu-inuoe has joined #lisp
<beach>
The only way I see to fix that problem is to make sure that the new thing is faster, more portable, better documented, better tested.
<aindilis>
or maybe just have the new thing be an index of the others
<aindilis>
like one big set of wiki disambiguation pages
anaphoric_ has joined #lisp
anaphoric has quit [Ping timeout: 244 seconds]
anaphoric_ is now known as anaphoric
sjl has quit [Quit: WeeChat 2.3-dev]
dpl has quit [Read error: Connection reset by peer]
anaphoric has quit [Quit: anaphoric]
<pjb>
I have an idea, let's write what we work on in a ~/.plan file, and let's the finger command fetch and dump this file…
anaphoric has joined #lisp
anaphoric has quit [Client Quit]
<ck_>
hold on not so fast I need to copy this down -- "let's ... the finger ... command fetch and dump the file" ok got it
<ck_>
will proceed with this plan but I will make a feint to the north-east first I'll surround them
<pjb>
aindilis: there's the notion of conformance in CL. This is stronger than portable. Portable, is only a potential. conforming is definitive.
<pjb>
aindilis: If you write conforming code, then it is guaranteed that it will run the same in all conforming implementations. No work to do, no porting of portABLE code, or whatever.
atgreen has joined #lisp
mindCrime_ has joined #lisp
kajo has quit [Ping timeout: 264 seconds]
mindCrime has quit [Ping timeout: 248 seconds]
mindCrime_ has quit [Remote host closed the connection]
JohnMS has joined #lisp
mindCrime_ has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
<Xach>
My cron job failed last night, but not to worry, it's because a lightning storm knocked out power. time to get another ups...
CloseToZero has quit [Ping timeout: 248 seconds]
<beach>
Wow.
<ck_>
There's also a 'major github outage' going on at the moment
nsrahmad has joined #lisp
MCP_ has joined #lisp
<Xach>
It wasn't me.
<Xach>
My cron job did not run as previously mentioned.
mindCrime_ has quit [Ping timeout: 258 seconds]
<ck_>
Xach: I just read your conversation with a scammer. Wonder why they're all called Solomon.
<ck_>
also I managed a straight face, but when war was beginning, I lost it.
EvW has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
Lycurgus has joined #lisp
oni-on-ion has joined #lisp
<ck_>
ah, good news -- githubstatus.com says 'error rates have dropped'. I guess the levees are holding.
mindCrime has joined #lisp
atgreen has quit [Ping timeout: 268 seconds]
hhdave has quit [Quit: hhdave]
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
abhixec has quit [Ping timeout: 258 seconds]
abhixec has joined #lisp
zgasma has quit [Quit: leaving]
EvW has quit [Ping timeout: 250 seconds]
nsrahmad has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
smazga has joined #lisp
dvdmuckle has quit [Quit: Bouncer Surgery]
orivej has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
dvdmuckle has joined #lisp
hiroaki has joined #lisp
JohnMS has quit [Quit: Konversation terminated!]
garbochock has joined #lisp
CloseToZero has joined #lisp
decent-username has joined #lisp
<decent-username>
Hi, does someone of you know how I could disable the quoting behaviour of paredit in Emacs? Right now when I type a backslash character it will quote the next key stroke, but I just want a simple backslash character.
<decent-username>
> . <
random-nick has joined #lisp
<ck_>
take a look at the keymap
garbochock has quit [Ping timeout: 245 seconds]
<ck_>
decent-username: \ is probably bound to paredit-backslash. Bind it to self-insert-command or remove the binding to get the behaviour you're looking for
themsay has quit [Ping timeout: 268 seconds]
<Xach>
decent-username: C-q \ will insert a backslash.
saravia has quit [Remote host closed the connection]
<decent-username>
thank god.
<Xach>
Deleting it will trigger some pareditness too though.
<decent-username>
o . O
<Xach>
C-q <anything> will insert that thing rather than going through fanciness, it's a generic emacs feature.
<decent-username>
I'm not an elisp hacker, so I have no clue how to rebind keys. I just started writing some function for the paredit mode hook.
karayan has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
sauvin has quit [Read error: Connection reset by peer]
mindthelion has quit [Remote host closed the connection]
<zhlyg>
housel: yes of-course, the symbols value vs its reachability/existence. Anyhow, thanks for the link. Those pre-CL lisps really seems to be the origin of the obarray concept.
_Posterdati_ has joined #lisp
<zhlyg>
Interesting style, is it to get temporary reachability of the special symbol X? (LET ((X ...)) ... (MAKUNBOUND 'X) ...) ;bad style