ebrasca has quit [Remote host closed the connection]
rtra has quit [Ping timeout: 246 seconds]
rtra has joined #lisp
atgreen has quit [Ping timeout: 265 seconds]
<aeth>
beach: The problem with the lack of hierarchical packages leading to the foo/bar package name idiom as a convention to work around that isn't the same class of problem of "add it and then the language can't be compiled". It's more likely to be in the class of problem of something that probably didn't exist back in the early 1990s so no one even thought about it.
ghard has quit [Read error: No route to host]
<aeth>
In 1995, I don't think large projects with hierarchical packages were a thing in many languages, even if possible. When I think about that, I think about Java (which is possibly the most rigid enforcing of this sort of thing, definitely not something to emulate) or Python (which definitely existed, but wasn't popular until the 2000s)
<aeth>
Both Java and Python afaik tie this sort of thing to the directory structure of the program, which is kind of a non-starter for CL.
jfb4_ has quit [Ping timeout: 265 seconds]
jfb4 has joined #lisp
lieven has quit [Ping timeout: 252 seconds]
<phoe>
yeah, ASDF's bundle-op would give you a really weird look if you tried to do that same thing
<phoe>
(among other, more obvious things)
lispyone_ has quit [Read error: Connection reset by peer]
kilimanjaro has quit [Read error: Connection reset by peer]
mjl has quit [Read error: Connection reset by peer]
splittist has quit [Read error: Connection reset by peer]
banjiewen has quit [Read error: Connection reset by peer]
Balooga has quit [Read error: Connection reset by peer]
kilimanjaro has joined #lisp
banjiewen has joined #lisp
<LdBeth>
util 1999 most Common Lisp softwares are self contained
Balooga has joined #lisp
lispyone_ has joined #lisp
splittist has joined #lisp
mjl has joined #lisp
Kaisyu has joined #lisp
<aeth>
And beyond that, the further back you go, I'd bet you'd observe that a CL project is more likely to be just all at the top level with one package, i.e. foo/*.lisp whose sole package is foo/package.lisp
CEnnis91 has joined #lisp
Kaisyu has quit [Client Quit]
teej has joined #lisp
teej has quit [Excess Flood]
<LdBeth>
and many just put things into lisp-user
<LdBeth>
before CLtL2
<HiRE>
What is the (:use :cl) used for defpackage? I mean, I would assume it means "use common lisp" but I find the notation funny since it's being written _in_ common lisp
teej has joined #lisp
MonoBobo_ has quit [Read error: Connection reset by peer]
<LdBeth>
which has many function names behaves drastically different from CL's
<aeth>
s/1164/1164 line/
<LdBeth>
in such a case a package shouldn't directly use #:common-lisp
<aeth>
So, I mean, 1990s CL is very stylistically different than 2010s CL, which is why you don't really see the need for hierarchical packages... just have one giant package.lisp contain everything with one giant defpackage > 1000-lines
jfb4_ has joined #lisp
<aeth>
These days I'm guessing you'd want at least 10 packages with a top package that does something like uiop:define-package's use-reexport instead of having a giant 1000+ line defpackage.
<Xach>
reminds me of how one of the clisp maintainers complained that quicklisp cluttered up the system by adding too many packages.
<LdBeth>
aeth: yes. It is more common to see 1 function per file today
jfb4 has quit [Ping timeout: 268 seconds]
g0d_shatter has joined #lisp
epony has quit [Quit: upgrades]
<aeth>
Xach: It is a fairly valid complaint, however it's worse to have a 1000-line DEFPACKAGE. Hierarchical packages means you get the best of both, needing to only expose one or a few top-level packages while still being able to, well, read any given DEFPACKAGE.
vivit has joined #lisp
<pjb>
HiRE: you don't necessarily write Common Lisp code to run on a Common Lisp implementation!
<aeth>
ASDF these days sort of strongly encourages a multi-package design to be FOO/BAR which is just a hack to only somewhat polute the package namespace, in a way that's very unlikely to collide
<pjb>
HiRE: This is the point of COMMON Lisp: to be able to run several different lisps!
<HiRE>
pjb, oh I see. That is the dialect indicator
MonoBobo has quit [Read error: Connection reset by peer]
rwcom4 has joined #lisp
<pjb>
HiRE: so for example, when you write a CLIM application, you don't use CL, you use CLIM instead. You don't get the same defclass and defmethod macros amongst other changes.
<HiRE>
Interesting. That's good to know. It was sort of given matter-of-factly in PCL so I was curious
<aeth>
A clever specification of hierarchical packages could probably define it in a way that's compatible both with unmodified CL implementations and extended ones, but then it would assign semantic meaning to / in the name of a packags.
<HiRE>
> Rendez-vous in 28 years to see how you can run a 1996 perl program in perl 2042...
<HiRE>
shots fired
<pjb>
HiRE: this is why any criticism of Common Lisp is usually untimely, since you can just define your own lisp package and use it instead of CL.
<pjb>
I could have written Python 2.7 :-)
rwcom has quit [Ping timeout: 258 seconds]
rwcom4 is now known as rwcom
epony has joined #lisp
<LdBeth>
or there's :zetalisp on a lisp machine
tfb has joined #lisp
<pjb>
In 1990, you wouldn't fetch thousands of libraries from the Internet… Software Engineering of CL software has much improved during the last 20 years, only thanks to asdf, quicklisp and the Internet.
<aeth>
hmm, actually you could define separator characters in hierarchical packages and so if you want #\\ or #\. or #\/ then no matter what you can have it.
smazga has quit [Quit: leaving]
<aeth>
HiRE: as far as (:use :cl) goes, you could e.g. (:use :r7rs) and get R7RS Scheme with symbols such as |car| and |cdr| and |list| instead of CAR and CDR and LIST
<aeth>
CL has always been a language for writing languages. It would be far easier to do something like JS's TypeScript in CL than it is in JS, and it would be "built-in" rather than an additional compilation step
<HiRE>
thats so interesting. I guess thats the power of lisp. Makes sense, just mindboggling coming from a professional programming life of if you write it one language everything must be in that language
<HiRE>
its pretty neat you can cleanly integrate so many different dialects
<Xach>
everything must be in lisp
<HiRE>
aeth, rumor has it Javascript is just a poor attempt at implementing CL
<aeth>
As far as doing something like TypeScript in CL, it's almost an introductory project to do a type-declared DEFUN macro. There are probably like 50 of those. There's at least one that's fancier than that and tries to do a fancier ML-style type system, though.
<aeth>
HiRE: Scheme, not CL. The author of JS was originally going to implement a Scheme, but that was rejected based on the syntax. Not much was borrowed from Scheme, although since idk 2007 or so people have been adding parts of Scheme to JS to try to justify the origin myth.
<aeth>
So at this point "JS is inspired by Scheme" is probably true, even though it was once false.
<HiRE>
oh I didnt even realize it was at least a partial truth. I figured it was just another jab using greenspun's 10th rule.
<Xach>
Shinmera: what should i do about identically-named system files in maiden?
theBlackDragon has quit [Remote host closed the connection]
kilimanjaro has quit [Read error: Connection reset by peer]
Balooga has quit [Read error: Connection reset by peer]
rme has quit [Ping timeout: 250 seconds]
rvirding has quit [Ping timeout: 245 seconds]
billstclair has quit [Ping timeout: 245 seconds]
banjiewen has quit [Ping timeout: 272 seconds]
bytesighs has quit [Ping timeout: 252 seconds]
lispyone_ has quit [Ping timeout: 260 seconds]
hydan has quit [Ping timeout: 260 seconds]
<pjb>
Well, any good programming language designer would have to know lisp and scheme, amongst a lot of other programming languages. So you can always say that a new programming language is inspired by scheme (or lisp). But this is definitely not a guarantee of quality for the new language.
jsatk has quit [Ping timeout: 250 seconds]
drmeister has quit [Read error: Connection reset by peer]
splittist has quit [Ping timeout: 260 seconds]
johs has quit [Ping timeout: 250 seconds]
mjl has quit [Ping timeout: 260 seconds]
lukego has quit [Ping timeout: 260 seconds]
teej has quit [Ping timeout: 272 seconds]
gendl has quit [Ping timeout: 246 seconds]
badgerblock has quit [Ping timeout: 245 seconds]
XachX has quit [Ping timeout: 245 seconds]
mgsk has quit [Ping timeout: 252 seconds]
jhei has quit [Ping timeout: 260 seconds]
sgithens has quit [Ping timeout: 260 seconds]
physpi has quit [Ping timeout: 248 seconds]
selwyn has quit [Ping timeout: 250 seconds]
tazjin has quit [Ping timeout: 260 seconds]
avicenna has quit [Ping timeout: 248 seconds]
chewbranca has quit [Ping timeout: 272 seconds]
CEnnis91 has quit [Ping timeout: 260 seconds]
gjnoonan has quit [Ping timeout: 260 seconds]
theBlackDragon has joined #lisp
pent has quit [Ping timeout: 272 seconds]
karlosz has joined #lisp
tfb has quit [Ping timeout: 246 seconds]
parisienne_ has quit [Ping timeout: 248 seconds]
travv0 has quit [Ping timeout: 272 seconds]
stylewarning has quit [Ping timeout: 250 seconds]
<aeth>
pjb:
<aeth>
oops, my numpad "enter was hit" somehow
<aeth>
pjb: The problem with "inspired by Lisp" is that you could make that claim for nearly any modern language because Lisp used to have features that no one else did, like GC
<aeth>
But these days, saying your language is "inspired by Lisp" just because it has a GC would be incredibly misleading because people think about the features that still distinguish Lisps from the rest, like the numeric tower
<aeth>
s/"enter was hit"/"enter" was hit/
p_l has quit [Ping timeout: 246 seconds]
Kevslinger has quit [Ping timeout: 248 seconds]
badgerblock has joined #lisp
jlpeters has quit [Ping timeout: 260 seconds]
jerme_ has quit [Ping timeout: 272 seconds]
MonoBobo has joined #lisp
nirved has quit [Ping timeout: 252 seconds]
nirved has joined #lisp
turona has quit [Ping timeout: 272 seconds]
turona has joined #lisp
fowlduck has quit [Ping timeout: 246 seconds]
lansiir has joined #lisp
oldtopman has quit [Quit: *pouf*]
badgerblock has quit [Ping timeout: 272 seconds]
rdh has joined #lisp
Achylles has quit [Remote host closed the connection]
Oladon has joined #lisp
pent has joined #lisp
aeth_ has joined #lisp
asdf_asdf_asdf has quit [Quit: asdf_asdf_asdf]
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
EvW1 has quit [Ping timeout: 245 seconds]
<pjb>
aeth: indeed, "inspired by lisp" is a problem. Foremost when they deliberately masacre lisp to make their language, like Matsumoto created Ruby the matsacred lisp…
_jrjsmrtn has quit [Ping timeout: 268 seconds]
__jrjsmrtn__ has joined #lisp
pent has quit [Ping timeout: 272 seconds]
phlim has quit [Quit: WeeChat 2.4]
jfb4 has joined #lisp
jfb4_ has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
quazimodo has quit [Ping timeout: 260 seconds]
quazimodo has joined #lisp
ebrasca has joined #lisp
sgithens has joined #lisp
johs has joined #lisp
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
sgithens has quit [Ping timeout: 246 seconds]
johs has quit [Ping timeout: 272 seconds]
fowlduck has joined #lisp
william1 has quit [Ping timeout: 265 seconds]
shifty has quit [Ping timeout: 268 seconds]
rtra has quit [Ping timeout: 245 seconds]
shifty has joined #lisp
rtra has joined #lisp
fowlduck has quit [Ping timeout: 272 seconds]
rtra has quit [Ping timeout: 272 seconds]
shifty has quit [Ping timeout: 272 seconds]
vms14 has quit [Remote host closed the connection]
Nilby has left #lisp ["👽愛🆑"]
shifty has joined #lisp
rtra has joined #lisp
hlavaty` has joined #lisp
pent has joined #lisp
hlavaty has quit [Ping timeout: 260 seconds]
jhei has joined #lisp
pent has quit [Ping timeout: 272 seconds]
<aeth>
pjb: On the other hand, technically speaking, Common Lisp is an "inspired by Lisp" language.
mjl has joined #lisp
pent has joined #lisp
pent has quit [Max SendQ exceeded]
rwcom4 has joined #lisp
rwcom has quit [Ping timeout: 260 seconds]
rwcom4 is now known as rwcom
dddddd has quit [Ping timeout: 265 seconds]
pent has joined #lisp
shifty has quit [Ping timeout: 268 seconds]
mjl has quit [Ping timeout: 246 seconds]
jhei has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
pent has quit [Max SendQ exceeded]
atgreen has joined #lisp
rtra has quit [Ping timeout: 260 seconds]
jhei has joined #lisp
rtra has joined #lisp
pent has joined #lisp
rdh has quit [Quit: Leaving]
billstclair has joined #lisp
shifty has quit [Remote host closed the connection]
shifty has joined #lisp
ebrasca has quit [Remote host closed the connection]
jhei has quit [Ping timeout: 245 seconds]
jhei has joined #lisp
shifty has quit [Ping timeout: 258 seconds]
rtra has quit [Ping timeout: 245 seconds]
rtra has joined #lisp
pent has quit [Ping timeout: 260 seconds]
jhei has quit [Ping timeout: 246 seconds]
X-Scale` has joined #lisp
rtra has quit [Ping timeout: 246 seconds]
pent has joined #lisp
X-Scale has quit [Ping timeout: 272 seconds]
X-Scale` is now known as X-Scale
rtra has joined #lisp
pent has quit [Max SendQ exceeded]
billstclair has quit [Ping timeout: 265 seconds]
rumbler31 has quit [Remote host closed the connection]
Lord_of_Life_ has joined #lisp
ahungry has joined #lisp
pent has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
rtra has quit [Remote host closed the connection]
rtra has joined #lisp
pent has quit [Max SendQ exceeded]
remexre has joined #lisp
william1 has joined #lisp
jack_rabbit has quit [Ping timeout: 265 seconds]
jfb4_ has joined #lisp
akoana has left #lisp ["Leaving"]
rtra has quit [Ping timeout: 272 seconds]
splittist has joined #lisp
jfb4 has quit [Ping timeout: 260 seconds]
<pjb>
aeth: Definitely. And it has been criticized as such. And it has the same success relatively as the other ones.
pent has joined #lisp
ahungry has quit [Remote host closed the connection]
g0d_shatter has quit [Remote host closed the connection]
pent has quit [Ping timeout: 272 seconds]
william1_ has joined #lisp
william1 has quit [Ping timeout: 268 seconds]
jfb4 has joined #lisp
jfb4_ has quit [Ping timeout: 240 seconds]
rtra has joined #lisp
william1_ has quit [Ping timeout: 272 seconds]
milanj has quit [Quit: This computer has gone to sleep]
rtra has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
splittist has quit [Ping timeout: 260 seconds]
lemoinem has quit [Killed (orwell.freenode.net (Nickname regained by services))]
lemoinem has joined #lisp
slyrus has joined #lisp
slyrus__ has quit [Ping timeout: 258 seconds]
Krystof has quit [Ping timeout: 260 seconds]
rtra has joined #lisp
Oladon has quit [Quit: Leaving.]
torbo has joined #lisp
aeth has quit [Read error: Connection reset by peer]
hlavaty` has quit [Ping timeout: 260 seconds]
vivit has quit [Ping timeout: 268 seconds]
Bike has quit [Quit: Lost terminal]
aeth has joined #lisp
decent-username has joined #lisp
gravicappa has joined #lisp
splittist has joined #lisp
Codaraxis has quit [Read error: Connection reset by peer]
splittist has quit [Ping timeout: 260 seconds]
Oladon has joined #lisp
<White_Flame>
aeth: common lisp has direct lisp lineage; it's not some new offshoot that only takes inspiration without continuance of design
<White_Flame>
so I don't quite think that works as described
<aeth>
It doesn't go the other way around, though. [[Lisp]] has Common Lisp under "Dialects" not "Influenced"
<White_Flame>
but still, that's influence, not inspiration ;)
oxum has quit [Remote host closed the connection]
asarch has joined #lisp
<asarch>
One stupid question: I do the query (let ((results (query "SELECT * FROM foo"))) and then I parse every record in the query (loop for record in results do ..., question: how could I initialize a counter from 0 and increment its value on every iteration inside the loop expression?
<beach>
asarch: Because you are setting it to 0 in every iteration.
<asarch>
D'oh! I thought the iteration was only the do part
<asarch>
Just like the old for (int i = 1, j = 2; ...)
<no-defun-allowed>
minion: tell seok about Universal Greeting Time
<minion>
seok: look at Universal Greeting Time: It is always morning when a person enters a channel, and late night when they leave. You may want to read http://www.total-knowledge.com/~ilya/mips/ugt.html for further information
<seok>
Gosh
<holycow>
does anyone know jackdaniels page where he posts mcclim updates?
torbo has quit [Remote host closed the connection]
raghavgururajan has quit [Remote host closed the connection]
<jackdaniel>
orthogonal features like complement make a lot of sense from a learning perspective, but deprecated in case of CL means: it will be around for another three standard revisions
<jackdaniel>
and we don't even know if there will be the next one ;)
<lieven>
there are a bunch of functions in CL that are used a lot less
hhdave has joined #lisp
<lieven>
after SETF they could deprecate RPLACD and similar mutators
<galdor>
it's faster to type than remove-if + complement so it's all good
<jackdaniel>
you may always define an abbreviation (~ test)
karlosz has quit [Quit: karlosz]
william1 has joined #lisp
orivej has joined #lisp
ym has joined #lisp
montaropdf has left #lisp ["WeeChat 2.4"]
montaropdf has joined #lisp
<aeth>
You all covered pretty much every point in one of the strangest CL flamewar topics except also... remove-if-not is faster unless the compiler optimizes remove-if complement, which the compiler authors are less incentivized to do because remove-if-not exists, even though remove-if-not is deprecated
<aeth>
Last time it came up, SBCL didn't have it optimized, but who knows?
Posterdati has quit [Read error: Connection reset by peer]
zmt01 has quit [Ping timeout: 260 seconds]
davepdotorg has joined #lisp
Posterdati has joined #lisp
<lieven>
it's doable by a compiler-macro on remove-if so they easily could if they wanted
<aeth>
lieven: Last time it was brought up (although for all I know it was implemented 15 SBCLs ago) it wasn't quite as trivial as it sounds, but imo the key thing it shows is that it wasn't seen as particularly idiomatic or else it would have been optimized already.
<heisig>
lieven: Heh, 'easily'. Have you ever tried parsing keyword arguments in a compiler macro :)
Posterdati has quit [Read error: Connection reset by peer]
<heisig>
And there is the problem that you couldn't optimize (let ((g (complement f))) (remove-if g x)), because the compiler macro only sees 'g'.
<aeth>
heisig: re keywords, is there a way to get to the point where you can use destructuring-bind? I've never written a compiler macro
<lieven>
heisig: sure. the whole point of optimizing is to get the low hanging fruit. if people are deliberately obfuscating their code, they can live with the default speed
Lycurgus has joined #lisp
<heisig>
aeth: Hmm, one could check that every second argument is a valid keyword, and then use destructuring-bind. Then one would still have to make sure that the order of evaluation is preserved.
Posterdati has joined #lisp
<beach>
Yes, that's the tricky part.
rtra has quit [Ping timeout: 272 seconds]
rtra has joined #lisp
wxie has quit [Ping timeout: 245 seconds]
william1_ has joined #lisp
frgo has quit []
william1_ has quit [Ping timeout: 265 seconds]
william1_ has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
chimneys has joined #lisp
frgo has joined #lisp
zmt00 has joined #lisp
wxie has joined #lisp
rtra has quit [Ping timeout: 240 seconds]
jonatack has quit [Quit: jonatack]
mingus has quit [Remote host closed the connection]
g0d_shatter has quit [Quit: Leaving]
milanj has quit [Quit: This computer has gone to sleep]
milanj has joined #lisp
jonatack has joined #lisp
wxie has quit [Ping timeout: 258 seconds]
Lycurgus has quit [Remote host closed the connection]
MonoBobo has quit [Ping timeout: 265 seconds]
narimiran has quit [Read error: Connection reset by peer]
narimiran has joined #lisp
mnmx has joined #lisp
chimneys has quit [Read error: No route to host]
dddddd has joined #lisp
mnmx has left #lisp [#lisp]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 258 seconds]
jonatack has quit [Ping timeout: 245 seconds]
orivej has quit [Ping timeout: 268 seconds]
imherentlybad has joined #lisp
<phoe>
if we have CL:REMOVE and CL:REMOVE-IF, why not have CL:RETAIN and CL:RETAIN-IF
* phoe
ducks
<heisig>
phoe: Issue TEST-NOT-IF-NOT Writeup: "Several alternative names for REMOVE-IF-NOT were suggested: KEEP-IF, ABSTRACT, FILTER. We did not pursue these suggestions."
m00natic has joined #lisp
brown121408 has joined #lisp
brown121407 has quit [Read error: Connection reset by peer]
<galdor>
did someone already this issue where emacs open all flexi-streams files when loading the system in slime ?
<phoe>
heisig: IMO twenty+ years of Common Lisp practice have shown that the future ANSI CL committee should likely pursue them at some point in time
mingus has joined #lisp
Achylles has joined #lisp
<heisig>
Even if there ever was a new standard, there cannot be any changes to the CL package. Otherwise, this new standard would break existing code.
<heisig>
I think it would be hilarious if there was a new CL standard, and it would essentially be 'We fixed a few typos and clarified a few descriptions'.
<heisig>
Imagine the faces of the C++ guys :D
frgo has quit [Remote host closed the connection]
<scymtym>
"typo fixes and clarifications? why didn't you add lambdas and compile-time metaprogramming? everybody has those nowadays"
frgo has joined #lisp
imherentlybad has quit [Quit: WeeChat 2.6]
tiwEllien has quit [Ping timeout: 268 seconds]
milanj has quit [Quit: This computer has gone to sleep]
amerlyq has joined #lisp
montaropdf has quit [Ping timeout: 240 seconds]
montaropdf has joined #lisp
flip214 has quit [Ping timeout: 258 seconds]
<phoe>
"oh shit, right, we forgot to add those to lisp"
flip214 has joined #lisp
jonatack has joined #lisp
rtra has joined #lisp
longshi has joined #lisp
Kevslinger has quit [Quit: Connection closed for inactivity]
asdf_asdf_asdf has joined #lisp
entel has joined #lisp
ggole has joined #lisp
Achylles has quit [Ping timeout: 272 seconds]
Achylles has joined #lisp
milanj has joined #lisp
notzmv has quit [Remote host closed the connection]
rumbler31 has joined #lisp
hsaziz has joined #lisp
oxum_ has joined #lisp
oxum_ has quit [Remote host closed the connection]
ozzloy has quit [Ping timeout: 265 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
oxum has quit [Ping timeout: 240 seconds]
vivit has joined #lisp
vivit has quit [Client Quit]
oxum has joined #lisp
hsaziz has quit [Ping timeout: 240 seconds]
asdf_asdf_asdf has quit [Remote host closed the connection]
oxum has quit [Remote host closed the connection]
oxum has joined #lisp
asdf_asdf_asdf has joined #lisp
kajo has quit [Ping timeout: 272 seconds]
gxt has quit [Ping timeout: 240 seconds]
jonatack has quit [Ping timeout: 258 seconds]
ebrasca has joined #lisp
kajo has joined #lisp
rtra has quit [Ping timeout: 265 seconds]
smokeink has quit [Ping timeout: 265 seconds]
asdf_asdf_asdf has quit [Remote host closed the connection]
Nilby has joined #lisp
william1 has quit [Ping timeout: 258 seconds]
asdf_asdf_asdf has joined #lisp
ebzzry has joined #lisp
asdf_asdf_asdf has quit [Remote host closed the connection]
asdf_asdf_asdf has joined #lisp
JohnMS has joined #lisp
EvW has joined #lisp
JohnMS_WORK has quit [Ping timeout: 268 seconds]
Achylles has quit [Ping timeout: 272 seconds]
LiamH has joined #lisp
Achylles has joined #lisp
zmv has joined #lisp
Achylles has quit [Remote host closed the connection]
Bike has joined #lisp
hjudt has quit [Quit: leaving]
flamebeard has quit [Remote host closed the connection]
flamebeard has joined #lisp
kajo has quit [Quit: From my rotting body, flowers shall grow and I am in them and that is eternity. -- E. M.]
kajo has joined #lisp
EvW has quit [Ping timeout: 246 seconds]
flamebeard has quit [Ping timeout: 265 seconds]
hjudt has joined #lisp
william1_ has quit [Quit: WeeChat 2.6]
<pfdietz>
Lambda the New Lambda
Necktwi has quit [Read error: Connection reset by peer]
Lycurgus has joined #lisp
Kevslinger has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<pfdietz>
slyrus: I have let the power of being able to merge pull requests in fset go to my head, and have merged one of yours from 2018.
Necktwi has joined #lisp
<_death>
pfdietz: good to hear
lucasb has joined #lisp
chimneys has joined #lisp
<chimneys>
hi
<chimneys>
I need help installing cl-jupyter can't install quicklisp
<chimneys>
I open I see sbcl inside it, but it says kernel connecting and cells don't execute
<chimneys>
A connection to the notebook server could not be established. The notebook will continue trying to reconnect. Check your network connection or notebook server configuration.
Necktwi has quit [Ping timeout: 260 seconds]
frgo has quit [Ping timeout: 265 seconds]
<Xach>
montaropdf has quit [Ping timeout: 265 seconds]
<chimneys>
Xach: hi
Necktwi has joined #lisp
montaropdf has joined #lisp
dnaeon has joined #lisp
flamebeard has joined #lisp
<dnaeon>
hey all! i have two packages that export the same symbols, e.g. package `A:foo` and then I have package `B:foo`. How could I import these symbols into my own package and use both `A:foo` and `B:foo`? Any way I could import-alias them or similar?
montaropdf has quit [Ping timeout: 268 seconds]
<jackdaniel>
basically you can't import two different symbols with the same name into the same package
<chimneys>
jackdaniel: hello
<jackdaniel>
you may use them like you've shown -- a:foo accesses symbol foo from package a
<jackdaniel>
and b:foo from package b
<chimneys>
how do i install the new kernel cl-jupyter , is it not installing because of virtual envs
<phoe>
dnaeon: you don't need to import them if you use a full package prefix
<pjb>
dnaeon: you can also consider whether those two foos are actually the same. For example, it may be the name of a generic function and a:foo is a method on As, while b:foo is a method on Bs. Then both packages A and B should use a package I that exports FOO and (defgeneric foo (…)).
Remavas has quit [Remote host closed the connection]
<pjb>
dnaeon: other similar cases exist.
<phoe>
if the package names are long, you can also use package-local nicknames
<pjb>
dnaeon: of course, it may be two entirely different foos, such as cl:car and tesla:car…
<phoe>
so if you have symbols QWERTYUIOP:FOO and ASDFGHJKL:FOO, you can local-nickname the packages to Q and A
<pjb>
reading long (structured) names is not a problem in general.
<phoe>
and refer to these symbols as Q:FOO and A:FOO inside your code.
<pjb>
Typing them is not either, since you have emacs abbrev and auto-complete…
* jackdaniel
squeezes out of the helping crowd
<chimneys>
jackdaniel: there is no crowd it's just me
<chimneys>
and my virtual envs
<phoe>
I actually have no idea how cl-jupyter works
<chimneys>
phoe: but installation is a different matter
<jackdaniel>
chimneys: I know that venv is some clever mechanism to bypass problems with the packaging, toher than that I try to not think about things like this
<dnaeon>
Ok, I was under the impression that if I use `(defpackage my-package (:use :A :B))` then within my package all symbols from `A` and `B` would inherited and cannot fully qualify things such as `A:foo` and `B:foo`.
milanj has joined #lisp
frgo has joined #lisp
jprajzne_ has joined #lisp
jprajzne has quit [Read error: Connection reset by peer]
jprajzne_ is now known as jprajzne
<dnaeon>
Maybe I misread the documentation, let me try these things, thanks all!
<chimneys>
if you don't like to think about it , think what a beginner might be going through who is pasting lisp cmds without understanding them
frgo_ has quit [Remote host closed the connection]
frgo_ has joined #lisp
<Shinmera>
it's not his job to help you out with your problem, nor is it his problem.
<Shinmera>
*nor is it his project
<phoe>
chimneys: I actually have no idea how cl-jupyter installation works
jprajzne has quit [Client Quit]
tiwEllien has joined #lisp
<phoe>
dnaeon: actually you can do that
<chimneys>
Shinmera: ok
frgo has quit [Read error: Connection reset by peer]
<phoe>
USEing a package means that you can refer to all of its symbols without qualifying them with the package name
jprajzne has joined #lisp
EvW1 has joined #lisp
z147 has joined #lisp
<dnaeon>
phoe: got it, thanks!
<chimneys>
Shinmera: then it is your job
<pjb>
dnaeon: you can always use symbol qualification. (eq 'foo 'cl-user::foo) #| --> t |#
<phoe>
so e.g. USEing :alexandria means that you can (assoc-value '((1 . :one)) 1)
<phoe>
also, if you use packages A and B, they cannot export symbols with the same names
<phoe>
because then conflicts occur, and you need to explicitly choose one or the other or not use both packages at the same time.
<pjb>
phoe: obviously not, as I showed just above!!!
<Shinmera>
chimneys: you're setting yourself up for disappointment if you think that.
<phoe>
There's also the issue if an USEd package decides to change its export list later on, e.g. because it decides to export new functionalities. It means that sudden use conflicts can arise even when you do absolutely *nothing* - only because a dependency has changed.
<pjb>
If two packages export symbols with the same name, you can use them, shadowing this name!
<chimneys>
Shinmera: enemies of jupyter notebooks
<phoe>
pjb: yes, I meant that by explicitly using one or the other - by means of SHADOW or SHADOWING-IMPORT-FROM
<phoe>
chimneys: you're just rude now
<phoe>
and I don't think that you have a support contract with Shinmera to be able to tell him that it's his job to help you out
<Shinmera>
I think Jupyter is terrible, but that's neither here nor there.
<phoe>
perhaps if no users of cl-jupyter are in here, you could try raising a GitHub issue with the details
rtra has joined #lisp
<phoe>
I think it'll capture the maintainers' attention more surely than expressing slightly immature behaviour on IRC
<beach>
chimneys: Maybe you have misunderstood the purpose of #lisp. It is not a support channel for newbies. It is a forum for discussing the language, its implementations, libraries, and applications between users of Common Lisp.
<chimneys>
beach: ok but there was no one is #lispcafe talking to me
<Bike>
we do try to help people out, but you get what you pay for
<galdor>
I guess the community is so small everyone ends up here
<galdor>
not enough people in each subgroup to have something sustainable
<phoe>
#clschool is also somewhat active though
random-nick has joined #lisp
montaropdf has joined #lisp
<dlowe>
IRC is pretty niche in itself too
<dlowe>
so here you're getting a niche within a niche
Kaisyu has quit [Quit: Connection closed for inactivity]
<galdor>
are there other general CL communities ? I mean there used to be the pro-lisp mailing list but it's dead
<galdor>
and comp.lang.lisp is a swamp
<jackdaniel>
there are. I think there is a discord server
Lycurgus has quit [Remote host closed the connection]
<jackdaniel>
there are mailing lists hosted by common-lisp.net
<jackdaniel>
and there are repositoreis on gitlab.common-lisp.net (so you could say that cl.net users form some kind of a community)
<jackdaniel>
there is planet.lisp.org maintained by Xach which aggregates lisp blogs
<phoe>
and comp.lang.list is not a friendly place anymore
Lord_of_Life_ has joined #lisp
<jackdaniel>
I've never managed to configure usenet client properly, probably I'm too young :) but I've been told I've avoided plenty of bad experience, so :)
jack_rabbit has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
EvW1 has quit [Ping timeout: 248 seconds]
scymtym_ has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
<pfdietz>
comp.lang.lisp! I haven't used usenet in years. Is it all spam now?
<phoe>
mostly
<pfdietz>
It wouldn't be the same without Naggum
<phoe>
with an occasional worthwhile post from Jim Newton who seems to be magically immune to all of the shitposts that happen there
heisig has quit [Quit: Leaving]
nowhere_man has joined #lisp
frgo_ has quit [Remote host closed the connection]
frgo has joined #lisp
moldybits has quit [Quit: WeeChat 2.4]
frgo has quit [Ping timeout: 258 seconds]
bitmapper has joined #lisp
picantest has quit [Ping timeout: 258 seconds]
nowhere_man has quit [Ping timeout: 268 seconds]
picantest has joined #lisp
dnaeon has quit [Ping timeout: 260 seconds]
<pjb>
and there's http://cliki.net that references all those channels and more…
zmv has quit [Ping timeout: 268 seconds]
dnaeon has joined #lisp
<galdor>
cliki is full of obsolete and wrong information infortunately
<galdor>
who owns it btw ? "Stichting Common Lisp Foundation" is unknown to me
<beach>
To you maybe, but not to many others.
<beach>
The people behind it are regulars at ELS and there have been presentations about its purpose, its organization, etc.
<beach>
The have had fundraisers for Common Lisp projects.
mingus has quit [Read error: Connection reset by peer]
mingus has quit [Read error: Connection reset by peer]
frgo has joined #lisp
igemnace has quit [Remote host closed the connection]
<montaropdf>
jackdaniel: it is just an update in the matrix ;)
<jackdaniel>
heh
<chimneys>
there are only 3 volunteers mark,erik and mariano
smazga has joined #lisp
<jackdaniel>
if you chip in with your expertise there will be four. that said they do a tremendous job. you may want to say hi on #common-lisp.net
<jackdaniel>
or "thanks" of course
<pjb>
galdor: YOU are responsible to update the wiki! cliki.net is a wiki, if YOU find someting wrong, YOU must correct it!
frgo has quit [Ping timeout: 268 seconds]
<galdor>
I guess it is the same things with sending patches, it's all fun and all, then you realize you are mostly alone in it and abandon
<galdor>
which isn't productive, but you get the idea
frgo has joined #lisp
frgo has quit [Remote host closed the connection]
<jackdaniel>
well, I often find up to date information on cliki
<jackdaniel>
and sometimes I update it, so I'd say it isn't dead
frgo has joined #lisp
<jackdaniel>
it just smells funny ;p
<galdor>
next time I find something wrong I'll edit it :)
<jackdaniel>
thank you, I'm sure someone will benefit from it
gabiruh has joined #lisp
<easye>
chimneys: that volunteer list needs to be updated. flip214 has been putting in a lot of effort as well.
<chimneys>
but the site has only one top admin who control everything? because i see the mainatainer changing
Kaisyu has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
oni-on-ion has joined #lisp
Nilby has joined #lisp
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
mingus has joined #lisp
dnaeon has quit [Ping timeout: 260 seconds]
montaropdf has quit [Quit: See you later]
Josh_2 has joined #lisp
frgo_ has joined #lisp
frgo has quit [Ping timeout: 268 seconds]
<beach>
The description of TRACE in the SBCL manual mentions that "breakpoints" are used when :ENCAPSULATE is NIL. TRACE is can perform actions upon function entry and before function exit, and one possible action is to stop execution (break).
<beach>
But does anyone happen to know how these breakpoints work, and whether these breakpoints are available at other places in the code, and if so, how to set/clear them?
<beach>
s/is can/can/
narimiran has quit [Ping timeout: 265 seconds]
jprajzne has quit [Remote host closed the connection]
<Nilby>
I used things like sb-di:make-breakpoint sb-di:activate-breakpoint in my debugger. I don't really know how they work though.
<beach>
Let me check those out. Thanks.
<Nilby>
I do know you have to set an sbcl specific handler if you want to step through code.
ljavorsk_ has quit [Ping timeout: 268 seconds]
<beach>
Sure. The stepper documentation mentions that it is "instrumentation based", and for stepping to be available, the DEBUG quality must be greater than all of speed, space, and compilation-speed.
<beach>
I take "instrumentation based" to mean that it also uses "breakpoints".
<beach>
But there does not seem to be any documentation for sb-di:make-breakpoint etc., other than the docstrings.
<Nilby>
True. I'm very very used to that situation though.
jprajzne has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
<beach>
Ah, there are some comments in the code.
<Nilby>
I probably should have documented what I discoverd about it, but I didn't feel qualified.
<Nilby>
But very few people write debuggers anyway.
flamebeard has quit []
karlosz has joined #lisp
<beach>
It appears only TRACE uses MAKE-BREAKPOINT.
jprajzne has quit [Read error: Connection reset by peer]
jprajzne has joined #lisp
<Nilby>
Thankfully the code in debug-int.lisp has a lot of nice comments. I sometimes wish they were in the docstrings though.
<beach>
AHA, the comment in the stepper says it works differently. It says that the compiler inserts "STEP-CONDITION signalling [sic] forms into code compiled at high debug settings, and having a handler for them at the toplevel."
dale has joined #lisp
<beach>
So it does not use breakpoints.
<Nilby>
I didn't think it did, otherwise I would have had to handle tracing in the debugger.
<karlosz>
Nilby: docstrings don't usually describe implementation details
<beach>
Nilby: Not quite sure what you mean by that, but I think I have enough information for the "Previous work" section of my paper.
kajo has quit [Ping timeout: 260 seconds]
<Nilby>
karlosz: Right, but when you have a huge comment in the code, and no docstring in an external interface function, I wish they would have just copied a few lines into the docstring. I feel like old code didn't want to bloat memeory with docstrings.
<karlosz>
yes, it's understandable given the compiler was written in 1985-1991
<karlosz>
there's a feature called sb-doc that will even remove docstrings from standard library functions (and extensions etc.) because it will save memory in the core image
<beach>
Wow.
<Nilby>
I want the opposite function. Put all the docstrings back, even the ones that aren't there.
<_death>
just (require :sb-contributor)
<karlosz>
i mean you need the source to understand the implementation anyway, i don't see why its advantageous ot have it in a docstring
brown121408 has quit [Ping timeout: 240 seconds]
brown121408 has joined #lisp
<karlosz>
actually a lot of the implementation details are in a manual, rather than a docstring ;)
jprajzne has quit [Read error: Connection reset by peer]
<beach>
There is an "internals" documentation, but it doesn't mention breakpoints as far as I can tell.
<Nilby>
Not understanding doesn't seem to stop me. Not knowing what of types arguemnts should be does though. Although I guess I could ask the compiler's type inference. :-)
<pjb>
beach: instrumenting the code with signal forms is a nifty way to do it!
<Nilby>
death: Funny, I don't seem to have that package.
<pjb>
Perhaps I could redo cl-stepper with this technique, it seems a lighter instrumentation.
<karlosz>
beach: that's because that's not a real internals documentation manual
<karlosz>
and yes, it documents the breakpoint functionality
<beach>
karlosz: AHA! Thanks!
<karlosz>
SBCL's compiler is just the CMUCL compiler without the documentation
<karlosz>
its absurd
<Nilby>
karloz: Wow. Thanks! I didn't know about that.
thecoffemaker has quit [Read error: Connection reset by peer]
jprajzne has joined #lisp
thecoffemaker has joined #lisp
<karlosz>
yep. for the next SBCL release i added a new section called "Advanced Compiler Use and Efficiency Hints" which says to read the CMUCL user manual because they describe how to optimize code for the compiler (which hasn't changed) in 100x more detail
<karlosz>
with a whopping 50 pages of optimization tricks and descriptions of how the compiler works
<karlosz>
and the cmucl internals manual is ~300 pages of that
davepdotorg has quit [Ping timeout: 272 seconds]
brown121407 has joined #lisp
brown121408 has quit [Read error: Connection reset by peer]
<beach>
Given that SBCL has these breakpoints, it is very surprising that no real source-level interactive debugger exists for SBCL. Unless of course, I am missing something obvious.
<beach>
I mean, SLIME could provide a key sequence to set a breakpoint in the code indicated by the editor point.
<Nilby>
I'm working on it right now in the 17th alternate universe.
<beach>
Great!
<Nilby>
Too bad were stuck in this crap timeline.
<karlosz>
beach: there does?
zmv has joined #lisp
zmt00 has quit [Quit: Leaving]
<karlosz>
i mean the functionality is all there. i don't think its the compilers job to deal with things like have source level interaction
<karlosz>
i think the reason there wasn't any in the compiler is because in CMUCL hemlock provided it
<beach>
That sounds plausible.
<karlosz>
in any case, it's definitely within the domain of SLIME to add something like that
ebzzry has quit [Ping timeout: 260 seconds]
<karlosz>
unclear how to do source level interaction without an editor interface to the compiler
<karlosz>
to me
<beach>
Absolutely.
<beach>
That's why I suggested SLIME. Or do you mean something else?
zmt00 has joined #lisp
frgo_ has quit [Ping timeout: 268 seconds]
<karlosz>
oh yes i meant SLIME
<karlosz>
i think hemlock does provide integration
<beach>
I am looking at the Hemlock documentation, and I don't see it.
<karlosz>
speaking of CMUCL, the next release of SBCL will have whole program optimization a la CMUCL block-compilation
<karlosz>
so you can finally have your unboxed floating point calls and returns where you please
<beach>
Great!
rtra has quit [Quit: WeeChat 2.3]
<Xach>
I'm sick of local-only optimizations so this is great news
<beach>
Anyway, thanks for all the information. Time for me to go have dinner with my (admittedly small) family and then spend time with her.
<HiRE>
pz beach
<Nilby>
Does cmu compile 64 bit yet?
<HiRE>
I was actually wondering how to effectively debug CL in SBCL
<HiRE>
it seems gross and messy
<karlosz>
yes, cmucl has done amd64 since 2004
<_death>
what is meant by "whole-program" in this context? i.e. how global is it?
<karlosz>
as global as you want it to be
<karlosz>
on a file level granualirty
<karlosz>
at least, a file level granularity for the next release
<karlosz>
CMUCL has better granularity though
<karlosz>
its amazing how much stuff they had that SBCL doesn't
<karlosz>
it's a shame because they've faded away from awareness over time
<karlosz>
i'll write a post about this Real Soon
scymtym__ has joined #lisp
<karlosz>
the block compilation i mean
scymtym_ has quit [Remote host closed the connection]
jprajzne has quit [Read error: Connection reset by peer]
z3n3 has joined #lisp
<_death>
cool, will wait for it ;)
hhdave has quit [Quit: hhdave]
jprajzne has joined #lisp
varjag has joined #lisp
<Nilby>
Thanks karlosz for removing my excuses for ignorance. :)
<asarch>
We could even do: (query nasa-session ...) ... (query ibm-session ...) ... (query 4chan-session ...)
z3n3 has joined #lisp
cosimone has joined #lisp
z3n3 has quit [Client Quit]
z3n3 has joined #lisp
slyrus_ has joined #lisp
z3n3 has quit [Client Quit]
slyrus has quit [Ping timeout: 258 seconds]
dyelar has joined #lisp
efm has joined #lisp
frgo has joined #lisp
kajo has joined #lisp
jbayardo has joined #lisp
m00natic has quit [Remote host closed the connection]
SmallBrain has joined #lisp
ngqrl has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
<pfdietz>
The SBCL compiler is the CMUCL compiler, without the bugs.
<pfdietz>
And with years of further extensions and tweaks.
<SmallBrain>
Can I ask a very stupid question?
ggole has quit [Quit: Leaving]
<phoe>
pfdietz: and with proper bootstrappin'
jprajzne has quit [Quit: jprajzne]
<phoe>
SmallBrain: sure, ask away
<pfdietz>
I don't think people realize the state of the compiler at the fork. It was not very mature.
<phoe>
asarch: doesn't really look OOP to me
<karlosz>
pfdietz: i will admit that i tend to have rose-colored lenses looking to the past. but the point on documentation and ease of reading the source still stands
<pjb>
pfdietz: really? It was praised!
<pjb>
with its name "Python" and all that…
<SmallBrain>
I've never written any code in my life before and figured "why not start with Lisp?" so I downloaded Portacle and read through the tutorial and at some point it said: "execute-extended-command has be rebound to the <execute> button" where is that?
<pjb>
SmallBrain: this is an emacs thing.
<pjb>
SmallBrain: an emacs is a program that has a particular structure.
jprajzne has joined #lisp
<pjb>
SmallBrain: basically, it's an event loop that reads the next character, and looks up a table (key map) to find a function (command) to be executed.
<pfdietz>
My schtick is torturing lisp compilers until they confess. SBCL's compiler is quite resistant now. CMUCLs? It breaks almost immediately, even now.
<pjb>
SmallBrain: the nice thing is that you can configure this key map table at any time, during the execution of the program.
<pjb>
SmallBrain: now, <execute> is the symbolic name of a key (specifically a X11 keysym).
<karlosz>
pfdietz: yeah, from reading the source it seems that your bugs provoked a lot of backporting of sbcl fixes into cmucl by gerd
<karlosz>
until about 2003
<pjb>
SmallBrain: if you have a key labelled <execute> on your keyboard, you can map the keycode of this key to the X11 key sym, and then you can map in emacs this keysym <execute> to some command, such as execute-extended-command.
<karlosz>
makes you wonder if it wasn't forked, given that people kept porting patches to and from CMUCL constantly until about 2004 when it became a ghost town there
<pjb>
SmallBrain: without such a key, it is customary, and the default, to use the key combination Meta-x (noted as M-x).
<SmallBrain>
pjb: ah, the problem is, I don't have that key and portacle has Meta-x rebound to something else
<pjb>
SmallBrain: the Meta keysym is usually mapped from a key labelled Meta, or if not present, a key labelled Command, Windows, or evne Alternate or Option.
<karlosz>
and, sometimes the patches when ported to cmucl would accrue improvements and those improvements wouldn't make it back
<karlosz>
or a bug would get fixed in one and be refixed a few years later in the other
<pjb>
SmallBrain: the mesasge may be misleading, because the basic operation is adding a new key binding, not removing the old one.
<pjb>
SmallBrain: so M-x might still work. If not, the meta key is also mapped by emacs from ESC escape. But since ESC is not a modifier, you have to type it separately, first ESC, then x.
<SmallBrain>
pjb: so does M-x do both?
<phoe>
SmallBrain: you mean portacle tutorial?
<SmallBrain>
pjb: I will try that
<pjb>
SmallBrain: you can also see where the execute-extended-command is bound, by typing C-h w execute-extended-command RET
<SmallBrain>
phoe: yes, I just downloaded it because it seemed less of a hassle than configuring everything myself
<pjb>
it will say you something in the minibuffer such as: execute-extended-command is on <execute>, <menu>, M-x
<pjb>
and inversely, you can know what command is bound to a key by typing C-h k followed by the key.
<pjb>
So C-h k M-x
<SmallBrain>
pjb: i tried that and it literally said: "execute-extended-command is bound to the <execute> key"
<pjb>
or C-h k ESC x
<pjb>
SmallBrain: well this is not too good…
<SmallBrain>
pjb: and google only gave me stockphotos of a return key where "execute" was written on it
<Nilby>
If you want you can probably type something like: <Esc> X global-set-key execute-extended-command <F1>
<pjb>
SmallBrain: go to the scratch buffer, and type: (global-set-key (kbd "M-x") 'execute-extended-command) C-x C-e
<phoe>
SmallBrain: could you link me that tutorial?
gareppa has joined #lisp
<pjb>
SmallBrain: you could also do that in the minibuffer with M-: (global-set-key (kbd "M-x") 'execute-extended-command) RET
<SmallBrain>
phoe: uh... its a file from within portacle, not online
<pjb>
Nilby: if the command execute-extended-command is only bound to <execute>, then ESC x is not bound to it, and won't do anything.
<SmallBrain>
pjb: is that how all key can be rewritten?
<SmallBrain>
keys*
<pjb>
SmallBrain: yes, you can add a key binding with global-set-key, or with local-set-key when you want it only in the current buffer.
<phoe>
SmallBrain: ooooh! Did you fire up the Emacs tutorial?
<SmallBrain>
phoe: yes
<pjb>
SmallBrain: you can have a bunch of global-set-key forms in your ~/.emacs to customize emacs as you wish.
<phoe>
execute-extended-command is equivalent to M-x
<SmallBrain>
pjb: could I set it to f8 for example? that one doesn't seem to do anything yet
<phoe>
or, as some people prefer to say it, Alt+X
<Shinmera>
M-x is rebound to a better version of the normal M-x in portacle.
<pjb>
phoe: not when the binding has been removed!
<phoe>
pjb: OK, that's correct
slyrus has joined #lisp
<Shinmera>
Anyway, you don't need to read the Emacs tutorial. All the necessary terminology and keybindings are explained in the Portacle help buffer.
<Shinmera>
Due to portacle's customisation the emacs tutorial is more likely to be confusing than not
<Shinmera>
As shown here.
<pjb>
Shinmera: so perhaps portable should issue a message saying that "execute-extended-command has been rebound to the <execute> button" is not alarming because there's still a M-x working the same or better?
<pjb>
I would advise against using portable, and any other similar packages.
slyrus_ has quit [Ping timeout: 268 seconds]
<SmallBrain>
Shinmera: I figured i couldn't hurt because i had never used any program like that
<Shinmera>
Why would it issue a message for every change it made
<pjb>
Shinmera: to inform the user.
<pjb>
If you tell me that M-x doesn't work, it's very alarming to me, and I guess to any emacs user.
<Shinmera>
It does work
<Shinmera>
I don't know which part tells you it doesn't.
<SmallBrain>
pjb: the tutorial said too that M-x was rebound, I just couldn't find any "execute" key
<Shinmera>
Not one I wrote, in any case.
<phoe>
or rather just mention that "if you want to use the vanilla emacs tutorial - be aware that it will not be useful, since Portacle was customized compared to the vanilla emacs and the tutorial won't cover that"
<pjb>
the part that says that execute-extended-command is not bound to it…
<phoe>
since that's the hole that SmallBrain seems to have fallen into
<Shinmera>
I'd rather just nuke the tutorial altogether.
<phoe>
I can imagine a situation where someone downloads portacle, fires up the default tutorial, and gets stuck there because the tutorial doesn't apply to emacs
<phoe>
or that
<pjb>
SmallBrain: so, the thing is that <execute> is the name of a virtual key (a keysym), not a physical key identified by a keycode.
<pjb>
SmallBrain: if you are on X, you can map some physical key you are not currently using, to the <execute> keysym, my editing a xmodmap file.
<SmallBrain>
I think the tutorial is fine as it is, it was probably just not written with the thought that someone as clueless as I could try it...
<SmallBrain>
pjb: i will try to re-map it then
<pjb>
SmallBrain: for example, if the <Pause> keysym is mapped from the keycode 111, and you don't use it, you could map it to <execute> By replacing the line: keycode 111 = Pause Break by keycode 111 = Execute in ~/.xmodmap and reloading it with xmodmap ~/.xmodmap
<pjb>
SmallBrain: you could then scratch the Pause label and paint a new Execute label, or just erase all labels and remember them from key position (use a Das Keyboard blank keyboard or similar).
<pjb>
SmallBrain: Alternatively get yourself a SpaceCadet keyboard with all those funny key labels :-)
karlosz has quit [Quit: karlosz]
<phoe>
SmallBrain: not really
<phoe>
it wasn't written with the thought that one could run it on a heavily modified emacs\
<pjb>
SmallBrain: but the thing is that with portable, execute-extended-command is not useful, since it's replaced by another command. Try: C-h k M-x to see which one. So you can just forget about the <execute> key.
william1 has joined #lisp
<phoe>
I suggest that, if you want to go with the tutorial, you download the vanilla emacs and do the tutorial there
<phoe>
this way, you'll avoid the inspecting and rebinding mess that pjb is suggesting now, and you'll go straight to learning emacs instead.
<pjb>
Yes, avoid portacle.
<phoe>
since I don't think you want to learn how to turn portacle into vanilla emacs - you want to learn emacs instead
orivej has joined #lisp
jprajzne has quit [Ping timeout: 240 seconds]
<phoe>
and I'll disagree, portacle is good enough when you don't want to invest your time and set up your own emacs installation for whatever reason and want to just hack some lisp.
<SmallBrain>
was it perhaps masochistic to try to learn programming with LISP as first language over all?
<pjb>
SmallBrain: no, it's really simple. But some people want to load a ton of pre-configured tools on newbies. This is not a good idea.
<phoe>
I know some people who attempted and achieved that, so the anecdotic proof is there
<SmallBrain>
I mean I want to learn Lisp, but most people suggested I start with Python or Javascript
<pjb>
SmallBrain: it's better to let you use your own editor, take a CL implementation, and run it in a terminal.
<phoe>
take into account language popularity though, python and JS are hundreds+ of times more popular than CL
<Josh_2>
very sad :()
<phoe>
it's possible to learn programming by doing Lisp, and there's one book that was written exactly for that reason
<phoe>
minion: tell SmallBrain about gentle
<chimneys>
python is even more popular than js
<minion>
SmallBrain: please look at gentle: "Common Lisp: A Gentle Introduction to Symbolic Computation" is a smoother introduction to lisp programming. http://www.cs.cmu.edu/~dst/LispBook/
<pjb>
SmallBrain: after a week or so, you'll be fed up typing (load "my-source.lisp") in the REPL, so you'll be ready (ie. you will understand what and why) to use emacs and tools to integrate the editor with the CL implementation.
<Josh_2>
phoe: exactly, that was the first programming book I read
<chimneys>
SmallBrain: no just learn lisp in one hour that "gentle" tutorial is too big and rough, didn't waste time. In fact I am learning lisp from derek banas youtube tutoiral
chimneys was banned on #lisp by phoe [*!*eo@unaffiliated/hortiel]
chimneys was kicked from #lisp by phoe [See you]
<phoe>
there, sorry for the trouble
<pjb>
SmallBrain: and similarly, emacs is very big so as a newbie, you could easily be overwhelmed. The thing with emacs is to start with the "bare" emacs, and to install and use emacs packages when you start feeling the need for them. Not pre-installing them, because then you won't understand what you did and why. And be prepared: you will never finish learning emacs, a lifetime wouldn't be enough!
asdf_asdf_asdf has quit [Quit: asdf_asdf_asdf]
<pjb>
SmallBrain: you will only wish you had started using emacs earlier. Like, pre-school.
<SmallBrain>
sounds exciting
gareppa has quit [Quit: Leaving]
<phoe>
SmallBrain: the way pjb is suggesting is actually the long one and AFAIK portacle attempts to be a shortcut for it. common lisp and emacs are pretty closely tied to each other by means of an IDE package called Slime.
<Shinmera>
pjb: That's just, like, your opinion, man
<phoe>
and Slime is basically a requirement to utilize what's actually good about Lisp - the fact that it's an interactive and image-based language
<pjb>
I see more problems with using pre-packaged and pre-configured systems.
<SmallBrain>
phoe: I heard of Slime, its in portacle too
<pjb>
Notably, people don't learn with them.
<Shinmera>
pjb: That's just, like, your opinion, man
<phoe>
image-based, meaning that you run Lisp once and then program by means of mutating that image
<pjb>
That's what I witness on irc!
<pjb>
Also, portable is not the first such systems. There was others before. They all dired.
<pjb>
died.
<SmallBrain>
phoe: I'l need more experience before I can accurately understand what that means
<phoe>
interactive, meaning that you are able to converse with it
<phoe>
okay, let me use other words
<phoe>
many other languages work by the means of writing your program in a text file, running it through a compiler, and executing the resulting program
<SmallBrain>
phoe: what do you mean by "image-based"?
<phoe>
and then, if you want to change anything else, you need to repeat the whole process
orivej has quit [Ping timeout: 268 seconds]
<phoe>
Lisp is different - you run Lisp once, and it stays in the background all the time
<SmallBrain>
phoe: I am aware of that, lisp tells immediately if something is wrong
<pjb>
Well, background when you use it in emacs, but it's actually in the foreground.
<phoe>
the image is the full contents of what is available in Lisp
<phoe>
and you program by changing these contents - for example, if you define some new functions, you add some new stuff to the Lisp image
<phoe>
if you tell Lisp that this previously defined function should instead do another thing, you modify stuff in the Lisp image
<phoe>
if you decide to remove some functions, you remove stuff from the Lisp image
<phoe>
and you do all of this without ever turning it off - unless you screw something up so badly that a restart is required (;
<phoe>
that's why it's interactive - you converse with the Lisp image by telling it to add X or change Y or remove Z or run a piece of code
jxy has quit [Quit: leaving]
<phoe>
or that it should tell you what's going on in a particular place of the system
<SmallBrain>
without having to close the compiler, and rewriting everything in the text file and running it through the compiler again, only to find out that something is wrong
<phoe>
yes, that means that the "feedback cycle" is really quick
<phoe>
if you screwed up while writing a function, you only need to fix and recompile that function
<phoe>
usually it's instantaneous
<phoe>
and then you can re-run whatever code you were running, and keep on coding
<phoe>
you don't need to hit the Build button and then wait for the compiler to boot up
dnaeon has joined #lisp
<phoe>
since the compiler is already booted up, and available in the memory
<phoe>
waiting for stuff to munch on
<ebrasca>
Hi
<SmallBrain>
so does that mean the overall coding process is faster than with other languages?
<phoe>
the fact that Lisp can look into its own self pretty deeply is very fun - the debugger plus the inspector are a powerful combo
<phoe>
usually when a language screws up, you get a textual stacktrace
<Xach>
dnaeon: :USE and :IMPORT-FROM are about how you type symbol names and if they require prefixes or not
<Xach>
dnaeon: it does not have much to do with loading software (usually)
<phoe>
slime makes it possible to interactively inspect the stack and see the values of the local variables and the contents of these values and the contents of the contents of these values and so on.
<pjb>
SmallBrain: the emacs description I gave you above, where you can modify the keymap bindings in the program that is currently runing, actually it's based on an emacs lisp image-based development scheme. The idea is that you have a program, (a bunch of functions), and you can add, remove or replace functions while the program is running, as well as inspecting the data and of course modifying the data while the program is running.
<phoe>
dnaeon: USE and IMPORT-FROM make symbols accessible without typing the package prefix
<phoe>
so you can do (-> ...) instead of (arrows:-> ...)
<pjb>
SmallBrain: so when you program in an image-based system, you are actually modifying the running program.
<phoe>
the latter will always work whenever the ASDF system is loaded
<Xach>
dnaeon: asdf system definitions control how software and its prerequisites are loaded
amerlyq has quit [Quit: amerlyq]
<Xach>
quicklisp automates fetching libraries you don't have locally available
<phoe>
the former will only work if you import the symbol in question
jonatack has joined #lisp
<SmallBrain>
And that book that was linked further up, does it contain something like a list of possible formulas for Lisp-commands? or would that be a sisypho-task?
<pjb>
SmallBrain: of course, such a system doesn't only contain a compiler. At least, it will contain either an emacs (event loop -> key -> function), or a REPL = read eval print loop: (loop (print (eval (read)))).
<phoe>
SmallBrain: Lisp-commands, do you mean Common Lisp commands or commands for emacs?
cosimone has quit [Quit: Quit.]
<SmallBrain>
pjb: How do I get from the written text to a separate executable at the end?
<phoe>
it contains an overview of most of Common Lisp
<Odin->
Lisp doesn't usually do executables.
<pjb>
SmallBrain: but you can have all kind of features implemented in an image based system, including an editor such as an emacs (which is the case for GNU emacs using emacs lisp, or for example Hemlock implemented in Common Lisp), and other applications.
<phoe>
SmallBrain: you usually don't need to get from the written text to a separate executable
<Xach>
executables are one thing that you can make but it isn't always the main thing like it is in other environments
<phoe>
SmallBrain: if you want to program, there's no need to create executables whatsoever
<dnaeon>
Xach: phoe: in general that would mean that any dependency defined in my ASDF system will be available to my packages using the fully-qualified package path, and using `:USE` or `:IMPORT-FROM` within `defpackage` is more like a convenience, isn't it? e.g. whether you need just some symbols imported or inherit all of them from a given package?
<SmallBrain>
phoe: I was hoping for something like explanations for formulas like "if-then-else"
<Odin->
phoe: There was a "usually" in there. :p
<phoe>
SmallBrain: yes, the book contains that
<Xach>
dnaeon: right
brown121407 has quit [Ping timeout: 268 seconds]
<phoe>
Odin-: okay, I understand now
<SmallBrain>
thank god
<dnaeon>
Xach: got it, thanks!
<phoe>
SmallBrain: that book contains explanations for such basics, and many other things in the language
<pjb>
SmallBrain: this is a question of delivering executable. Nowadays, we mix file-based development with image-based development, by editing files saved on the file system, outside of the image, and constantly being compiling and loading those files. We can do that because our computers have become very fast, so we can recompile and load interactively.
mangul has quit [Ping timeout: 272 seconds]
<phoe>
in many other languages, making executables is the only way to interact with the programs written in these languages
<pjb>
SmallBrain: so since the program is saved in files, once it's completed and debugged, we can use those files to generate an executable.
<phoe>
thank goodness that Lisp doesn't have that limitation
rippa has joined #lisp
<phoe>
and your program can be invoked fully from the Lisp REPL, without ever needing to leave it
brown121407 has joined #lisp
<pjb>
SmallBrain: it can be either by loading them in an image, and saving it as an executable image (most cl implementations do that), or compiling them and linking them (eg. with ecl).
cosimone has joined #lisp
<pjb>
SmallBrain: but you can also deliver lisp programs in other ways, eg. as sources, or as fasl file (ie. compiled files that can be loaded and run later).
<Xach>
hotel clifornia
<Xach>
hey now
rwcom7 has joined #lisp
<Xach>
it was a good joke!
<pjb>
Xach: starting a hotel management system in CL?
<phoe>
Xach: you got the goosebumps, didn'tcha
<SmallBrain>
alright, I can't thank you all enough, I was about to give up since I had been sitting at this problem since yesterday
rwcom has quit [Ping timeout: 265 seconds]
rwcom7 is now known as rwcom
<Xach>
SmallBrain: i find it's a real help to ask people for help and get answers in real time.
<copec>
If only there were a programming paradigm that worked that way?
mangul has joined #lisp
<[df]>
one day we will all have our brains plugged in to one global lisp image running on a planet-sized supercomputer
<SmallBrain>
Xach: Especially when the usual answer is "use python instead"
<[df]>
until we expand out into the solar system of course
<phoe>
SmallBrain: no problem
<phoe>
[df]: and then someone will call (loop for x = nil then (cons x x))
<SmallBrain>
well its getting close to 5am, so good night people
SmallBrain has quit [Remote host closed the connection]
chimneys has left #lisp ["WeeChat 2.4"]
<[df]>
nah, this will be in an enlightened era where humans are never malicious
<[df]>
or possibly humans have been replaced with something better ;)
<phoe>
nested Lisp images, mmmmm
refpga has joined #lisp
<[df]>
inception!
<copec>
Was there ever any work on an sbcl tree shaker?
<phoe>
there was
<phoe>
there seems to be one that worked some time ago
<phoe>
but then it bitrotted
reimu_ has joined #lisp
<phoe>
how much do you need to shake off your binary?
<copec>
There was a nice feeling about being able to end up with a little executable "back in the day"
<copec>
none, phoe
<copec>
For the same motivations that led to systemd
<phoe>
I think much more is saved with core compression than there is with shaking
<copec>
just being OCD about something
asarch has quit [Quit: Leaving]
<[df]>
it's nice but very non-essential, except perhaps for commercial products or tiny embedded systems
<[df]>
an sbcl image is pretty tiny by today's (ridiculous) standards anyway
<copec>
I've been learning Rust, because I hate myself, so that's the only reason I even think about it
reimu__ has joined #lisp
refpga has quit [Remote host closed the connection]
refpga has joined #lisp
<galdor>
funny thing is, when you see people deploying 1+GB images containing trivial web apps, you stop caring about the size of a CL executable image
reimu_ has quit [Ping timeout: 265 seconds]
<phoe>
"why is a Lisp app 50MB in size"
<galdor>
docker made CL images look small
<phoe>
"why is your non-Lisp app 5000MB in size"
<phoe>
"why does your app bundle a compiler"
<phoe>
"why does your app bundle an operating system and ten versions of a trivial-left-pad package"
<phoe>
oh well though, this is #lispcafe material
dnaeon has quit [Ping timeout: 260 seconds]
sauvin has quit [Read error: Connection reset by peer]
mangul has quit [Ping timeout: 240 seconds]
<HiRE>
Is there a reason I see some packages being named with `#:<package>` vs `:<package>`?
<HiRE>
or is it just developer preference?
asdf_asdf_asdf has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
<phoe>
HiRE: the former doesn't intern a new keyword
<_death>
HiRE: packages are named by strings.. you are talking about package designators, which may be symbols whose name is equal to the package's name
<copec>
Developer preference as far as I can tell. I personally try not to intern symbols
<HiRE>
what does "intern symbols" mean
<HiRE>
?
<phoe>
it's a petty thing, attempting to save space for a single symbol, but nonetheless
<phoe>
HiRE: creating a new symbol in a package and making it stay there in memory forever*
<HiRE>
oh I see
<phoe>
*in case of keywords, it actually stays there forever
<HiRE>
so `#:` only keeps the symbol around for as long as the package is needed?
<phoe>
not really
<phoe>
it creates the symbol without any assigned package
<phoe>
it's a symbol that is not interned anywhere
<dlowe>
:keyword is a keyword, #:sym is a symbol without a package
decent-u` has joined #lisp
<pjb>
Well, any symbol read from #:foo will be garbage collected when memory is needed if it is not referenced somewhere.
<pjb>
So in a defpackage form, they will indeed disappear soon!
<Nilby>
Unfortunately if there's one use of :package instead of #:package then it doesn't matter.
<phoe>
yep, that's why consistency matters
<pjb>
Nilby: #:package will be garbage collected even if :package is not.
<phoe>
^
<phoe>
that's the ultimate reason
slyrus_ has joined #lisp
<Xach>
without a home package
<Xach>
apparently uninterned symbols have a package but are without a home
<_death>
if you use keywords, then there may be more ambiguities when autocompleting a keyword
<phoe>
Xach: wait what
decent-username has quit [Ping timeout: 272 seconds]
<Xach>
(this is not a useful detail most of the time)
<phoe>
#:foo doesn't have a package
refpga has quit [Quit: ERC (IRC client for Emacs 26.3)]
pilne has joined #lisp
<copec>
_death, that's actually the best reason I think i've heard
<Xach>
phoe: it doesn't have a home package. it might be present in a package though.
jxy has joined #lisp
<phoe>
that's a pathological case
<Xach>
phoe: c'mon, this is like page 2 of RG's spiteful guide to packages.
<phoe>
if you intern a symbol in A, import it into B, unintern it from A
<Xach>
phoe: right.
<pjb>
HiRE: the most important job of intern, and the notion of internalizing things, is that when you read twice the same representation you get always the same object.
<phoe>
that's not the case when you type in a literal #:foo
<Xach>
that's right.
refpga has joined #lisp
refpga has quit [Client Quit]
<HiRE>
ah I see
bitmapper has quit [Ping timeout: 268 seconds]
<HiRE>
well I think I see
<HiRE>
im reading the CMU guide on symbols now
<HiRE>
lol
refpga has joined #lisp
<pjb>
HiRE: so in (foo foo) we have actually two pointers to the same symbol foo. While in (#:foo #:foo) we have two pointers to two different homeless symbols named "FOO". While in (#1=#:foo #1#) we have two pointers to the same homeless symbol named "FOO".
<phoe>
that's one decent guide to packages with a somewhat abrasive title
<HiRE>
I find the title charming
<phoe>
i know, right
<Xach>
not just a title, abrasive throughout.
<Xach>
yet no slacker has superseded it, so
<copec>
That's USA style, like Dumbies guides
<copec>
or dummies, even
<pjb>
HiRE: you can internalize other things, by implementing your own mapping. For example, cons cells. (defvar *conses* (make-hash-table :test 'equal)) (defun intern-cons (k) (or (gethash k *conses*) (setf (gethash k *conses*) k))) (setf *print-circle* t) (list (intern-cons (cons 1 2)) (intern-cons (cons 1 2)) (intern-cons (cons 3 4))) #| --> (#1=(1 . 2) #1# (3 . 4)) |#
<copec>
Learning garbage collector theory is something I need to finally jump into
<pjb>
HiRE: note: this is something that a compiler is autorized to do on any literal cons cell it finds in the compilation-unit.
<HiRE>
hm, I suppose I'll hit the books a little harder.
<Nilby>
Or just do what I do and (delete-package :keyword) every now and then.
<Xach>
Nilby: don't do that.
<White_Flame>
HiRE: interning isn't a lisp-specific term, either. Many languages use it to describe unifying various equivalent objects into 1 instance.
* Odin-
found it a little hilarious when he realised GNU Emacs is a tenth the size of "modern editors" that are basically attempts to remake it.
<White_Flame>
however, even if you delete-package, the actual symbol instances are still there, so as long as you're not READing any new strings with keywords, you might actually be okay?
<phoe>
White_Flame: unicorns might happen
<phoe>
we're in the undefined behaviour land.
<White_Flame>
or manually interning symbols, too
z147 has quit [Remote host closed the connection]
<Odin->
White_Flame: I do suspect those other languages borrowed the term from Lisp.
z147 has joined #lisp
<Odin->
I still haven't seen a reference using that which doesn't have a clear link to Lisp usage, direct or indirect.
reimu__ has quit [Ping timeout: 272 seconds]
<phoe>
Odin-: which term?
<Odin->
Interning, in terms of symbols or unique strings.
slyrus__ has joined #lisp
<White_Flame>
did it also use the term "intern" in the beginning?
<phoe>
who interned the term "intern" in everyone's minds?
<White_Flame>
wikipedia talks about an objlist or obarray
X-Scale has quit [Ping timeout: 260 seconds]
narimiran has joined #lisp
slyrus_ has quit [Ping timeout: 260 seconds]
<copec>
Have you made it as a programmer when you make your own blog about making your own lisp?
<_death>
is the blog written in this lisp
<White_Flame>
and the httpd
<copec>
For the sake of argument, yes.
<dlowe>
You've made it as a programmer when you make a thing and someone else uses it for something they want
jfb4_ has joined #lisp
<Odin->
White_Flame: The function 'intern' is in the Lisp 1.5 manual, at least.
<White_Flame>
ah cool
jfb4 has quit [Ping timeout: 268 seconds]
<copec>
I swear I saw someone made a good illustration of the cl reader, and in searching for it came across many blogs about making a lisp
<copec>
To highlight the reader <--> symbol relationship
brown121407 has quit [Read error: Connection reset by peer]
<pjb>
Of course, since INTERN was in the first LISP in 1960…
<LdBeth>
Odin-: At least I know Java borrowed interning as a term for string comparison
<pjb>
At the time, no other programming language had such a notion. In compilers, you had a symbol table, so you could have lookup_identifier or something, but no intern.
brown121408 has joined #lisp
<Odin->
LdBeth: Well, the Lisp link is absurdly easy to trace there.
X-Scale has joined #lisp
<LdBeth>
I do suspect the term is originated from IBM S/360 internals
<LdBeth>
But searching on the internet won’t help
<White_Flame>
either "internal" or "internment" :-P
<LdBeth>
GG
<Odin->
As long as it's not interment.
Oladon has joined #lisp
longshi has quit [Quit: WeeChat 2.7]
EvW has joined #lisp
rdh has joined #lisp
Codaraxis has quit [Ping timeout: 240 seconds]
<copec>
Anyone done a HTTP POST GET repl
asdf_asdf_asdf has quit [Ping timeout: 272 seconds]
reimu_ has joined #lisp
lclark has joined #lisp
bitmapper has joined #lisp
<pfdietz>
Lisp predates the IBM 360. I first used Lisp 1.5 on an IBM 7094.
<pfdietz>
I was very young then. :)
milanj has joined #lisp
xuxuru has joined #lisp
<pjb>
copec: how would that work?
<pjb>
copec: isn't that Firefox?
<jackdaniel>
copec: building a macro around drakma shouldn't be hard
<_death>
maybe something like restclient-mode?
<jackdaniel>
I wrote rest api test automation that way (macros were more functionality oriented)
asdf_asdf_asdf has joined #lisp
<phadthai>
other than handling HTTP, you may want to bind *debugger-hook* to handle conditions and use eval... also look at slime/swank that includes a third party implementation-independent REPL
<phadthai>
(all that's different is that your lines/commands originate from http requests)