<_death>
the self-modifying code issue is interesting.. not just because it uses "bletcherous" jargon, but also because it mentions "displacing macros", which I will now try to find more about.. my guess is that they "patch" the form in place with their expansion
dbotton has quit [Quit: This computer has gone to sleep]
warweasle has quit [Quit: I'm rooting for daffy duck.]
karstensrage_ has left #lisp ["Leaving"]
abhixec has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
zooey_ has joined #lisp
zooey has quit [Remote host closed the connection]
aeth has quit [Ping timeout: 272 seconds]
aeth has joined #lisp
karlosz has quit [Ping timeout: 264 seconds]
esoteric1lgo has quit [Remote host closed the connection]
semz has quit [Ping timeout: 258 seconds]
vegansbane6963 has joined #lisp
long4mud has joined #lisp
semz has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
skapata has joined #lisp
logand``` has joined #lisp
luni has quit [Quit: Connection closed]
logand`` has quit [Ping timeout: 272 seconds]
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
wxie has joined #lisp
trebor_home has quit [Ping timeout: 240 seconds]
drl has quit [Quit: Leaving]
<Bike>
the mention of an EVAL that takes an environment is interesting
toorevitimirp has joined #lisp
ldbeth has joined #lisp
karlosz has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
aindilis has joined #lisp
<ldbeth>
good morning
Christ0pher has joined #lisp
gzj has quit [Read error: Connection reset by peer]
gzj has joined #lisp
gzj has quit [Read error: Connection reset by peer]
gzj has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
casual_friday_ has quit [Ping timeout: 260 seconds]
casual_friday has joined #lisp
gzj has quit [Remote host closed the connection]
Sheilong has quit [Quit: Connection closed for inactivity]
gzj has joined #lisp
edgar-rft has joined #lisp
vutral_ has quit [Quit: Connection closed for inactivity]
pillton has joined #lisp
prxq_ has joined #lisp
aartaka has joined #lisp
beach` is now known as beaach
beaach is now known as beach
charles` has joined #lisp
prxq has quit [Ping timeout: 246 seconds]
nicktick has quit [Ping timeout: 265 seconds]
spal_ is now known as spal
<beach>
Good morning everyone!
Alfr_ has joined #lisp
Alfr has quit [Ping timeout: 258 seconds]
nicktick has joined #lisp
aeth has quit [Ping timeout: 265 seconds]
Bike has quit [Quit: Lost terminal]
aeth has joined #lisp
<charles`>
hi beach
_whitelogger has joined #lisp
ldbeth has quit [Ping timeout: 264 seconds]
aartaka_d has joined #lisp
ldbeth has joined #lisp
aartaka has quit [Ping timeout: 276 seconds]
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 264 seconds]
charles` has quit [Ping timeout: 264 seconds]
easye has quit [Remote host closed the connection]
easye has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
Nilby has joined #lisp
wxie has quit [Ping timeout: 272 seconds]
karlosz has quit [Ping timeout: 265 seconds]
wxie has joined #lisp
karlosz has joined #lisp
ldbeth has quit [Read error: Connection reset by peer]
ldbeth has joined #lisp
frgo has quit [Remote host closed the connection]
holycow has joined #lisp
<holycow>
is it okay to ask uber noob questions here or do i need to go to another chan?
<beach>
You can ask, and if it becomes tedious you will be told to take it to #clschool.
<holycow>
oh! that is the chan, writing it down
skapata has quit [Remote host closed the connection]
<holycow>
docs updated. okay not tedious at all. i just need a tip on how to think about solving the problem and what to google for
pagnol has quit [Ping timeout: 240 seconds]
abhixec has quit [Quit: leaving]
<holycow>
i have a text file with a list of music files, one per line. i want to load the list of music files and i guess basically sort by 'i like it' 'i don't like it'. the interface part isnt too much of an issue. so uiop:read-file-lines works fine, but i am wondering how to 'store' the list of files in lisp ... maybe an array? I keep on reading about tokens as well. basically i will create a loop that will
<holycow>
loop over the list, ask me a question, record the answer and move on to the next one.
<holycow>
what structure should i think about using for this?
<beach>
If you have less than a few million music files, then it won't matter much.
<moon-child>
^
<moon-child>
can make a structure with a slot for the name of the file and a slot for whether you like it
<holycow>
it's a trivial project to just learn lisp.
<moon-child>
or two lists, one for liked and one for unliked files
<moon-child>
(corresponding roughly to row-major and column-major database stores)
<holycow>
oh, aha
<holycow>
okay thanks i know what to google for now. thank you.
<beach>
I would make a list of standard objects, one object per file, and have a like/don't like slot in it. I would not necessarily sort it right away. But then, I would hide the list behind a protocol (interface) that does not mention the representation.
<beach>
This advice would be true for any language, in fact.
<holycow>
*nod*
<holycow>
thank you kindly.
<ldbeth>
for LOOP macro, how should I write (loop for j <<if (oddp j) then from 0 to x else from x down to 0 >> do ...)?
charles` has joined #lisp
<beach>
There is no simple way. You may use FOR ... THEN instead of TO/DOWNTO, but it is not necessarily going to be prettier than two loops.
<ldbeth>
ah, ok, I guess I can macrolet the body
varjag has joined #lisp
<charles`>
where did the package prefix trivial come from?
<Nilby>
charles`: It's kind of a meme that Lispers think everything is trivial, even when it's not, or at least not in other languages. Although it's true that many such packages are very simple portability wrappers around what is provided by an implementation.
ldbeth has quit [Ping timeout: 272 seconds]
frgo has joined #lisp
ldbeth has joined #lisp
frgo has quit [Ping timeout: 258 seconds]
narimiran has joined #lisp
nullx002 has joined #lisp
ldbeth has quit [Ping timeout: 265 seconds]
carkh has joined #lisp
ldbeth has joined #lisp
ldbeth has quit [Ping timeout: 264 seconds]
<fiddlerwoaroof>
I always just assumed that it was because those libraries are intended _not_ to do anything particularly interesting
<fiddlerwoaroof>
Except bridge incompatibilities between implementations
_jrjsmrtn has quit [Ping timeout: 256 seconds]
__jrjsmrtn__ has joined #lisp
varjag has quit [Ping timeout: 246 seconds]
nullx002 has quit [Quit: ERC (IRC client for Emacs 27.1)]
flip214 has quit [Changing host]
flip214 has joined #lisp
ldbeth has joined #lisp
gaqwas has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
ldbeth has quit [Ping timeout: 276 seconds]
bilegeek has quit [Quit: Leaving]
wxie has quit [Ping timeout: 276 seconds]
sauvin has joined #lisp
ldbeth has joined #lisp
gaqwas has quit [Remote host closed the connection]
ldbeth has quit [Ping timeout: 246 seconds]
gioyik_ has quit [Quit: WeeChat 3.0]
<logand```>
Alfr_: if call-arguments-limit is an issue: (reduce (lambda (l r) (let ((rr (length r))) (when (= l rr) rr))) '("hi" "th") :initial-value 2)
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
<logand```>
it would be much nicer if = returned the element instead of t
ldbeth has joined #lisp
cognemo has quit [Quit: cognemo]
cognemo has joined #lisp
<pyc>
(uiop:delete-directory-tree "/path/to/dir") gives me this error: UIOP/FILESYSTEM:DELETE-DIRECTORY-TREE was asked to delete "/path/to/dir" but it is not a physical non-wildcard directory pathname. I think the pathname is expected in a different format. How can I fix this call?
anticrisis has quit [Read error: Connection reset by peer]
<carkh>
try adding a "/" at the end
ldbeth has quit [Ping timeout: 240 seconds]
anticrisis has joined #lisp
<pyc>
carkh: same error. I think it needs a "physical directory pathname", not a string. I don't know what that means.
<pyc>
moon-child: the docstring cautions using `:validate t` with care? what if I did not want to use `:validate t` but do it the right way by making ensure-function happy? What is ensure-function?
<logand```>
moon-child: should? why?
<moon-child>
pyc: :validate t is the 'right thing' if that's what you want to do. :validate t is like rm -rf. Passing in a function there is like rm -i
<moon-child>
I agree that that's convenient. It would also be convenient if (eql 'a 'a) => 'a. This indicates that a more general solution, which can support the latter case as well, is in order
<pyc>
moon-child: does the pathname #p"/path/to/dir" in the call to uiop:delete-directory-tree always have to be an absolute path? Can I not use relative path there?
ldbeth has joined #lisp
<Nilby>
What should (= 3 3.0 3/1) return?
<logand```>
Nilby: why does the choice matter?
<Nilby>
Why does anything matter?
<logand```>
hmm this goes nowhere
<Nilby>
Feel free to make a (== x y) that returns whatever you want.
<logand```>
strange, i am discussing =
ldbeth has quit [Ping timeout: 276 seconds]
<logand```>
moon-child: (eql nil nil) => nil breaks that unfortunatelly
<Nilby>
Consider that the reasons for = returning a boolean have like 50 years of practical experience and argument and papers written about the reasoning behind equality predicates. Thankfully you can make your own equality function and use it and see which one you like best and what the problems could be.
<logand```>
moon-child: but that only shows that trying to apply it to eql is not a good idea, not that (= 3 3) => 3 is a bad idea
<logand```>
Nilby: that does not explain anything
ldbeth has joined #lisp
<moon-child>
logand```: my claim is that, once you know two things are equal, it's generally useful to know what one of them was, and that this doesn't just apply to numbers. I think there should be a more general solution to the problem, one that allows you to test (eql nil nil), know that the comparison was successful, and know that the object being compared was nil
<moon-child>
(incidentally, eql is a _better_ target for this than =, since it doesn't suffer from the problem Nilby points out where 3 and 3.0 are = and yet distinct)
<holycow>
thanks for the help guys. good night.
holycow has quit [Quit: leaving]
galex-713 has quit [Ping timeout: 272 seconds]
<Nilby>
logand```: Sorry. I'm bad at explaining but many people might be able to explain better than me.
<Nilby>
Another example, if I say (defun == (a b) (if (= a b) b nil)), then consider the performance/storage/gc differences between (= (expt 2 10000000) (expt 2 10000000)) and (== (expt 2 10000000) (expt 2 10000000))
ldbeth has quit [Ping timeout: 276 seconds]
<moon-child>
Nilby: I don't see what the difference is there
<Nilby>
One returns an object with a lot of storage requirements, the other can be stored in one bit.
theothornhill has quit [Remote host closed the connection]
theothornhill has joined #lisp
<moon-child>
you already needed to compute both numbers, though; waiting a little longer before freeing one doesn't matter much. Maybe you're done with the object before the next gc cycle anyway. And it's a trivial compiler optimization to avoid keeping around the object if you treat it as a boolean
cognemo has quit [Ping timeout: 272 seconds]
ldbeth has joined #lisp
<Nilby>
Maybe, maybe not. Maybe your compiler is smart enough to not even create the number in the = case. Maybe you're storing the results of the == case in a loop. = as it is, just has far less potential problems, and it's very easy to make == if you want it.
ldbeth has quit [Ping timeout: 276 seconds]
ldbeth has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
<logand```>
moon-child: those are not distinct by the = definition. it doesnt make sense to talk about = equality and mix in eql equality
<logand```>
Nilby: no extra storage needed, just return an existing argument
<moon-child>
logand```: yes but there are other definitions by which they are distinct, so it matters which you return
<logand```>
Nilby: interesting article, thanks
<moon-child>
logand```: yes but you have to keep storing that argument for longer
<logand```>
moon-child: not sure, i don't see how mixing eql with = makes sense
domovod has joined #lisp
Krystof has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
<logand```>
moon-child: i don't think storing for longer issue is an issue. even if it was an issue, returning the last argument would practically eliminate that issue
<logand```>
actually even returning the first one should not be an issue unless lisp can somehow gc function arguments before the function returns
<Nilby>
The equality operators in CL make people wonder, but there's a lot of deep and practical reasoning behind them.
<logand```>
so no, it would not store anything for longer
<logand```>
Nilby: the path-dependence argument is not very enlightening
<logand```>
esp when common lisp is far from perfect
<Nilby>
When I first saw - eq eql equal equalp ..., I was like WTF
<logand```>
yeah, well it makes sense, could it be different? how?
<logand```>
i think the (= 3 3) => 3 case could be different
<logand```>
same probably applies to < e.g. what if (< 1 2 3) returned 3? although this might be more controversial
jeosol has quit [Ping timeout: 240 seconds]
<Nilby>
yes
<carkh>
you have nil the false value, and nil the absence of something
<Nilby>
Interestingly you can make your own set of comparison operators and test out the performance.
<carkh>
= should return true because it's either true or false
<carkh>
if it's not = , that's not the absence of something
<carkh>
generally, predicates should return T or false (nil)
toorevitimirp has quit [Remote host closed the connection]
<moon-child>
carkh: you will note that the function is named =, not =p :)
toorevitimirp has joined #lisp
<carkh>
haha well = is the ultimate predicate
<logand```>
Nilby: of course you can make your own, for example if you write a calculator which needs to deal with not-yet-entered input, math operations that accept nil and return nil in nil case are useful. this brings the question, why does + not accept nil and insist on throwing error? is that more useful behaviour? scheme distinguishes #f nil and throws error, is that more useful behaviour? (i don't think so)
<carkh>
now going with this = returns its parameter thing to it ultimate conclusion, you get the c language
<logand```>
carkh: 3 is true
<carkh>
it isn't
<carkh>
it just isn't nil
<logand```>
you meant t
<logand```>
but i probably misunderstood, your point about the second argument was good
<logand```>
except i don't think that predicates should return T
<logand```>
(member 'a '(a b c)) -> '(a b c)
<carkh>
that's because member isn't just a predicate
<carkh>
(member 'b '(a b c)) -> '(b c)
<carkh>
it is usefull for other things
<carkh>
there are practical considerations i must concede on that
<logand```>
the same applies to =
<logand```>
it doesn't have to be just a predicate, it could be useful for other things
<Nilby>
I think when designing a language you have to consider not only utility, and advanced usage, but performance, and simplicity and how confusing something might be, and potential programming pitfalls. I feel like CL makes pretty good choices about these. I particularly like that it tries to not sacrifice efficiency while still allowing for flexibility.
<carkh>
i made a tactical mistake by conceding anything =D
<carkh>
time to call ansi and get started on that next CL spec
<logand```>
:-)
<logand```>
i think it is enough to understand how things could be different for now
<carkh>
i'd still vote for = returning t i think
<logand```>
Nilby: (+ 1 nil 3) -> nil should not sacrifice efficiency
<jdz>
logand```: That way lies madness (errors not caught where the arise, but propagate).
gum has quit [Ping timeout: 260 seconds]
<jdz>
logand```: If you want that behavior, try Javascript.
<logand```>
jdz: it depends on your the definition of "error"
<jdz>
NIL is not a number.
gum has joined #lisp
<logand```>
it is different, i am not talking about coercion
<jdz>
logand```: Are you trying to argue that CL should have ternary logic?
<jdz>
Like SQL?
<logand```>
nil is a shortcircuit thing: (and 1 2 nil 4 5)
<logand```>
not at all comparable to sql
<logand```>
nothing to do with ternary logic
<carkh>
it is not a shortcircuiting thing : (or nil :a)
<carkh>
that's a matetr of context
<jdz>
I may be missing the beginning of this discussion, but why would (+ 1 nil 3) return nil?
<logand```>
becase that is the definition of or
<carkh>
and it short circuits because of the definition of and
<Nilby>
I'd be interested to see the design of a computer where it doesn't have an efficiency impact if a return type is (or null number) vs number.
<logand```>
s/computer/lisp is relevant i think
terrorjack has joined #lisp
<jdz>
Nilby: It seems to me that IEEE floats cover this (NaN being the null part, a specially encoded number).
<logand```>
lisp already hast to deal with that
<logand```>
jdz: it seems like it except specific to ieee floats
pve has joined #lisp
<logand```>
but how would i use it in lisp? (+ 1 nan 3) -> nan
<jdz>
I seem to remember there is quite huge unused value space in floats, so they might be used for value tagging, so all we really need is floats. Somebody should code up a CL which uses floats for everything.
<moon-child>
pls no
<jdz>
For science!
<moon-child>
(that's nan-tagging, and it's used by some lua and js implementations)
<beach>
jdz: It is called "NaN boxing".
<jdz>
Oh, there you go, my original idea is not even original. What a bummer.
<ecraven>
it's been in use for some 30 years or so ;)
<logand```>
is nan first class value in lisp?
<moon-child>
jdz: compared with the fixnum-boxing employed by most cl implementations, unboxing a float is a somewhat expensive operation. It makes sense for lua and js only because there are no integers
<Nilby>
NaN has no place in my number system
<pyc>
In my SBCL, when I try to use uiop, I get: Package UIOP does not exist. What could be the issue? I don't have quicklisp at this time. Is quicklisp mandatory to use uiop?
<pyc>
I thought uiop comes with SBCL these days
<logand```>
require :asdf?
<carkh>
do you have asdf ?
<pyc>
thanks logand```, carkh. That was the exact issue. Works fine after (require :asdf).
<pyc>
Then I will always (require :asdf) in my programs to keep them portable, so that they run on any implementation regardless of whether quicklisp is installed or not.
<beach>
pyc: Yes, put that in your .sbclrc
<logand```>
better be explicit and write it in programs instead of .sbclrc
hendursa1 has joined #lisp
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
<pyc>
beach: logand```: I normally use quicklisp, so quicklisp adds some code to .sbclrc which loads asdf by default anyway. I was more concerned about the user experience, someone who has plain sbcl but may not have .sbclrc or quicklisp. for them I will (require :asdf) in my programs itself to keep it more portable.
hendursaga has quit [Ping timeout: 268 seconds]
<logand```>
.sbclrc is a bad idea if not using sbcl, .sbclrc is a bad idea if sharing that code with somebody else, .sbclrc is a bad idea if you want to save time in the future
_heisig has joined #lisp
jibanes has quit [Ping timeout: 272 seconds]
<pyc>
logand```: agree
heisig has quit [Ping timeout: 240 seconds]
nicktick has quit [Ping timeout: 276 seconds]
jibanes has joined #lisp
<pyc>
what is the #p called in paths like #p"/tmp/foo"?
<jdz>
logand```: I have ~/.common.lisp, which is loaded from ~/.sbclrc, ~/.ccl-init.lisp, ~/.eclrc, etc.
<jdz>
Might as well create a single file with reader conditionals, and link the implementation-specific rcfiles...
<jdz>
Or rather not -- too much trouble to work around implementation-specific packages.
ldbeth has quit [Ping timeout: 256 seconds]
<jdz>
Never mind, *read-suppress* is there for a reason.
skapata has joined #lisp
ldbeth has joined #lisp
zaquest_ has quit [Quit: Leaving]
zaquest has joined #lisp
ldbeth has quit [Remote host closed the connection]
ldbeth has joined #lisp
catt has joined #lisp
frgo has quit [Remote host closed the connection]
iskander has quit [Ping timeout: 256 seconds]
iskander has joined #lisp
hiroaki__ has quit [Ping timeout: 272 seconds]
cods_ is now known as cods
cods has quit [Changing host]
cods has joined #lisp
carkh has quit [Remote host closed the connection]
datajerk_ has quit [Ping timeout: 256 seconds]
ljavorsk has quit [Ping timeout: 240 seconds]
grumble has quit [Quit: K-Lined]
datajerk has joined #lisp
grumble has joined #lisp
hiroaki__ has joined #lisp
logand``` has quit [Quit: ERC (IRC client for Emacs 27.1)]
imode1 has quit [Ping timeout: 260 seconds]
logand has joined #lisp
<ldbeth>
actually, you can dump a image with quicklisp preloaded
<ldbeth>
so you can get rid of the .sbclrc etc thing
theothornhill has quit [Ping timeout: 264 seconds]
Oddity- has quit [Ping timeout: 272 seconds]
Oddity has joined #lisp
hjudt has quit [Ping timeout: 276 seconds]
frgo has joined #lisp
theothornhill has joined #lisp
luni has joined #lisp
frgo has quit [Ping timeout: 265 seconds]
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
niac has joined #lisp
<pyc>
If I have a variable x with "hell" in it, how can I append the character literal #\o to x, so that I get "hello"?
<beach>
pyc: Do you mean that the value of the variable is "hell"?
<pyc>
beach: yes
<beach>
pyc: Either the string has a fill pointer and you can do it by modifying the value itself, or else you need to change the value.
<beach>
er, or else you need to give the variable a new value, computed from the old.
<pyc>
beach: I mean I have (defvar x "hell"). I can always do something like (concatenate 'string a "o") to get "hello" but what if I want to supply #\o instead of "o"?
<beach>
Sorry, fill-pointer is not required. It has to be ADJUSTABLE, I mean.
ldbeth has quit [Remote host closed the connection]
ldbeth has joined #lisp
FennecCode has joined #lisp
ebrasca has joined #lisp
ldbeth has quit [Ping timeout: 264 seconds]
ldbeth has joined #lisp
<_death>
funny, I just had some email exchange with someone who knows a little Lisp about such operations.. actually it was about bombs, and not in English, but here's a translation of a message: https://gist.github.com/death/68ddf9eb12ed9f133364fc71200d6511
phantomics has joined #lisp
kevingal has joined #lisp
kevingal_ has joined #lisp
vegansbane6963 has joined #lisp
frgo has joined #lisp
<Nilby>
_death: Lisp has some weird history. Somehow that reminds me of P.K.Dick.
orivej has joined #lisp
<beach>
The fact that Xach brought up chapter 31 of the SICL specification http://metamodular.com/SICL/sicl-specification.pdf yesterday made me realize that there was (and still is) more important stuff to include.
<beach>
So I wrote sections on documentation strings (now 31.3), use of the most specific construct (31.11) using packages (31.12), and I expanded the section on commenting (31.4). After my lunch break, I'll write the section on names of slot accessors (31.13) which is still empty.
<beach>
Comments are welcome, except the ones in the categories "I disagree", "But *I* prefer...", etc. Because I already know the arguments.
niac has quit [Ping timeout: 240 seconds]
<_death>
maybe summarize the normative with Dos and Don'ts, like 31.2 Don't write lines that are too long
madage has quit [Remote host closed the connection]
madage has joined #lisp
luni has quit [Quit: Connection closed]
aartaka has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
bitmapper has joined #lisp
<_death>
also I'm wondering if you meant that about four semicolons
aartaka_d has joined #lisp
<_death>
also, "the last line of the file should not be blank" is unclear to me.. it is a common convention to have text files end with a newline, so in a sense the last line is always blank
<loke`>
Yeah, that one tripped me up too.
<loke`>
A text file is usually defined as ending with a newline, and with that definition Beach's working is correct.
ldbeth has quit [Ping timeout: 256 seconds]
ldbeth has joined #lisp
<loke`>
Adding a clarification on the terminating newline would be a good idea though.
OlCe has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
<jmercouris>
I personally don't think it matters that there is a terminating newline
<jmercouris>
why would it ever matter?
<jmercouris>
in what case would code be correct/incorrect based on the presence of such a line
gzj has quit [Remote host closed the connection]
gzj has joined #lisp
epony has joined #lisp
<logand>
jmercouris: iirc for eg wc -l
jeosol has joined #lisp
<_death>
all code that depends on this convention.. many unix tools
<ldbeth>
that could means cat output on terminal would be crappy
<_death>
if you don't think it matters, modify your current tools to not add a newline (because they likely all do it) and see what happens
<jmercouris>
OK
<Nilby>
what happens is the shell puts in a "magic" indicator, grep works, and wc is one off
<jmercouris>
I don't like to use such tools anyways though
<jmercouris>
I basically only use Emacs
<jmercouris>
I find unix tools idiotic in design
<_death>
what about github?
<jmercouris>
What about GitHub?
<_death>
do you like those red indicators? :)
<jmercouris>
The diff for PRs you mean?
<_death>
no, the indicators you get when there's no terminating newline
<_death>
(I think github has them)
<ldbeth>
emacs auto appends newline
<jmercouris>
I don't mind them, Pierre is annoyed by them
<jmercouris>
so I do add a newline
<jmercouris>
and I remove trailing whitespace etc..
<_death>
see, that's the thing about conventions.. they're not about just you :)
<jmercouris>
I follow conventions, even if I don't agree with them
<jmercouris>
something something branch that bends does not break
<Nilby>
i originally wrote my wc to be correct, but then I caved into the stupid unix way
<_death>
good.. that's the value of conventions, that people follow them even if they're not perfect
<_death>
and now you can recognize that it does matter whether a newline is added or not
<logand>
and sometimes it is good not to follow conventions, esp if they are not perfect
<logand>
that's how progress is made, maybe
ldbeth` has joined #lisp
aindilis has quit [Ping timeout: 240 seconds]
aindilis` has joined #lisp
ldbeth has quit [Ping timeout: 276 seconds]
<_death>
logand: more often it's in the other direction.. and this is why the software world looks like what it looks like nowadys ;)
<_death>
new conventions are constantly created without looking into how previous conventions went off and came about
<jmercouris>
the problem is many conventions were created by inertia, or no longer technically relevant problems
<Nilby>
Just using Lisp is pretty defiant, but missing final newlines bug me
<jmercouris>
reminds me of the famous paradigm of the bananas and the monkeys getting squirted
<_death>
existing conventions are deemed imperfect, and some take this to mean they are worthless and create new conventions that have the exact same issue but without the advantage of status quo
<jmercouris>
I don't think it can be fully generalized like this
<jmercouris>
oftentimes new convenions /are/ superior, and they become the new convention
<_death>
disagree.. oftentimes new is shiny and fad is the convention
<jmercouris>
for example, OO superseding procedural code for large programs
<jmercouris>
I think that OO is a much better convention for big programs
<jmercouris>
however were we to still write assembler, we'd be stuck in a procedural mindset
<ldbeth`>
why procedural mindset considered bad
<jmercouris>
did I say it was bad?
<jmercouris>
I said OO was superior for large programs
<_death>
do you not know about Randall Hyde and his quest for High Level Assembly? ;)
<jmercouris>
I am very much a procedural programmer myself, often favoring it as a paradigm
<ldbeth`>
but fortran can be oo
<jmercouris>
that's a really cool story ldbeth` , however, I don't see how that is relevant to my argument
<ldbeth`>
nothing stops people thinking oo even writing assembly programs
<jmercouris>
it is unrelated to my argument
<jmercouris>
my argument is about OO superseding Procedural as a convention
<jmercouris>
for large programs
<_death>
I'm guessing it's all veering into offtopicness or, by channel convention, lispcafeness (lispnescafe?)
<jmercouris>
agreed
<ldbeth`>
That could be personal test of project manager team something
<beach>
_death: Do you mean like at the end of each section?
random-nick has joined #lisp
orivej has quit [Ping timeout: 276 seconds]
<beach>
I see what you mean about the blank lines. I'll see what I can do about that.
ldbeth`` has quit [Ping timeout: 264 seconds]
v3ga has quit [Ping timeout: 240 seconds]
v3ga has joined #lisp
Sheilong has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
varjagg has joined #lisp
<beach>
I mostly agree with _death. Most conventions don't exist because of some reason of technical superiority but as Pinker puts it because some "tacit agreement". Their main advantage is to exist. So abandoning them in favor of others, that are not agreed upon, is very unfortunate.
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
<beach>
But I often see evidence here of the common idea that we should do whatever we please because conventions are crap and we know better than all those silly old people who came before use.
totoro2021 has joined #lisp
vaporatorius__ has quit [Quit: Leaving]
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
<carkh>
kevingal_: thanks
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
varjagg has quit [Ping timeout: 276 seconds]
contrapunctus has joined #lisp
sm2n has quit [Ping timeout: 264 seconds]
pagnol has joined #lisp
srandon111 has joined #lisp
pfdietz has quit [Ping timeout: 240 seconds]
<beach>
For instance, there is absolutely no technical reason to use `argc' and `argv' as names of the parameters of `main' in C. And there is no technical reason to prefer `i', `j', `k' as loop variables for indices of arrays. Mathematicians use `x', `y', `z' for numbers, but there is no technical reason for that either.
<beach>
It is just, like I wrote in that chapter, and arbitrary convention that evolved over time, often for unknown reasons. And that is exactly why we should continue using it.
gzj has quit [Remote host closed the connection]
<jackdaniel>
if there is a good reason to break a convention I'd say that one should do that. otherwise conventions would not evolve over time. I don't consider "not liking it" being a good reason for breaking the convention though.
<beach>
I totally agree, and I deliberately try to break some conventions myself. Like the one of prefixing a slot accessor with a class name, rather than using the package system.
sm2n has joined #lisp
<jackdaniel>
I often get confused when there are too many packages in the codebase I'm reading
<jackdaniel>
but that's probably a personal trait
<beach>
But, I wrote that chapter as a guide for inexperienced people who might not even recognize the existence of conventions, because they probably have little experience from reading other people's code. So the emphasis is on following conventions rather than breaking them.
<jackdaniel>
sure, makes sense
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
jeosol has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
ldbeth``` has quit [Ping timeout: 276 seconds]
X-Scale has quit [Ping timeout: 256 seconds]
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
<_death>
sometimes defining a scope for a convention is useful.. for example in this file/library/organization they use class-foo names, so I'll add class-bar.. but in this library they use foo names, so I'll add bar.. in this way different conventions can coexist while maintaining some level of sanity
jonatack has joined #lisp
<beach>
Absolutely.
contrapunctus has joined #lisp
<jackdaniel>
(/me also agrees)
ldbeth``` has joined #lisp
ldbeth``` has quit [Ping timeout: 246 seconds]
<_death>
throughout the lifetime of a programmer it makes sense "try on" different conventions.. sometimes you settle on the ones you like, and sometimes they are more dependent on context.. so some of my projects are written in one style, and others are written in a very different style.. sometimes it's the result of an "accident", i.e. "trying on", and other times it's on purpose..
<Xach>
One problem comes from people who disagree so strongly they refuse to participate unless everyone else agrees to their demands.
<beach>
_death: Do you mean different choices of existing conventions, or establishing conventions for situations where none exist?
<_death>
and the inexperienced can indeed benefit from trying to follow guides that lead coherent styles
<_death>
*to
<_death>
beach: both
<beach>
I see.
<_death>
beach: when writing a program, you often need to develop conventions specific to it
<_death>
beach: and throughout the relatively long evolution of Lisp, there have been different ways of doing some things :)
<beach>
Definitely. That's why I thought that this is what you meant.
<beach>
_death: I find that these conventions evolve over time, more like a progression from conventions that did not work out so well to more solid ones.
<Xach>
beach: I very much like the section on the Dunkers in Franklin's autobiography on the topic
<_death>
beach: I guess some of them do, yeah.. because we as a (CL) community tend to appreciate Lisp tradition and learn the history
<beach>
Xach: Very nice!
* easye
applauds Ben's text.
<beach>
_death: Exactly!
<_death>
beach: unfortunately as communities grow larger, it's almost inevitable to regress or diverge
ldbeth``` has quit [Ping timeout: 240 seconds]
<beach>
_death: That's part of the reason that I am always a bit queasy about the desire to enlarge the use of Common Lisp at all cost.
<_death>
beach: but that's where your style guide or other writings or help on irc for example may help ;)
<beach>
That's why I am trying to finish this text before Common Lisp become hugely popular. :)
<_death>
;)
<_death>
family time.. later ;)
<beach>
Take care!
ldbeth``` has joined #lisp
narimiran has joined #lisp
ldbeth``` has quit [Ping timeout: 264 seconds]
FennecCode has quit [Ping timeout: 240 seconds]
warweasle has joined #lisp
theothornhill has quit [Ping timeout: 264 seconds]
FennecCode has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
ldbeth``` has joined #lisp
<shka_>
i sometimes think that re-branded Common Lisp would had a better shot at becoming popular
<semz>
Rebranded?
ldbeth``` has quit [Ping timeout: 265 seconds]
<beach>
I think shka_ is suggesting a different name, so that people who associate "Lisp" with slow, interpreted code with lots of parentheses would not immediately reject it.
<beach>
And that might work for young inexperienced programmers who don't care to learn about computing history, but I think "Lisp" is an indication of a heritage we should be proud of.
<shka_>
beach: yes
jonatack has quit [Read error: Connection reset by peer]
jonatack_ has joined #lisp
<Nilby>
I don't care if everyone calls it PowerLang™ DynamicScript™, I'm still gonna program in Lisp.
<beach>
I for one do not particularly want to attract people with uninformed opinions like that to Common Lisp. We would spend the rest of our lives giving them newbie advice here.
<semz>
Yeah it seems like a bad audience to cater to.
<beach>
Absolutely.
<semz>
I think the stigma of slow interpreted code has largely faded nowadays though.
<semz>
The one about parentheses has obviously stuck however
ldbeth``` has joined #lisp
<contrapunctus>
shka_: like Julia or CL21? 😏
<beach>
semz: In some groups, very likely. Like Python programmers, for instance. But I bet that many C++ programmers still think their code is faster than what we could produce with Common Lisp. And that might be true for some truly unmaintainable C++ code, but not for modular C++ code, as I often point out.
<shka_>
contrapunctus: ha!, julia is not a common lisp but close enough i guess!
<antoszka>
I don't think it's in any way close
<antoszka>
I see more unfortunate resemblance to Python
<fitzsim>
Dylan was an attempt to provide an alternative to parentheses
<loke`>
semz: I'd hope so. People keep using Python these days which is the slowest language I've ever had the misfortune to lay eyes upon.
<fitzsim>
I skimmed OpenDylan recently and didn't see many references to Common Lisp in the code though
<Nilby>
and yet Dylan, which is seems like one of the most easily readable language ever, didn't seem to become popular. so I think language popularity has more to do with external factors.
<loke`>
The speed argument was only popular when all the cool kids were using C, which has pretty much only a single thing going for it: I can be fast (at least on the computers at the time)
<fitzsim>
I guess Dylan was bootstrapped from Common Lisp but then later by itself or something?
jonatack_ has quit [Quit: jonatack_]
ldbeth``` has quit [Ping timeout: 276 seconds]
<epony>
loke`, that is why the operating system kernels are written in Lisp hahaha
<beach>
Nilby: Oh, definitely. The people who think that changing the syntax of Common Lisp will magically make it more popular are definitely wrong.
<Nilby>
fitzsim: yes
jonatack has joined #lisp
<semz>
loke`, may I introduce you to Ruby?
<fitzsim>
I was hoping that OpenDylan would sit on top of Common Lisp, and offer an alternative syntax; that's why I wanted to try it
<fitzsim>
out of interest
<kevingal_>
What would you call a rebranded Lisp? I propose "Stammer".
<fitzsim>
has anyone tried to implement Python syntax hosted on Common Lisp?
<beach>
epony: Why is that funny?
<epony>
it's hilarious
<contrapunctus>
kevingal_: lol
<beach>
epony: C is a very bad choice indeed for operating systems.
sjl has joined #lisp
<epony>
the rest of the world thinks that for Lisp
<beach>
epony: Hell, "kernel" is a very bad choice for operating systems.
<Nilby>
epony: There are a number OS kernels in Lisp.
<epony>
that's what all OSes use
<beach>
epony: That doesn't mean it is good.
rogersm has joined #lisp
<epony>
yeah, we've seen the REPLs pretending to be IDEs / OSes too
cantstanya has quit [Remote host closed the connection]
<contrapunctus>
I liked * the idea of CL21 ("modernizing" the language while leveraging existing CL implementations)
<shka_>
this looks a cosmetic changes honestly
jonatack has quit [Excess Flood]
<shka_>
if anything, I still think that porting some of the C++ <algorithm> (preserving semantics where it would make sense) wouldn't be a terrible idea for a project
jonatack has joined #lisp
cage_ has joined #lisp
<shka_>
but yeah, i think that stylewarning comment is on point, you need tested, de facto standard tools
<semz>
The STL does have some nice ideas. It's a shame that a lot of the related material (Stepanov's generic programming stuff too) is buried under mountains of C++ arcana and other obscurantism.
pegu has quit [Remote host closed the connection]
<semz>
I found Elements of Programming utterly unreadable for that reason
jonatack has quit [Ping timeout: 276 seconds]
<shka_>
yes, i think that all things considered it is a well designed library (in most of the areas)
<shka_>
a little bit over-standardized perhaps
pagnol has quit [Ping timeout: 265 seconds]
jonatack has joined #lisp
<beach>
contrapunctus: Hah, one of my engineering students laughed very hard when I hinted that sockets could be used by a Common Lisp program.
<beach>
epony: Can you please elaborate?
<warweasle>
beach: Are sockets limited to certain langauges?
<Nilby>
ironc that Symbolics was the first .com
hiroaki__ has quit [Remote host closed the connection]
<beach>
My student was convinced that Common Lisp was a toy that could not be used for real programming. Or so he wanted to believe so as to avoid the cognitive dissonance that would otherwise be inevitable.
<shka_>
semz: actually i think that D library is even better
<warweasle>
Learning Lisp, Forth and Prolog has changed how I look at programming.
<Xach>
warweasle: you should have learned lisp *first*
<warweasle>
beach: Your next assignment should be to write a quick lisp interpreter.
<shka_>
warweasle: lol
<beach>
Oh, I don't do assignments anymore. That was a while ago.
<warweasle>
Xach: Yes. But I didn't know. And microsoft kept telling me to learn C++, MFC and COM.
<warweasle>
At the time... Anyone else have PTSD from trying to understand Micrsoft's ATL?
slyrus has joined #lisp
<Nilby>
warweasle: you might know that beach's current "assignment" is writing our next super CL compiler :)
<pyc>
Is there a quick way to surround the current sexp with parentheses in Emacs or Paredit?
<contrapunctus>
pyc: M-( or something
charles` has joined #lisp
slyrus has quit [Remote host closed the connection]
<contrapunctus>
pyc: I don't remember the command and I don't have a computer ATM 😔
<Xach>
pyc: I don't think this is the best way, but I use ( M-<right-arrow> to do that.
<Xach>
pyc: this only works at the start of a sexp
<warweasle>
Nilby: Is it an actual super compiler? because those are AWESOME.
<contrapunctus>
pyc: if you use Boon, you can `a p ;` to surround the expression after point with parens and `a p j` to do it for the expression before point; Evil probably has an extension for it too; and amartparens definitely does it.
<warweasle>
Maru? It's a cool concept but I think it stalled.
<Xach>
warweasle: attila_lendvai might have
<pyc>
contrapunctus: I use Emacs4CL which is just plain Emacs + sbcl + slime + paredit. So M-( works great for me.
<warweasle>
Xach: Your humor is so dry I sometimes can't tell when you are joking.
<warweasle>
OH, attila_lendvai is in the channel.
<warweasle>
WOW.
<attila_lendvai>
warweasle, it's been dead, and in the past year it became a one-bus project... :)
<warweasle>
attila_lendvai: There was so much I didn't understand but it's intriguing. A mix of machine code and lisp?
<pyc>
Xach: did you mean ( C-<right-arrow>. That slurps forward. I don't see what M-<right-arrow> is supposed to do.
<warweasle>
(Please forgive me if I mixed your project up with another. It's been a minute.)
<attila_lendvai>
warweasle, the code wasn't very accommodating to newcomers, but i think it got much better in that regard.
<attila_lendvai>
warweasle, and i wrote some docs in the docs/ dir! if you have read them, then i welcome any questions that remained foggy afterwards!
<warweasle>
Now that I know who to ask, I might look back into it. But first I need to get my current project working.
<Xach>
pyc: yes, thanks for the correction.
<warweasle>
attila_lendvai: It's been a while, so I'll need to read them again. I'm pretty sure I'm running a stack based OS in my head.
slyrus has joined #lisp
<slyrus>
Has anyone taken a stab at better pretty printing facilities in the last, oh, 30 years? The built in pretty printer is showing its age, IMO.
<warweasle>
slyrus: How can you improve perfection?
<slyrus>
heh
<semz>
what is wrong/missing that can't be corrected with the printer variables?
slyrus has quit [Remote host closed the connection]
slyrus has joined #lisp
kam1 has quit [Read error: Connection reset by peer]
<pyc>
how can I check my asdf version?
<slyrus>
part of it may be my lack of understanding but it is a pain to use and harder to get things to look right. Also, it very much seems designed around printing lisp forms. If you're data isn't a list, the built in capabilities seem very limited.
<Xach>
slyrus: i'm curious if there are other systems you like from which good ideas might be stolen...
<slyrus>
I'm looking for those :)
gabc has joined #lisp
F________ has joined #lisp
F________ is now known as Feldman
<beach>
slyrus: Sounds like a perfect project for you. :)
<beach>
slyrus: I'll use the result as the pretty printer for SICL.
<beach>
slyrus: And while you are at it, please improve its specification/documentation.
slyrus has quit [Remote host closed the connection]
* beach
still can't figure out what epony was referring to.
slyrus has joined #lisp
perrier-jouet has quit [Quit: WeeChat 3.0]
<gabc>
Hi, I'm on windows and I'm trying to find out a good way to do lisp (on linux/mac I use sbcl+emacs and it's great) but I haven't have been able to figure something nice on windows
<gabc>
Is there any tips here that can help?
<Xach>
gabc: people seem to really like portacle for an easy way to get set up
<pyc>
What is a good coding style? require statement at the top of a .lisp file? or just before where I need to use the package?
<epony>
well, who makes the comparisons and false claims, elaborates.. since they are defending their claims ;-) I have nothing to say on that topic.. it was all outlined in several obvious facts from all systems that pick C for systems programming regardless of what other language users think about their own favourites
<Nilby>
I used sbcl+emacs on windows. and ccl too
slyrus has quit [Remote host closed the connection]
slyrus has joined #lisp
<gabc>
I'll take another look at sbcl on windows
<beach>
epony: Can you give an example of "Lisp people always try to compare themselves on speed with a failure of some sort in programming design application". I can't even parse the phrase.
<pyc>
gabc: SBCL + Emacs should work fine on Windows too. I use https://github.com/susam/emacs4cl Much simpler alternative to Portacle. you can use your own Emacs with this config.
<Xach>
pyc: REQUIRE is uncommon in source files these days
<Nilby>
I'm pretty sure I just installed the whatever current versions at the time. The tricky part is making sure you have a libffi for sbcl, which I had to do with cygwin.
<gabc>
I'm trying to get an sbcl on WSL and my emacs on windows, and it works until I do M-.
<Xach>
pyc: much more common to define a system and load the system
<Nilby>
I didn't try on WSL.
<epony>
well, you can parse it of course.. since people compare Lisp as speed with things that are slow and failing
<slyrus>
beach: no, this one's above my pay grade. But I probably could spend some time formalizing my gripes.
<pyc>
Xach: I need (require :asdf) because I am using uiop. what would be the way to load it without (require)? sorry, I haven't learnt systems yet
<beach>
slyrus: Oh, too bad!
<slyrus>
btw, props to stassats for getting amd64 macos sbcl working so quickly!
<pyc>
gabc: did you set up Emacs + SBCL on linux and macos yourslf? what else do you use? do you have SLIME? do you use paredit?
<Xach>
pyc: usually you would express a dependency on the UIOP system
<slyrus>
beach: I can't be the first person to have complained and/or thought about how to make things better in the last 3 decades.
<Nilby>
gabc but I didn't use slime since I was working on stuff that ran in a windows console
<pyc>
Xach: any documentation you can point me to to learn this stuff?
<gabc>
pyc: I use lispy mostly that part of the config I have quite down, I just never used Windows to do lisp
<beach>
slyrus: Specifically about the pretty printer? I don't know.
<gabc>
and I'm sad it's not as easy as on linux/mac
<Xach>
pyc: hmm, i would try looking at some existing projects and libraries, and look at the .asd files
<pyc>
Xach: thanks
<Nilby>
slyrus: I've been thinking about it too, and if you check the irc logs death found some good papers.
<gabc>
Nilby: oh right I see so you just started the program in the terminal each time?
<Xach>
pyc: at their simplest, a system file defines a system with a name, a list of zero or more prerequisite systems, and a list of source files to compile and load.
<Xach>
pyc: so if you see an overwhelming system definition, know that it doesn't have to be that complex
<gabc>
And I'm not convinced I want to pay a lot for LispWorks
<Nilby>
gabc: For emacs, I just clicked on it, but for sbcl I was working on my own repl in a console window.
<Nilby>
gabc: I could go test it out, but I'm pretty sure slime will work too.
<slyrus>
beach: yes, with the pretty printer. sometimes even small-seeming details around the margins make things much more useful. The analogous example for me is the with-readtable stuff. makes readtables much more usable, IMO.
<beach>
I see.
<gabc>
Nilby: I have it working but I came here to see if people use something else I remember running into problems (that I forgot it's been a moment) I'll try out more and if I get into something specific I'll ask again
<gabc>
Nilby: your nickname is similar to the person who did `lish` is that you?
<Nilby>
slyrus: I've been trying to use the pretty printer to do indenting in my editor, but so far the results aren't so good. But I haven't tried much tweaking yet. I have to read/re-read some papers.
<Nilby>
gabc: That's my evil twim.
<Nilby>
twin
<gabc>
Oooh okok
<slyrus>
Nilby: yes, it's hard to use, and harder still to get the desired output.
<gabc>
If you see him tell him I had fun playing with that software :)
gioyik has joined #lisp
srandon111 has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 265 seconds]
slyrus has quit [Remote host closed the connection]
<logand>
beach: is a text version sicl-specification.pdf available, prefereably via git?
long4mud has quit [Quit: WeeChat 3.0.1]
slyrus has joined #lisp
charles` has quit [Ping timeout: 258 seconds]
<beach>
logand: Definitely.
<beach>
minion: Please tell logand about SICL.
<minion>
logand: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
_heisig has quit [Ping timeout: 246 seconds]
<beach>
logand: Look in the Specification directory.
cognemo has joined #lisp
theothornhill has joined #lisp
<beach>
logand: If you have more specific questions about it, we hang out in #sicl.
kevingal_ has quit [Remote host closed the connection]
kevingal has quit [Remote host closed the connection]
luni has joined #lisp
<logand>
beach: thanks, i'll have a look
<logand>
hmm #sicl needs password
vegansbane6963 has quit [Remote host closed the connection]
<Bike>
oh, it's +r. you need to be logged in on freenode.
<beach>
You might have to be registered.
<logand>
can I have two identities in erc?
<beach>
You may have to start a separate Emacs session.
<logand>
i see
<beach>
I am not sure. Just guessing.
<beach>
logand I am usually present between 5am and 6-7pm (UTC+1 at the moment) with some breaks. But there are people in several other time zones that can answer questions in case you have any.
<logand>
beach: i need to think about questions first but if i find something to say, i will:-)
<logand>
beach: which country are you in?
<logand>
berlin here
zups has joined #lisp
zups has quit [Client Quit]
terpri_ has quit [Remote host closed the connection]
akoana has joined #lisp
long4mud has joined #lisp
charles` has joined #lisp
<beach>
logand: Bordeaux, France.
<logand>
nice i've never been to bordeaux, maybe one day
<beach>
It's a beautiful place now.
<warweasle>
Is there where Bordeaux-Threads comes from?
<beach>
Yes, Dan Barlow came up with it during LSM/RMLL, perhaps 2000 or 2001 or something like that.
<beach>
Krystof may remember more details.
jonatack has quit [Ping timeout: 265 seconds]
<beach>
That's also where gilberth created the basis for McCLIM. And where we came up with how SBCL should represent special variables in the presence of threads.
<beach>
Maybe Dan did ASDF there too? I can't remember.
* Nilby
misses Bordeaux gastronomically
<beach>
Oh, and the first ELS was organized in Bordeaux. I was the local organizer.
<beach>
Poor Krystof had to translate the speech of the adjunct mayor from French to English in real time.
aindilis` has quit [Remote host closed the connection]
<beach>
It appears that mayors of France have, as part of their job description, the obligation to organize a (free) cocktail party for visiting conferences, so we were invited to the splendid city hall for one of those.
jonatack has joined #lisp
orivej has joined #lisp
aindilis has joined #lisp
<Nilby>
Apparently the mayoral duties in Bordeaux included the mayor (or assistant) said I looked like a sheep, but might have a black heart.
<beach>
Really?
<Nilby>
Yes.
<beach>
Wow!
<Nilby>
It was strange.
<beach>
I can imagine.
<Nilby>
But it's a lovely building. :)
<beach>
:)
<beach>
Dinner. I'll be back tomorrow.
<Nilby>
enjoy
perrier-jouet has joined #lisp
<warweasle>
I forget how international the lisp community is. I'm just dumb american. Hopefully I'll get to travel some day.
<Nilby>
The Lisp community is interplanetary.
<warweasle>
Nilby: We have some lispers on the IIS?
edgar-rft has joined #lisp
perrier-jouet has quit [Quit: WeeChat 3.0]
<charles`>
warweasle I think he is referring to the aliens that gifted it to us.
<Nilby>
Hmmm. Probably. But that's not a planet.
<contrapunctus>
I thought they meant the Voyager 1 😄
<warweasle>
Wasn't there a probe saved by lisp?
<contrapunctus>
warweasle: ^
varjagg has joined #lisp
zaquest has quit [Ping timeout: 276 seconds]
<warweasle>
Anyone here know more about the NAVSEA programming language study. Lisp was one of the languages used and I'd love to get some context.
surabax_ has joined #lisp
<warweasle>
Namely, they held things against lisp like "not being understandable" and "the developer showed up late".
zaquest has joined #lisp
karlosz has joined #lisp
surabax has quit [Ping timeout: 272 seconds]
karlosz has quit [Quit: karlosz]
jeosol has joined #lisp
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
theothornhill has quit [Ping timeout: 240 seconds]
terpri has joined #lisp
surabax_ has quit [Quit: Leaving]
themasterbuilder has joined #lisp
galex-713 has joined #lisp
<contrapunctus>
warweasle: that's...simultaneously funny and sad.
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
ebrasca has quit [Remote host closed the connection]
toorevitimirp has quit [Remote host closed the connection]
<warweasle>
contrapunctus: I can't find the paper right now, but they were really leaning into Haskell.
<warweasle>
They gave it the win although lisp was done more quickly and with fewer errors.
casual_friday has quit [Quit: %bye%]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
dbotton has joined #lisp
luni has quit [Quit: Connection closed]
perrier-jouet has joined #lisp
<beach>
That sounds very similar to the paper by Hudak and Jones that I often cite.
<beach>
When was this contest supposed to have happened?
<alanz>
wasnt paul hudak one of the founders of haskell?
<beach>
Hudak is one of the creators of Haskell, and that paper was specifically about Haskell, so it is not surprising that they favored it.
<beach>
Yes.
<alanz>
but that music thing he did had a very lispy feel to it
<beach>
But there was an entry for something called "relational Lisp" that beat the others.
<beach>
I used that paper in my teaching, and I have an industry talk based on it. But not because of Haskell or Lisp, but because of the factor 20 difference in productivity reported, between different experts using the respective language that they master.
<beach>
warweasle: But that's not what you are asking about?
<beach>
Anyway, the title of that paper is "Haskell vs Ada vs ..."
* beach
vanishes.
slyrus has quit [Remote host closed the connection]
slyrus has joined #lisp
scoofy has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
<albusp_>
Would anyone know why I can't load cl-freetype2 to lispworks7.1? Error is No applicable methods for make-instance with args ft-outline-funcs
domovod has quit [Ping timeout: 264 seconds]
_heisig has joined #lisp
_heisig has quit [Client Quit]
sauvin has quit [Read error: Connection reset by peer]
holycow has joined #lisp
<holycow>
hi
<pyc>
what is the right place to ask SLIME-related questions? #lisp or #emacs?
<Bike>
starting here is probably fine.
<Bike>
i think there is also a #slime, though i don't know how active it is.
<edgar-rft>
pyc: there's even a #slime channel :-)
<holycow>
if i have a string in the form of /dir/dir/dir/dir/filename.txt, i would like to find the last / char and then extract rest from that line. i have looked at strings, pattern matching and regex on clcookbook but i'm not finding how to find the last / char. any tips on what to google?
<pyc>
If I place the cursor on (+ 1 1) and type C-c C-c, it compiles it but does not show the result. What do I do to see the result?
<Bike>
C-x C-e
<Bike>
which is slime-eval-last-expression.
<Bike>
holycow: you can just use cl:position for that, if i understand your problem correctly
<Bike>
with :from-end t
contrapunctus has left #lisp ["Disconnected: closed"]
<holycow>
oh, let me look that up. thank you.
<Bike>
(position #\/ "foo/bar/baz/x.txt" :from-end t) => 11, and then (subseq "foo/bar/baz/x.txt" (1+ 11)) => "x.txt"
contrapunctus has joined #lisp
<pyc>
Bike: C-x C-e is very different from C-c C-c. With C-c C-c I can place the cursor anywhere within an expression and it always compiles the top-level form. But C-x C-e only evaluates the last expression before the cursor.
<holycow>
aha! thank you kindly. reading up on position
karlosz has quit [Ping timeout: 240 seconds]
<Bike>
pyc: C-M-x
<Bike>
maybe?
<Bike>
which is slime-eval-defun.
mdevos has joined #lisp
<Bike>
there's a whole bunch of slime-eval-whatever functions
skapata has quit [Remote host closed the connection]
<mdevos>
Is there a formal set of guidelines for what to talk about here, or should I just rely on what I think is reasonable?
<pyc>
Bike: thanks C-M-x does it
<Bike>
well, to be on topic, talk about common lisp. beyond that, dunno
<mdevos>
Bike: ok
<mdevos>
does someone know a Scheme <-> Common Lisp compatibility layer? I want to use a Common Lisp library in Guile Scheme
<mdevos>
Currently, I'm using define-syntax & syntax-rules to define defvar, defun etc.
<Bike>
i think they are different enough languages that a "compatibility layer" would have to be very extensive.
<mdevos>
(My implementation isn't really conforming I think but whatever)
kam1 has joined #lisp
<mdevos>
I don't mind fudging many details (e.g. I don't put defun and defvar definitions in separate namespaces even though they should be in common lisp IIUC)
<mdevos>
also, I can modify the library I want to use
<Bike>
you may have to port it entirely.
<mdevos>
Bike: probably (-:. Though I can save myself some typing by defining the "defvar" and "defun" syntaxes in terms of Scheme's define, and maybe likewise for other things
<Bike>
some things are going to be more involved. i don't think scheme has anything like CLOS, for example
<Bike>
This isn't something that you can solve with a few search-replaces, in general
<mdevos>
Bike: actually, Guile Scheme does (in the (oop goops) module)
<mdevos>
but yes, there'll be many differences
<mdevos>
I'll just try and see how it goes ...
<Nilby>
How hard it will be porting, really depends on things like does it use FFI, does it use weird format features, how much CLOS, reader features etc, gray streams, etc. Guile has a lot of stuff, but there's a lot of corners in CL.
<Feldman>
I think there is a R5RS define-syntax for CL, no clue if it actually works tho
<phoe>
2) you might have more luck asking on #racket because this is a lair of Common Lisp programmers
shka_ has quit [Ping timeout: 272 seconds]
sm2n_ has joined #lisp
Wezl has joined #lisp
sm2n has quit [Ping timeout: 264 seconds]
<Wezl>
say I have a value and a list, and I want to reverse the list and have the value as the (cdr (last)), is there a better way than (apply #'list* (reverse (cons value lst)))?