<aeth>
Schemers don't seem to recognize the $foo convention if you ask in #scheme
<aeth>
and most of the "occasionally seen" stuff are probably just in one project (one even says Macsyma)
<dbotton_>
appreciated
<aeth>
you can violate a few of the archaic rules. No one will complain if you use define-foo instead of deffoo or defoo. It's even in the standard, with define-condition
<_death>
<foo> is dylan-esque, .foo. is used in sbcl, foo&/foo$ is used in gbbopen..
<aeth>
you're far more likely to see the actual type instead of foo&/foo$ if you're writing numerical code... especially since you basically gain nothing for having a "foo, operating on floats" since if you don't specify single-float or double-float, you're probably just going to get the generic + anyway
<_death>
aeth: gbbopen uses foo$ to mean single-float.. there's also foo$&/foo$$/foo$$$ for the others
<aeth>
now at that point you might as well use C
<aeth>
I use CL so I don't have to decode &s
<_death>
aeth: well, I can't imagine gbbopen implemented in C :)
<aeth>
I've never heard of that before. what's it do?
borei has joined #lisp
<_death>
it's a blackboard system that integrates well with CLOS
<_death>
anyway, it's not that important.. I would say +foo+ is widely used, but not universally used.. e.g., CL does not use it (and neither do I, for some years now)
<borei>
can somebody gimme heads-up - is it possible to find out size of the basic types - single-float, double-float, integer, etc.
<borei>
hmm, not exactly like that. Is there any analog of C "sizeof" ?
<_death>
not in standard CL
<borei>
what is non-standard approach ?
<aeth>
_death: idk, +foo+ seems like one of the most universally used conventions, excluding CL's built-ins... since if you don't, it's reserved. You're not allowed to (let ((most-positive-fixnum 42)) most-positive-fixnum)
<no-defun-allowed>
A Common Lisp program isn't concerned with the size of objects in memory, so it'd be very implementation dependent.
dbotton has joined #lisp
<aeth>
_death: I know that the current standard discourages USE in DEFPACKAGE outside of CL, but anything that doesn't +foo+ its constants is unUSEable
<aeth>
borei: the size of a fixnum is probably (log (- most-positive-fixnum most-negative-fixnum) 2) bits
<_death>
aeth: if you want your package to be USEable, you use names that assume less context..
<aeth>
(the size of an integer is unbound because it could be a fixnum or a bignum.)
<aeth>
If you care about sizes, though, you can just specify it as e.g. (unsigned-byte 32)
<aeth>
(if it's larger than a fixnum it might be a bignum at the ends of that specified interval, but not necessarily... SBCL optimizes (unsigned-byte 64) and (signed-byte 64) in some circumstances)
<_death>
aeth: for example you would use (defconstant ebac-swedish-standards-factor 1.2) rather than (defconstant factor 1.2)
<Nilby>
The size of a specific fixnum could in fact be zero.
<aeth>
Nilby: how?
<no-defun-allowed>
Well, a fixnum on most implementations doesn't allocate anything on the heap. But there is the one word that every object occupies.
<Nilby>
Compiled away, or compiled into the instruction stream, among other ways.
flip214 has quit [Read error: Connection reset by peer]
<aeth>
if it actually exists, it will probably be 63 bits with a tag bit... or more generally (log (- most-positive-fixnum most-negative-fixnum) 2) bits with the rest of the 64 (or 32 or whatever) bits as a tag bit, since most don't optimize fixnums to the point of giving them 63 bits.
hineios has quit [Ping timeout: 264 seconds]
<aeth>
But, yes, it can be smaller if the compiler has enough information. If everything's (unsigned-byte 32) and stays (unsigned-byte 32) it might just be able to do more if the instruction set lets it. Also, e.g. bit.
cer0 has joined #lisp
<Nilby>
Or it, in memory, could be bigger than the amount of bits needed to represent it, for example if it is GC'd and turned into a forwarding pointer.
<aeth>
Even if there was a SIZEOF it would probably have to pretend to be a fixnum (e.g. 63 bits in SBCL) even if it's actually smaller...
flip214 has joined #lisp
<dbotton>
I find this interesting Dynamic binding was actually a bug in McCarthy's lisp 1.0 and then became a feature ever since
hineios has joined #lisp
skapata has quit [Ping timeout: 272 seconds]
<_death>
serendipity.. welp, sleepytime
<aeth>
this is why specified languages are better than single-implementation languages :-)
<aeth>
if there's one main implementation, every bug is a feature
<aeth>
SBCL makes breaking changes to conform to the standard
skapata has joined #lisp
<Nilby>
I think calling dynamic binding a bug is a little exaggeration. I think it's just easier to implement. Perhaps lexical binding is more a 2.0 feature.
<Nilby>
especially when the first version was by hand in assembly, translated from the lisp implementation on paper
toorevitimirp has joined #lisp
space_otter has joined #lisp
<Bike>
C sizeof exists because C defines that objects can be treated as arrays of bytes (or chars, or whatever it is), and sizeof returns the size of that
<Bike>
lisp does not do that definition, so there is no sizeof
<Bike>
implementations of Lisp and C can use other representations internally. adding up the sizes of C objects won't accurate reflect memory usage in a C program because the allocator has its own overhead, etc
lucasb has quit [Quit: Connection closed for inactivity]
IPmonger_ has joined #lisp
IPmonger has quit [Read error: Connection reset by peer]
semz has quit [Ping timeout: 260 seconds]
dbotton has quit [Remote host closed the connection]
semz has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
torbo has quit [Remote host closed the connection]
mbomba has joined #lisp
justHaunted has quit [Ping timeout: 260 seconds]
Bike has quit [Quit: Lost terminal]
Alloc has quit [Ping timeout: 256 seconds]
Alloc has joined #lisp
Alloc has quit [Ping timeout: 260 seconds]
Alloc has joined #lisp
justHaunted has joined #lisp
justHaunted has left #lisp [#lisp]
cer0 has quit [Quit: cer0]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
beach has quit [Ping timeout: 272 seconds]
Alfr_ has joined #lisp
Stanley|00 has joined #lisp
Alfr has quit [Ping timeout: 260 seconds]
terpri has quit [Remote host closed the connection]
terpri has joined #lisp
beach has joined #lisp
Stanley00 has quit [Ping timeout: 260 seconds]
<beach>
Good morning everyone!
Alloc has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
Alloc has joined #lisp
gravicappa has joined #lisp
<Nilby>
Greetings from the deep galactic void
karlosz has quit [Quit: karlosz]
Guest66899 has quit [Quit: WeeChat 2.3]
benjamindc has joined #lisp
miasuji has quit [Ping timeout: 260 seconds]
space_otter has quit [Remote host closed the connection]
space_otter has joined #lisp
space_otter has quit [Remote host closed the connection]
space_otter has joined #lisp
mbomba has quit [Quit: WeeChat 2.9]
<aaaaaa>
beach: !
<aeth>
has anyone data mined beach's good mornings yet?
<aaaaaa>
aeth: can be easily grepped
<aaaaaa>
and calculate variance
<aaaaaa>
I should do this
<aeth>
time, any missing days, etc.
<aaaaaa>
aeth: yeah
<aeth>
I propose that a "Lisp day" is a period of time between two of beach's good mornings
<aaaaaa>
aeth: upvote
<aeth>
this would probably be a good use case for one of those CL Jupyter notebook libraries
<moon-child>
on 2020-04-06 and 2020-07-30 he said ' Good morning everyone!' (with a leading space). Capitalization and spelling are completely consistent, though
bocaneri has joined #lisp
<aeth>
I hope it's regular enough that we can make a "Lisp day" visualization
<Nilby>
How about letting beach have some (admittedly little) personal space?
<aaaaaa>
draw a histogram
<moon-child>
it's pretty tight. 3.5-hr range total, but usually more like 1-2
<aeth>
Nilby: obviously it can't really be published without his permission
<aeth>
I guess we should ask first, though
<aeth>
beach: can we make a good morning graph?
<Nilby>
I'm more curious what's up with the 400 mostly silent users.
<aeth>
All of Freenode has been like that for years. A lot of that is various cloud bouncer services and bridges, like the Matrix bridge. We have some active users from Matrix, but I only notice most of them when the Matrix bridge goes down.
<no-defun-allowed>
aeth: I don't annoy you enough?
<aeth>
no-defun-allowed: you count as some active users
<no-defun-allowed>
Okay, I'll tell the rest to git gud.
<aeth>
I think Matrix disconnects you for inactivity eventually (but I'm not sure?)
<moon-child>
'git: "gud" is not a git command. See "git --help".'
<aeth>
But it definitely inflates numbers over the past
<aeth>
moon-child: not yet
gravicappa has quit [Ping timeout: 272 seconds]
<moon-child>
aeth: I wouldn't pin too much of it on matrix. IRC has always been filled with lurkers
<no-defun-allowed>
After a month.
saganman has joined #lisp
<aeth>
moon-child: yes, but you used to be able to assume that joins/parts were joins/parts, but that's rarely the case with all of the bouncers/cloud/bridges/etc.
<moon-child>
well, fair enough
Qudit314` has joined #lisp
<aeth>
It has been a gradual 10 or so year change
<no-defun-allowed>
And I believe that joins/parts do match up, otherwise the Freenode people would be very annoyed with the Matrix people.
saganman is now known as blackadder
<no-defun-allowed>
And the Matrix people came up to me one day, annoyed that I hadn't given the bot permissions to kick inactive people.
<aeth>
slightly more on topic, but with all these bridges on Freenode now, there still isn't one from the CL world afaik...
<aeth>
do we have chat on a list of things to rewrite in Lisp yet?
<no-defun-allowed>
Everything. And we rewrite the stuff already in Lisp for good measure.
<pillton>
We could do with some more unit test frameworks.
<aeth>
JS already has everything and they rewrite JS things as new JS things regularly, anyway
<aeth>
CL could be the same...
<aeth>
no-defun-allowed: chat and voice chat are missing, but those are... maybe the two most important things for socializing on the internet (it does have an email client, though)
<moon-child>
I mean, an IRC client|server in lisp wouldn't be hard. Latter wouldn't be very interesting, and as for the former there's erc et (probably) al
<pillton>
A CLIM Slack client?
<Nilby>
Pretty sure Shinmera already did chat thoroughly, e.g. Coleen et al.
<aeth>
pillton: sadly, I probably need a new test framework
<aeth>
(for my Scheme in CL)
<aeth>
(very niche use case)
borei has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
That's easy, do arecord | lisp -e "(loop with stream = (usocket:socket-stream (usocket:socket-connect "conscordapp.com" 1337 :element-type '(unsigned-byte 8))) for byte = (read-byte *standard-input*) do (write-byte stream))"
<beach>
aeth: Go right ahead.
<no-defun-allowed>
Listening is an exercise for the reader.
<beach>
Spelling and capitalization is consistent because it's an Eamcs abbrev.
<beach>
Emacs
<moon-child>
no-defun-allowed: even easier with oss; cat /dev/dsp | lisp -e ...
<aeth>
beach: great!
<no-defun-allowed>
I have a graph of the cumulative distribution function for the UTC time of "gme RET". Now I'm wondering why I made the graph.
<aaaaaa>
beach said "I have the same for "first-class global environments", "Common Lisp HyperSpec", "Common Lisp", "(first) Climacs", "Second Climacs", "Good morning everyone!", "Good afternoon everyone!", etc. etc."
<no-defun-allowed>
I'm also confused about what timezone the times are reported in; the mean is about 3:45 of some time zone.
<aeth>
that looks like UTC
<aeth>
so it changes by an hour with DST if you're looking at a year
<no-defun-allowed>
That's 4:30 then in UTC+1, I suppose.
<aeth>
summer time for France is CEST, or UTC+2... so 03:45 is 05:45
<aeth>
currently, 04:45 since I think Europe moved already?
<pillton>
beach: You have two shortcuts for etc.?
<no-defun-allowed>
Indeed it did. ("already" is strange from _here_, because we entered daylight savings on 2020-10-04)
<aeth>
and the US doesn't do it until after Halloween
<aeth>
International time zones in the fall is always weird
* White_Flame
laughs in Arizonan (no DST here)
<aeth>
Or, I guess it's the Australian spring...
<White_Flame>
I think there's 3 US states without DST
Qudit314` has quit [Quit: ERC (IRC client for Emacs 27.1)]
<aeth>
hopefully 50 states soon
<aeth>
this is how we know that programmers don't have real political power yet
<Nilby>
Not time again. I've spent more leap seconds than have happend agonizing about timezones.
karlosz has joined #lisp
<TMA>
aeth: it's 6:54 now
benjamindc has quit [Remote host closed the connection]
narimiran has joined #lisp
nicktick has joined #lisp
Oladon has quit [Quit: Leaving.]
paul0 has quit [Ping timeout: 258 seconds]
karlosz has quit [Quit: karlosz]
<beach>
pillton: No abbrev for "etc.".
paul0 has joined #lisp
<beach>
aaaaaa: Abbrevs save A LOT of time, and I am always surprised to learn how few people use them.
<beach>
aaaaaa: In addition, they decrease the number of typos, so there is less typing for correcting mistakes.
<beach>
aaaaaa: And I use abbrevs for correcting common typos too. For instance, my fingers seem unable to type "the", and they more often come up with "teh". So I have an abbrev for "teh" that expands to "the".
<Nilby>
M-x butterfly
ramus has quit [Ping timeout: 272 seconds]
ramus has joined #lisp
<TMA>
beach: I don't use them because the Czech language is heavily inflected so there is not much to gain, unless there is a good language model to help. Which there is not, unless GPT2 or GPT3 was hooked in.
<beach>
TMA: But you are typing English text right now.
karlosz has joined #lisp
shka_ has joined #lisp
<beach>
All of my examples are from ERC mode.
<TMA>
sure. I would feel like having a split personality if I used for one language and not for the other
<beach>
That makes absolutely no sense to me.
<beach>
I don't use abbrevs for my native language. Mainly because I don't use it very often.
<beach>
But I write a lot of French too, and there, abbrevs make things much faster as well. Different abbrevs for different languages, of course.
<beach>
It sounds like an excuse not to try it out.
<beach>
But don't worry. I am not forcing people to be more efficient. I was just remarking on an observation.
<TMA>
I have tried to use them when I attempted to write my thesis , my setwas rather small, I felt there were not enough of the opportunities. Moreover the abbrevs I came up with started to clash with real words; I seemed unable to remember the unique ones. After I noticed I have forgotten to use the abbrev for the third time in a row I gave up
<TMA>
I have no hard data, but I _felt_ less efficient, not more
dbotton_ has quit [Remote host closed the connection]
<aaaaaa>
beach: yeah, right
aaaaaa has quit [Quit: leaving]
narimiran has quit [Ping timeout: 256 seconds]
_paul0 has joined #lisp
paul0 has quit [Ping timeout: 256 seconds]
<TMA>
I needed to stop and think what was the abbrev for this even if I remembered there was in fact one
<TMA>
on the other hand, abbrevs (or smart completion) are awesome in code. I take m-v-b instead of multiple-value-bind. Not so for plain text.
<beach>
Well, there are two aspects to that observation. One is that you would not start by defining abbrevs and then try to remember them. You would start by observing words or phrases that you type frequently, and only then make an abbrev.
<beach>
The second observation is that you have to get used to your abbrevs so that you remember them. That is the same problem with any learning. In the beginning, it feels (and probably is) less productive, because you have to look things up fairly often. Only after some time do the savings kick in.
<beach>
It is of utmost importance for productivity to avoid the temptation of always using what you know. One must struggle in the beginning in order to get the great benefits later.
<beach>
It is the same thing with learning key sequences in an editor such as Emacs.
karlosz has quit [Quit: karlosz]
<beach>
If you don't take the time and temporary loss of productivity, you will always be stuck with the minimum set of key sequences, or worse, use the mouse too often.
narimiran has joined #lisp
<beach>
I have observed this again and again with my students. They use the arrow keys to go from the middle of a function to the beginning of that function. Even after I tell them about C-M-a and C-M-e, they continue with the arrow keys.
<beach>
I estimate that during a single 2h lab, the average students spends half an hour or so with unnecessary keystrokes.
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
<beach>
But, I also know that this phenomenon is due to some very strong psychological forces that are tough to compete with.
lottaquestions_ has joined #lisp
* Nilby
is addicted to ispell-complete-word, ya-snippets, templates.
<beach>
And I am totally convinced, that as software developers, we have the obligation to fight those forces as much as we possibly can.
lottaquestions has quit [Ping timeout: 264 seconds]
gravicappa has joined #lisp
Aurora_v_kosmose has joined #lisp
skapata has quit [Quit: Leaving]
<beach>
In one of my industry talks, I present some figures about relative time for learning certain things, compared to the savings once these things have been learned. Humans tend to get the proportions wrong by 2 orders of magnitude. Not by calculating, but by letting the "fast" brain module make the decision rather than the "slow" one.
skapata has joined #lisp
<autumn[m]>
I remember seeing a quote, somewhere (maybe on something about plan9?) that despite people swearing up and down that using the keyboard felt faster, the people given a task and asked to do it with the mouse actually were. But they may not have been using something like vim or emacs, idk!
aartaka has joined #lisp
<beach>
It is very hard to design experiments that show with some statistical significance such a result.
mmohammadi9812 has quit [Ping timeout: 240 seconds]
mmohammadi9812 has joined #lisp
charlie770 has joined #lisp
<aeth>
to be fair on the students, they're probably new to Emacs
<aeth>
I probably learned about on average a command a month... which is a lot now, but it took time
<beach>
And since we are on the subject, another use for abbrevs is to avoid subjecting the other people in a conversation to your own abbreviations, like "idk", "thx", "afaict", etc.
<beach>
aeth: My point is that, despite being told about a faster way of doing it, they continued to use the painfully slow way.
<Nilby>
It might be hard to design an experiment, but it's easy to see the facts in a student lab.
<beach>
To become more productive, one has to pause each time and possibly look up the key sequence before taking the easy way out. It feels horrible, but the gain is just around the corner, contrary to the estimate by the "fast" brain module.
<beach>
Learning can be painful. But, by doing it frequently, one gets used to the feeling, and it can become quite enjoyable.
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
<beach>
And again, as software developers, I think we have an obligation to become more productive. Not just to make the industry as a whole more productive, but to prevent overwork and burnout. By becoming more productive, one can take more time for personal activities, like writing a library, or (very often) learning even more stuff to become even more productive.
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 264 seconds]
<Nilby>
Sadly now with my Lisp environment fairly decent, my limitation is almost mostly in my slow/no brain module.
liberliver has joined #lisp
<charlie770>
Is there a book or an article, where I can see common-lisp app development in action?
<phoe>
Little Bits of Lisp, a Youtube channel
<charlie770>
thanks
orivej has quit [Ping timeout: 260 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 246 seconds]
<beach>
Nilby: The terminology "fast" and "slow" brain module is from the work of Kahneman "Thinking, fast and slow". The fast module is the one that is very bad with calculations and statistics. Trust the slow one more.
<beach>
Nilby: I recommend reading the book during the time your colleagues spend their day with unnecessary keystrokes.
<charlie770>
"Little bits of lisp" looks like a common-lisp tutorial. What I want is development of a full app. For eg. writing a compiler
<beach>
charlie770: A compiler for what language?
<beach>
charlie770: There is "LiSP" and "Anatomy of Lisp" for Lisp-like languages.
<beach>
minion: Please tell charlie770 about LiSP.
<minion>
charlie770: look at LiSP: "Lisp in Small Pieces". This book covers Lisp, Scheme and other related dialects, their interpretation, semantics and compilation. To sum it up in a few figures: 500 pages, 11 chapters, 11 interpreters and 2 compilers. <http://pagesperso-systeme.lip6.fr/Christian.Queinnec/WWW/LiSP.html>
<charlie770>
beach: If I wanted an interpreter for say.. python?
<beach>
charlie770: Also for writing a compiler, you probably need something like the books by Andy Appel and the one by Muchnick.
<beach>
charlie770: Such a thing, written in Common Lisp, would very likely make heavy use of CLOS, so that would be a good start to get more familiar with.
<no-defun-allowed>
A compiler is a very hard "full app".
<charlie770>
beach: I dislike object-oriented-programming!
<no-defun-allowed>
Too bad for you then!
hiroaki has quit [Ping timeout: 260 seconds]
random-nick has joined #lisp
<beach>
charlie770: Then you should know that CLOS is not like traditional object-oriented programming.
<beach>
charlie770: And, yes, as no-defun-allowed said, to bad for you.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<aeth>
charlie770: CLOS is good if you dislike OOP
<aeth>
there's almost no difference between DEFUN and DEFMETHOD
<charlie770>
aeth: why?
<aeth>
Most languages (1) have your methods live with the class definition and (2) give methods a special infix dot syntax
Nilby has quit [Ping timeout: 264 seconds]
<aeth>
so you have to live with their style of OOP (especially in Java) at the core of the language
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<aeth>
On the other hand, CLOS lets you treat your methods mostly like functions, and you mostly use them for the polymorphism.
<charlie770>
aeth: I don't know what polymorphism is. could you explain?
<aeth>
You don't have to really use CLOS, but more importantly, if someone else is heavily using CLOS in their library's API that you're using, you don't really notice.
mmohammadi9812 has quit [Ping timeout: 258 seconds]
<aeth>
Different method selection based on the type of the argument to FOOBAR
<no-defun-allowed>
charlie770: I'm curious as to how you formed an opinion on object oriented programming then.
mmohammadi9812 has joined #lisp
<aeth>
And FOOBAR itself is a generic function that is, in this example, implicitly created... You could put (defgeneric foobar (obj)) in front if you want
<aeth>
CLOS in particular does polymorphism based on the class of the argument, where classes are a subset of types.
<charlie770>
aeth: I'm aware of "selecting a function based on arguments" from SICP. I just never linked it to the word polymorphism.
OlCe has quit [Ping timeout: 260 seconds]
<easye>
Does anyone know if under Windows SBCL expands a #\~ to a user home directory when parsing Pathname namestrings?
<aeth>
charlie770: there are a few other phrases, like e.g. "dynamic dispatch" (which in this case also means it's done at runtime rather than at compile time)
<aeth>
(the selection, I mean)
<charlie770>
aeth: nice
<charlie770>
aeth: tell me more!
<phoe>
easye:
<phoe>
* (uiop:native-namestring #p"~/")
<phoe>
"C:\\cygwin64\\home\\clci\\"
<easye>
phoe: thanks
<charlie770>
aeth: do other languages have dynamic dispatch?
<phoe>
but (namestring #p"~/") ;=> "~/" so beware
<phoe>
(it's good to have three VMs with Lisp set up!)
<easye>
Ah.
<no-defun-allowed>
Dynamic dispatch is a defining feature of object-oriented programming, and I suppose it kinda exists with typeclasses in some functional languages.
* easye
has one Windows VM running that is struggling on ~2014 hardware.
OlCe` has joined #lisp
<aeth>
charlie770: most will have dynamic or static dispatch. Iirc, C++ is an example of the static kind, where the information is available at compile time. A quick search shows that it does have some dynamic dispatch, too, but it's very different from CLOS's because CLOS has multiple dispatch
<aeth>
Notice that 2 classes and 2 arguments means 4 methods... so there can be a lot of combinations if you really wanted to take advantage of multiple dispatch.
<charlie770>
aeth: so other languages don't have multiple dispatch?
<aeth>
(the section in that chapter that's relevant is called "multimethods")
<aeth>
most don't have multiple dispatch, but Wikipedia has a few other examples
hendursaga has quit [Ping timeout: 240 seconds]
<aeth>
Wikipedia has examples in C#, Common Lisp, Julia, Next Generation Shell, and Raku.
<aeth>
Common Lisp rarely is the only language with a feature (maybe just the Common Lisp condition system?), but it has an interesting combination of features.
<no-defun-allowed>
Dylan has a condition system, but it's basically the Common Lisp condition system.
<charlie770>
aeth: The problem with classes, like macros is they that they can be used everywhere. You can wrap them around anything and still have a working program. People use oop as a silver bullet for every problem. They just don’t know what the problem is. Makes you wonder if there’s a method to his madness😉. If I wanted to understand oop, I think I need to know when not to use it.
<aeth>
charlie770: yeah, but CL is (mostly) not like that.
<no-defun-allowed>
Yeah, and?
<aeth>
CL just gives you a bunch of different equally-powerful tools to solve a problem and lets you decide which ones to use
<phoe>
if you only have a hammer then all problems start looking like nails
<phoe>
that's the case with e.g. Java which has an "everything is a class or its subpart" approach
skapata has quit [Quit: Leaving]
<phoe>
CLOS is optional do indulge in when you program in CL, since CL is a multiparadigm language and doesn't limit the programmer in choices like Java does
<aeth>
As I said a while ago, you can simultaneously entirely avoid CLOS in your code, and not even notice if other people's code that you're using is written via CLOS... mainly due to the uniform syntax and the focus on generic functions (verbs, not nouns)
<aeth>
Lots of languages give you the first option, but then if you use someone's library, you're going to have to deal with foo.bar()s
space_otter has quit [Remote host closed the connection]
X-Scale` has joined #lisp
<aeth>
Okay, you'll probably notice MAKE-INSTANCE, but I like wrapping (MAKE-INSTANCE 'FOO ...) with a MAKE-FOO function, personally.
X-Scale has quit [Ping timeout: 256 seconds]
<charlie770>
So dynamic-dispatch, multiple-dispatch. What else sets CLOS apart?
X-Scale` is now known as X-Scale
<no-defun-allowed>
Multiple inheritance and packages used to (approximately) enforce encapsulation instead of class relations.
<charlie770>
no-defun-allowed: what is encapsulation?
<aeth>
With CLOS you have methods living with generic functions instead of with the classes... and the uniform syntax (generic functions are just functions) rather than the typical dot notation of method calls (which is infix and encourages noun-based APIs that focus on the object)
<no-defun-allowed>
I'm not sure if I should have expected you to know or not, given that you started this discussion with "I dislike object-oriented-programming!"
<aeth>
s/and the uniform syntax/and you have the uniform syntax/
<charlie770>
no-defun-allowed: because it confuses me!
<no-defun-allowed>
Encapsulation is how you stop the external world from modifying the stuff that you don't want it to modify.
<cl-arthur>
charlie770: Would recommend you spend more time with it to the point where it's understandable and known if your main irk is confusion
<aeth>
charlie770: Encapsulation is often seen as an essential OOP feature, especially by C++/Java programmers, but in many languages it's just by convention. Really, I don't see it as an essential part of OOP because everyone does encapsulation to some extent. (At least, if it's some form of structured programming.)
<aeth>
One problem with OOP is that there's no one consistent definition
<aeth>
I'd personally define it as hiding private things
<aeth>
Often, languages do just have a "private" keyword that they put in front of their methods and/or slots
<charlie770>
cl-arthur: I try to learn it. Then again, after a while, I think "I could probably do all this with macros"
<aeth>
CLOS is more in the encapsulation-by-convention camp (naming conventions, to be specific), like Python. Iirc, Python uses __foo (or is it __foo__?) while CL uses %foo
<aeth>
Arguably, the only true way to encapsulate in CL is with a closure (which is an entirely different kind of thing than OOP)
<no-defun-allowed>
You also have packages, and an agreement with the client that they can't use internal symbols and/or SLOT-VALUE.
<charlie770>
aeth: I'm guessing closures are how they implemented CLOS?
<aeth>
no-defun-allowed: yes, but packages are a weak form of encapsulation because you can just do foo::bar and access the private thing even if foo:bar doesn't work
<aeth>
closures are basically unbreakable
<no-defun-allowed>
No, CLOS is not implemented with closures.
<aeth>
charlie770: you could implement OOP with closures... but CLOS (probably) isn't implemented via closures in any implementation
<aeth>
Some Scheme and/or academic exercises do things like this, though
<no-defun-allowed>
aeth: Yes, then you write in the agreement that the client loses their keyboard and monitor if they do that.
<no-defun-allowed>
Same goes for dunders (the underscore wrapping in Python), I suppose.
<aeth>
charlie770: closures vs OOP is probably too deep of a concept right now, though
Cymew has joined #lisp
<charlie770>
do you guys read code(from github)?
dilated_dinosaur has joined #lisp
<aeth>
sometimes
<aeth>
I can't think of any good examples to read at the moment, though
<charlie770>
aeth: I'd like to start reading some code!
<phoe>
charlie770: any particular kind of code you'd like to start reading?
<phoe>
there exists https://github.com/atlas-engineer/nyxt whose sources I have almost never read so I cannot say anything about the quality of the code there
<phoe>
this is as close to an application as I can imagine
<aeth>
That's what I was going to go to next :-)
<jdz>
Maybe Quicklisp?
<jdz>
Very self-contained.
<phoe>
^
<charlie770>
I'll check it out(nyxt)
<aeth>
The most popular application might be pgloader... which is apparently about migrating to PostgreSQL. https://github.com/dimitri/pgloader/
<phoe>
oh yes! pgloader
<charlie770>
what is pgloader?
<phoe>
it's an amazing piece of Lisp software
<phoe>
a utility for database migration
<phoe>
from X to PostgreSQL, where X aims to be literally any database
gko` has quit [Quit: ERC (IRC client for Emacs 27.1)]
gko has joined #lisp
<aeth>
phoe: I want to migrate from PostgreSQL to PostgreSQL!
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
<phoe>
aeth: yes
<phoe>
as I said, literally any database
cantstanya has joined #lisp
pve has joined #lisp
davepdotorg has quit [Remote host closed the connection]
frgo has joined #lisp
frgo_ has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 246 seconds]
charlie770 has quit [Ping timeout: 260 seconds]
charlie770 has joined #lisp
frost-lab has joined #lisp
nicktick has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
<beach>
Wow, this discussion reminds me of a student I once had, who moved to Bordeaux to avoid Ada, which was taught at the university of his home town. But after I questioned him, he admitted to knowing nothing about Ada at all. Disliking object-oriented programming while not knowing about encapsulation, polymorphism, or dynamic dispatch seems very similar to me.
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` has joined #lisp
[X-Scale] has joined #lisp
amb007 has joined #lisp
<phoe>
it's easy to dislike that what you don't know
<beach>
charlie770: I think you need to work on your basic programming skills and basic knowledge about software development tools before you can hope to start implementing an interpreter or a compiler.
<phoe>
it's even easier if you dislike the lack of knowledge itself and then project it onto whatever
<beach>
phoe: It is not very smart, though, to dislike something you don't know.
X-Scale` is now known as X-Scale
<beach>
It can have serious consequences to one's ability to do good work.
davepdotorg has joined #lisp
<phoe>
beach: sure it's not beneficial, but it's common
<beach>
Sadly, yes.
<phoe>
that's just a common way human minds work, that's the reality
<charlie770>
beach: I don't understand oop. Maybe that's why I dislike it. Maybe also because I could get away with it(using macros).
<phoe>
the best thing is to acknowledge it and move on with life while trying to fix the ignorance to the best of one's ability, no point in dwelling on it too much
<dim>
hi folks!
<phoe>
hey dim!
<no-defun-allowed>
Hello dim
<charlie770>
beach: do you think learning object-oriented-programming will make me a better programmer?
<beach>
charlie770: If you dislike things just because you don't understand them, you will be very limited in what you can do in the future.
<beach>
charlie770: Yes, it will.
<dim>
yeah pgloader can be used to move from Postgres to Postgres, the main use case is to have a alternative to ALTER TABLE foo ALTER COLUMN bar TYPE bigint USING processing_function(bar); but well we didn't solve all of the concurrency issues at the moment
<beach>
charlie770: Because you will then have an informed opinion about it, and you can make choices based on knowing what you are talking about.
<dim>
charlie770: do you think learning hammer will make someone a better carpenter? ;-)
<beach>
charlie770: That might be to avoid object-oriented programming, but at least you then know why.
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
davepdotorg has quit [Ping timeout: 240 seconds]
<charlie770>
beach: you're right.
<phoe>
learning multiple ways of programming indeed makes one a better programmer
<beach>
charlie770: I don't use traditional object-oriented programming, where encapsulation and abstraction go together. I much prefer CLOS-style programming, whatever you call it, where encapsulation is handled by the package system and the abstraction is done with generic functions.
<dim>
+1 to that
<beach>
charlie770: But then, I understand both styles, and I have made my decision based on that knowledge.
<dim>
also when all you have is object oriented as the only architecture tool, I tend to dislike those programming languages (Java is the main example I can think of)
davepdotorg has joined #lisp
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
<beach>
dim: Right. For example, in order to create an anonymous function, some languages require (or used to require) that you actually create a class with a single method in it.
<no-defun-allowed>
I work with both frequently, as I implement message-passing OO using CLOS.
<charlie770>
no-defun-allowed: what is message-passing?
<dim>
beach: same with closures being only available within a class construct in Python, I guess?
<no-defun-allowed>
(And the inspirations for the former, Erlang and Smalltalk, to some extent, allow one to produce closures.)
<beach>
dim: I guess so, yes.
<beach>
I also recently realized that, in some object-oriented languages, you defeat encapsulation entirely when you make a subclass. Then it is easy to, by accident, violate the original protocol.
<dim>
a friend of mine loved closures when he taught himself Clojure (the lisp inspired language in the JVM) but always though he wasn't smart enough for OOP, I showed him a class in Python is the same thing as a closure in Clojure and he was like “wow”, I hope he know realises he's smart enough ;-)
<beach>
With CLOS, the package system still protects from such accidents.
<phoe>
a closure is just a poor man's object
<phoe>
the same way an object is just a poor man's closure
<no-defun-allowed>
charlie770: Message passing is what most people think of when they think of object-oriented programming, where objects collaborate by sending "messages" to each other.
<no-defun-allowed>
That's not quite the same as objects calling methods on each other, as messages can also be passed around as objects, allowing one to do a few things that would be tricky otherwise, such as selectively passing on messages to another object.
Aurora_v_kosmose has joined #lisp
scymtym has joined #lisp
<no-defun-allowed>
But you don't need to know much about that now.
orivej has joined #lisp
ljavorsk has joined #lisp
ljavorsk has quit [Remote host closed the connection]
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
ljavorsk has joined #lisp
<TMA>
speaking of message-passing and OOP, I want to point out the power of reification. reification is an enabler for neat things. in the same vein is reification of computation environments as invented by beach here -- enabler for nifty things
<beach>
Or of classes and generic functions in CLOS.
<beach>
... and slots, methods, etc.
edgar-rft has joined #lisp
[X-Scale] has quit [Quit: HydraIRC -> http://www.hydrairc.com <- Po-ta-to, boil em, mash em, stick em in a stew.]
Stanley|00 has quit [Remote host closed the connection]
dyelar has joined #lisp
<TMA>
symbols even -- reified names
<TMA>
in a sense it enables the programmer to do something that would otherwise be restricted to the compiler/system
iissaacc has quit [Ping timeout: 256 seconds]
<TMA>
and that's why I love common lisp.
<beach>
Definitely symbols, yes. And packages.
Alloc has quit [Ping timeout: 240 seconds]
Alloc has joined #lisp
ljavorsk_ has joined #lisp
Oddity_ has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
ljavorsk has quit [Ping timeout: 272 seconds]
paul0 has joined #lisp
Oddity has quit [Ping timeout: 260 seconds]
_paul0 has quit [Ping timeout: 260 seconds]
davepdotorg has quit [Remote host closed the connection]
galex-713 has joined #lisp
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
ljavorsk_ has quit [Remote host closed the connection]
davepdotorg has joined #lisp
ljavorsk_ has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
davepdotorg has quit [Ping timeout: 256 seconds]
jw4 has joined #lisp
liberliver has quit [Remote host closed the connection]
liberliver has joined #lisp
davepdotorg has joined #lisp
Alloc has quit [Ping timeout: 240 seconds]
tankrim has joined #lisp
Alloc has joined #lisp
davepdotorg has quit [Ping timeout: 246 seconds]
ndbopoi^ has joined #lisp
galex-713 has quit [Remote host closed the connection]
davepdotorg has joined #lisp
charlie770 has quit [Ping timeout: 260 seconds]
charlie770 has joined #lisp
davepdotorg has quit [Ping timeout: 246 seconds]
aartaka_d has joined #lisp
knobo has joined #lisp
aartaka has quit [Ping timeout: 258 seconds]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 256 seconds]
Alloc has quit [Ping timeout: 240 seconds]
charlie770 has left #lisp ["ERC (IRC client for Emacs 27.1)"]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
davepdotorg has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
davepdotorg has quit [Ping timeout: 256 seconds]
nicktick has joined #lisp
davepdotorg has joined #lisp
Alloc has joined #lisp
davepdot_ has joined #lisp
davepdotorg has quit [Ping timeout: 260 seconds]
davepdot_ has quit [Ping timeout: 256 seconds]
Stanley00 has joined #lisp
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 260 seconds]
Stanley00 has quit [Ping timeout: 260 seconds]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 256 seconds]
davepdotorg has joined #lisp
davepdot_ has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
frost-lab has quit [Quit: Connection closed]
wsinatra has joined #lisp
davepdot_ has quit [Ping timeout: 256 seconds]
lispbeginner has joined #lisp
drot has quit [Remote host closed the connection]
davepdotorg has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
Bike has joined #lisp
hendursaga has quit [Client Quit]
hendursaga has joined #lisp
davepdotorg has quit [Ping timeout: 258 seconds]
gaqwas has quit [Remote host closed the connection]
ljavorsk_ has quit [Remote host closed the connection]
ljavorsk_ has joined #lisp
Josh_2 has joined #lisp
madage has quit [Ping timeout: 240 seconds]
galex-713 has joined #lisp
ggole has joined #lisp
lispbeginner has quit [Ping timeout: 258 seconds]
bitmapper has quit [Quit: Connection closed for inactivity]
yottabyte has joined #lisp
davepdotorg has joined #lisp
<Josh_2>
Afternoon
madage has joined #lisp
<beach>
Hello Josh_2.
treflip has joined #lisp
davepdotorg has quit [Ping timeout: 258 seconds]
Krystof has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
DGASAU has quit [Read error: Connection reset by peer]
aartaka has quit [Ping timeout: 264 seconds]
aartaka has joined #lisp
davepdotorg has joined #lisp
DGASAU has joined #lisp
aartaka_d has quit [Ping timeout: 246 seconds]
kneefraud has joined #lisp
FreeBirdLjj has joined #lisp
scymtym has quit [Ping timeout: 260 seconds]
drot has joined #lisp
EvW has joined #lisp
Stanley00 has joined #lisp
bitmapper has joined #lisp
sjl_ has joined #lisp
Stanley00 has quit [Ping timeout: 256 seconds]
ljavorsk_ has quit [Ping timeout: 256 seconds]
daniel1302 has joined #lisp
kyych has joined #lisp
IPmonger_ has quit [Ping timeout: 272 seconds]
clockboi has joined #lisp
<clockboi>
Is Sicp worth it, even when learning Common Lisp?
<jackdaniel>
it teaches many important things about programming in general
<jackdaniel>
so yes
<edgar-rft>
SICP teaches programming in general using Scheme examples, but it's not necessarily only for Scheme or Lisp
cpape has quit [Remote host closed the connection]
cpape has joined #lisp
<clockboi>
Are Sheme and CL that different?
<jackdaniel>
yes
<clockboi>
( sorry, just start learning CL two days ago )
<jackdaniel>
while they belong loosely to the same family of programming languages, they are very different (both design- and community- wise)
<edgar-rft>
clockboi: no worries, there's lots of historical quirks in Lisp, don't be afraid to ask :-)
cantstanya has quit [Remote host closed the connection]
cantstanya has joined #lisp
kaftejiman has joined #lisp
<phoe>
if you want to, you can do all of SICP in Common Lisp; the most important difference you will encounter is FUNCALL which does not exist in Scheme but is necessary in Common Lisp
<phoe>
another one is the concept of NIL in Common Lisp which has no Scheme counterpart
<jackdaniel>
nil is a quirk, not a concept
u0_a156 has joined #lisp
jonatack has quit [Quit: jonatack]
<beach>
clockboi: There are books specifically for Common Lisp, in case you already know the basics of programming in general.
jonatack has joined #lisp
<gothnbass>
Practical Common Lisp is one good book for that.
toorevitimirp has quit [Remote host closed the connection]
<p_l>
clockboi: also, consider that the amount of scheme you're supposed to know to finish SICP is quite small
gaqwas has joined #lisp
scymtym has joined #lisp
<docl>
I just did SICP 1.1 in CL, one thing I noticed was define doesn't exist, instead you have to do defun for functions. and the paren structure for that is slightly different.
dvdmuckle has quit [Ping timeout: 265 seconds]
<beach>
Also, using DEFUN inside a function means something different from using DEFINE to define a function inside another one in Scheme.
<beach>
Nested DEFINEs in Scheme translate to LABELS in Common Lisp.
rumbler31___ has joined #lisp
<beach>
I wouldn't recommend that way of working, but many people seem to think it is OK.
<beach>
I mean, doing SICP exercises in Common Lisp.
<docl>
good to know
<jdz>
c
dvdmuckle has joined #lisp
dvdmuckle has quit [Client Quit]
hnOsmium0001 has joined #lisp
Frankenlime has quit [Quit: quit]
also_uplime has joined #lisp
dvdmuckle has joined #lisp
kaftejiman has quit [Remote host closed the connection]
luckless has quit [Ping timeout: 240 seconds]
luckless has joined #lisp
davepdotorg has quit [Remote host closed the connection]
<cl-arthur>
beach: Don't forget SICP in javascript etc. :)
karswell_ has quit [Remote host closed the connection]
davepdotorg has joined #lisp
hineios has joined #lisp
<gothnbass>
Tracking down a bug relating to `html-template:fill-and-print-template`. Does anybody know of a non-obvious dependency on `pwd`? It works just fine if I'm running from the parent directory of `/templates`, but breaks with a `format` error otherwise.
<dim>
I like PAIP intro chapter about Common Lisp for people who already know how to write some code
aartaka has joined #lisp
davepdotorg has quit [Ping timeout: 260 seconds]
gravicappa has quit [Ping timeout: 264 seconds]
dbotton has joined #lisp
EvW has joined #lisp
FreeBird_ has joined #lisp
dbotton_ has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
<gothnbass>
Never mind; I found it. I'm an idiot, and I hard-coded that path into TMPL_INCLUDE statements in the templates.