dilated_dinosaur has quit [Ping timeout: 256 seconds]
dra has quit [Remote host closed the connection]
nicktick has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
loli has quit [Quit: WeeChat 2.9]
loli has joined #lisp
smazga has joined #lisp
msk has quit [Ping timeout: 260 seconds]
ex_nihilo has joined #lisp
smazga has quit [Ping timeout: 240 seconds]
astronavt has joined #lisp
loli has quit [Quit: WeeChat 2.9]
loli has joined #lisp
loli has joined #lisp
smazga has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 260 seconds]
cantstanya has quit [Ping timeout: 240 seconds]
smazga has quit [Ping timeout: 256 seconds]
cantstanya has joined #lisp
Steeve has quit [Quit: end]
ech has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
pillton has quit [Ping timeout: 272 seconds]
jurov_ has quit [Read error: Connection reset by peer]
choegusung has joined #lisp
ech has joined #lisp
mrchampion has quit [Ping timeout: 256 seconds]
rumbler31 has quit [Remote host closed the connection]
Lycurgus has quit [Quit: Exeunt]
rumbler31 has joined #lisp
jurov has joined #lisp
mrchampion has joined #lisp
jurov_ has joined #lisp
jurov has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
kir0ul_ has joined #lisp
kiroul has quit [Ping timeout: 260 seconds]
choegusung has quit [Quit: leaving]
ech has quit [Ping timeout: 240 seconds]
semz has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
ech has joined #lisp
smazga has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
skapata has quit [Ping timeout: 246 seconds]
ech has quit [Ping timeout: 240 seconds]
smazga has quit [Ping timeout: 272 seconds]
skapata has joined #lisp
ech has joined #lisp
semz has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
shifty has joined #lisp
Gerula has quit [Ping timeout: 240 seconds]
Gerula has joined #lisp
pfdietz has quit [Ping timeout: 245 seconds]
gxt has quit [Ping timeout: 240 seconds]
edgar-rft has quit [Quit: Leaving]
gxt has joined #lisp
smazga has joined #lisp
skapate has joined #lisp
iissaacc has quit [Ping timeout: 256 seconds]
skapata has quit [Ping timeout: 272 seconds]
jesse1010 has quit [Ping timeout: 260 seconds]
skapate is now known as skapata
smazga has quit [Ping timeout: 272 seconds]
smazga has joined #lisp
dbotton has quit [Quit: -a- IRC for Android 2.1.59]
dbotton has joined #lisp
Alfr_ has joined #lisp
Alfr has quit [Ping timeout: 260 seconds]
Nilby has quit [Read error: Connection reset by peer]
<beach>
Good morning everyone!
<moon-child>
morning beach
smazga has quit [Ping timeout: 258 seconds]
Oladon has joined #lisp
cl-arthur has quit [Remote host closed the connection]
devon has joined #lisp
miasuji has joined #lisp
saganman has joined #lisp
astronavt has quit [Quit: Leaving]
iissaacc has joined #lisp
astronavt has joined #lisp
justHaunted has quit [Read error: Connection reset by peer]
justHaunted has joined #lisp
pillton has joined #lisp
<dbotton>
good evening:)
<beach>
Hello dbotton.
<beach>
I should not have been so cranky yesterday. I think Xach and phoe have good points. There are obstacles to Common Lisp use that are straightforward to remove, and that would be a desirable thing to do.
smazga has joined #lisp
<beach>
It may require time and energy that nobody here has, but it is still important to make the distinction between those obstacles, and others that can't be removed that easily.
<beach>
So, given the available time and the energy, it is clearly not pointless to remove the simple obstacles. Whether doing that will significantly increase the use of Common Lisp is mostly an orthogonal issue.
aaaaaa has quit [Quit: leaving]
<dbotton>
yes but if resources short you have to pick a focus
<beach>
Sure. And most people here are not paid for doing Common Lisp development.
<beach>
So they get to choose what they are interested in.
<dbotton>
identifying who are candidates to be attracted to invest their own time or finding ways to encourage businesses
<dbotton>
would be first step
<dbotton>
then to caterer to them
<beach>
Oh, and I should say that I personally don't see it as high priority to attract more people at all cost.
<dbotton>
quality always
<dbotton>
over quantity
<beach>
Yes, I would much rather see a few devoted people willing to learn sophisticated stuff.
<dbotton>
so figuring out where they are and targeting then is key
dbotton_ has joined #lisp
shka_ has joined #lisp
<beach>
I think we are already on the right track.
<dbotton_>
I became interested after reading Martin Craceur's blog
<beach>
Several people here are working on improving the development tools. jackdaniel, scymtym, and many more are working on McCLIM. I think McCLIM is the key to many other good tools.
<beach>
And scymtym is working on Clouseau, Eclector, and many more things.
<dbotton_>
I wrote the defacto standard for windows dev for Ada and thought that was key, then created Gnoga a gui using a browser as a rendering engine
<dbotton_>
it generated interest but that didn't keep the interest for most
<dbotton_>
if they had to use Ada they did or were enthusiast
<beach>
jackdaniel is working on Clostrum. heisig is working on Trucler. Bike and karlosz are doing great work on Cleavir.
autumn[m] has joined #lisp
<dbotton_>
but I will see my advocacy had much to do with my investment
<dbotton_>
meaning if people are excited about what they have done they reach out to others
<dbotton_>
So for sure something like McClim is important
<dbotton_>
but as you have to perhaps find the project that reaches the individuals you think would be ideal
<dbotton_>
meaning highlight projects that are interesting
<dbotton_>
many of them even
ldbeth has joined #lisp
<ldbeth>
good afternnon
<dbotton_>
and especially the ones that have the technical angles you want to show off with
<dbotton_>
From what I see Lisp has all the raw material for success
torbo has quit [Remote host closed the connection]
<beach>
Hello ldbeth.
<autumn[m]>
hi
<beach>
dbotton_: I have a slightly different take on things, I think. Rather than attempting to attract more people at all cost, I am hoping to decrease the collective maintenance burden of existing experienced people, so as to improve the collective productivity.
Alfr_ has quit [Quit: Leaving]
ldbeth` has joined #lisp
<beach>
Like if McCLIM becomes truly excellent (and I am convinced it will), then more people will spend time using Common Lisp for their GUI programs, rather than wasting time on combinations of Common Lisp and languages with totally different semantics.
<dbotton_>
I am not saying to attract more at all costs, I am saying centralize and show off
<beach>
When these people start using pure Common Lisp solutions, they will contribute to more Common Lisp libraries and such.
<beach>
Yes, I see.
ldbeth has quit [Ping timeout: 260 seconds]
<dbotton_>
find a way to pool resources
<dbotton_>
Much is already there
<ldbeth`>
I it hard to convincing people get used to event based GUI toolkit such as Qt to use stream based CLIM
<beach>
And if Cleavir becomes truly excellent, then more Common Lisp implementations might decide to use it, thereby making it possible to pool resources for compiler improvements.
<dbotton_>
other languages have the advantage (and disadvantage) of a single sources
<beach>
ldbeth`: That's why I have imagined writing (and I think jackdaniel is doing it) a McCLIM manual that describes CLIM bottom-up, so that people who want event-driven GUIs can quit reading after chapter 2.
<beach>
ldbeth`: The "mistake" with existing CLIM documentation is that it shows the stream-based style first.
<dbotton_>
python is python, rust is rust, ruby is ruby
<beach>
dbotton_: Yes, but we have the advantage of CLOS. So we can make things implementation independent, yet easy to customize, I think much easier than what is possible in other languages.
<aeth>
dbotton_: But the largest of the popular languages tend to have multiple popular implementations. C, C++, JavaScript... Really, Java is the outlier there.
<dbotton_>
so that is what needs to be shown off
<aeth>
(Actually, Java has two major implementations. The JVM Java for desktops/servers and the Android version of Java.)
<dbotton_>
c and c++ acutally considering size of community don't have that many implementations
<aeth>
3.
<aeth>
CL really only has two big implementations (SBCL and CCL). The rest fit various niches.
<dbotton_>
For the size of community that is amazing
<ldbeth`>
it is very good to be able to use CL in CL compiler development, imagining an APL compiler company doesn't not require the employees to be proficient in APL but must can write efficient C code
<dbotton_>
So centralize and show - technical articles, marketing materials (why use Lisp for your business, showing the speed of dev, etc), interesting projects, etc
ldbeth has joined #lisp
<aeth>
(And C, like CL, has various niche compilers. C++ is apparently too hard to make compilers for, so it's not quite as common.)
<dbotton_>
comparative articles between languages
<beach>
dbotton_: Exactly! And I think we are on to something. It appears that with Common Lisp, we are able to accomplish great stuff with only a handful of people, whereas it seems that other languages need entire groups of people and commercial support to do even things like adding a feature to the language (which they must do because they have complicated syntax and no macros) every 3 years or so.
smazga has quit [Ping timeout: 240 seconds]
<pillton>
My favourite is docker vs save-lisp-and-die.
<dbotton_>
I would love to see an article on that
<dbotton_>
a video
<dbotton_>
etc
<dbotton_>
that is what I mean
<beach>
pillton: I don't know docker, so can you explain a bit more?
ldbeth` has quit [Ping timeout: 265 seconds]
<dbotton_>
I started reading phoe's book and really love the angle and the fact that all the major advanced features are actually just normal extensions of the base language
Volt_ has joined #lisp
<dbotton_>
who would believe that the condition system could be implemented as a library and not need compiler support
<dbotton_>
the fact that the standard has not needed to be updated
<beach>
It shows that the base language is pretty sound.
<dbotton_>
etc
<beach>
As opposed to something like C++ that needs to be modified every 3 years.
<pillton>
beach: Docker is a portable image format which allows you to bundle your application in a container to make it easier to deploy. The container is supposed to have everything needed to run your application.
aeth_ has joined #lisp
<beach>
dbotton_: The condition system, yes. But also CLOS is mainly a library, except for some very minor additions to CLtL1 required, like funcallable standard objects.
<dbotton_>
That is my point
<beach>
pillton: And how does that compare to save-lisp-and-die?
<dbotton_>
can five away a container ready to go
<ldbeth>
well, it is because many applications has dependencies messed up
Alloc has quit [Ping timeout: 240 seconds]
<pillton>
beach: In order to create an image you need to write a Docker file which provides instructions on how to create the image. In CL, you just load the system with ASDF and save the image using save-lisp-and-die.
aeth has quit [Ping timeout: 256 seconds]
<beach>
pillton: Yes, I see.
<ldbeth>
However it is still not very gracefully if you need external C libs for your CL programs
<dbotton_>
that article is well known I am sure, but is the marketing approach that works, even 17 years later has a good angle
<dbotton_>
push the technical angle to peak interest in the right developers and peak business interest that the language has real advantages
Bike has quit [Quit: leaving]
<dbotton_>
showing that there are new and exciting implementations important too
<beach>
dbotton_: If I remember correctly, ViaWeb was sold to Yahoo, who turned it into Yahoo Store by rewriting everything in some other language. I forget which.
<dbotton_>
Clasp for llvm is important for example show investments in Lisp are worth it
<dbotton_>
it is a big factor for me
<dbotton_>
I want what I write to be useful many years from now
<beach>
Why do you think Clasp is important? I am not questioning its importance, but I would like to know your reason for saying that.
<dbotton_>
llvm
<dbotton_>
for many they believe it is the new world post gnu
<beach>
My take on Clasp is that drmeister thought it would be better to make C++ usable from Common Lisp than to rewrite CANDO and all the other chemistry libraries in Common Lisp.
<dbotton_>
investment for future use in future tech etc
<beach>
dbotton_: Why the desire for a post-GNU world?
<dbotton_>
Personally no diff
<dbotton_>
But for some less restrictive license
<dbotton_>
and corporate investments in it
smazga has joined #lisp
<no-defun-allowed>
I was hoping "post-GNU world" would entail going in the other direction.
<dbotton_>
ability to write for ios and android
<beach>
And why is that desirable, unless you are one of the people or companies who want to take free stuff and then commercialize it for your own profit?
<dbotton_>
I am a long time gnu guy
<dbotton_>
answering a question as to why
ldbeth has quit [Ping timeout: 260 seconds]
<dbotton_>
from the perspective of a language activist you want them to steel it
<drmeister>
They rewrote ViaWeb in C++ and Perl
<beach>
Amazing.
<dbotton_>
most rewrites are because employees think they have better chance for next job with those skills
<dbotton_>
and they are right
<beach>
Let me repeat this again: It is amazing how much time and energy people are willing to spend in order to avoid learning and using Common Lisp.
smazga has quit [Ping timeout: 260 seconds]
<dbotton_>
that is why universities drop languages that help actually develop a programmer in to something more
<dbotton_>
Ada, smalltalk, Lisp
<dbotton_>
I think that tools that force you to think different more important
smazga has joined #lisp
<dbotton_>
afterwards if forced to use C or Python etc you have a different mind set
Alfr has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
<dbotton_>
how far is clasp from a 1.0?
<drmeister>
Way past it.
<drmeister>
We are largely developing it for a specific application and we keep improving it.
<dbotton_>
git hub says - NOTE: November 28, 2018 - This contains a pre-release of Clasp 0.9.
<drmeister>
But it passes all but a few of the ANSI tests. Currently we are improving the compiler to improve performance.
<drmeister>
Yes - I haven't had time to update that. I've been focused on other things for the past 8 months.
<drmeister>
We are working on a new technology to deal with pandemics.
<dbotton_>
Are there binary installers for windows
<dbotton_>
cool
shoshin8 has joined #lisp
DGASAU has quit [Remote host closed the connection]
DGASAU has joined #lisp
<no-defun-allowed>
What makes using LLVM your code "useful many years from now", may I ask? SBCL is also public domain or BSD licensed if it's still a license thing.
<drmeister>
We don't support Windows.
shoshin has quit [Read error: Connection reset by peer]
shoshin8 is now known as shoshin
<beach>
I am also curious about the answer to the question by no-defun-allowed.
<drmeister>
no-defun-allowed: If that is a question for me I don't know if using LLVM does - although it does allow us to interoperate with C++ code.
<dbotton_>
I was not saying for myself, the marketing image
<no-defun-allowed>
Not to say you shouldn't use Clasp, but an older implementation would probably cause less headaches to set up.
<beach>
To me LLVM is a necessary evil to make C++ work with Clasp.
<drmeister>
beach: Yeah - pretty much.
<drmeister>
no-defun-allowed: An older implementation?
<dbotton_>
and for me a possibility for using it on platforms not supported by other compilers
<no-defun-allowed>
drmeister: Yes, I was wondering what the relationship dbotton_ appeared to have between LLVM and stability.
aeth_ is now known as aeth
<drmeister>
dbotton_: We are about to generalize things so that we can run on any backend that llvm has. Currently we are tied to x86_64
<no-defun-allowed>
drmeister: I suppose "more commonly used implementation" would be more accurate, but I don't want to make it sound like usage and ease of use are related.
<drmeister>
LLVM has a lot of investment in it - it's a slow - but pretty good compiler backend library.
<drmeister>
It would have been hell to achieve C++ interoperability with other Common Lisp implementations because of peculiarities of C++ - and C++ is a moving target.
<beach>
drmeister: I am betting that it is a very complex one too, partly due to the fact that it is written in a language without sophisticated development facilities like GC and CLOS.
<no-defun-allowed>
Some people have said that Clozure is nicer to work in, though it's less commonly used than SBCL, for example. And telling someone to use what's most frequently used is a good way to cause stagnation.
<drmeister>
Why maintain C++ interoperability - there are a lot of C++ libraries I want to use.
<drmeister>
beach: Yes - but there are a lot of people working on LLVM - and they do the massive amount of work it takes to move it forward.
<drmeister>
It's still slow, slow, slow. SBCL is a much faster compiler and it generates really good code.
<beach>
Sure, but it seems to be moving forward in all the ways that I see with C++ itself and other languages, making it a moving target as well.
<drmeister>
Oh yes - I'm constantly playing catchup.
<beach>
So I am wondering whether it takes that massive amount of work because it is complicated, and meant to be used to compile a complicated moving target language.
<beach>
... as opposed to some intrinsic complexity I mean.
<drmeister>
I don't know - it's a large software library written in C++ - I'd be surprised if it was fast and efficient and easy to maintain.
<dbotton_>
no-defun-allowed I am using sbcl and so far very pleased
ldbeth has joined #lisp
<drmeister>
I try not to complain about the stuff I use - I'm just glad it's there and I didn't have to write it.
<dbotton_>
my big point is it all make Lisp very attractive
<drmeister>
Except build systems - I like complaining about them. :-)
smazga has joined #lisp
<drmeister>
dbotton_: I really just care about one thing - I want to write software that works five, ten, twenty years later. That way I can build stuff over a long time that keeps working. There are only a few languages that support that. Fortran, C, C++, Common Lisp.
<dbotton_>
Exactly
<drmeister>
Otherwise we are scratching programs into the sand with the tide coming in.
<dbotton_>
We were talking about Lisp and have the elements for success and that I believe is the most important point
Alloc has quit [Ping timeout: 272 seconds]
ldbeth has quit [Ping timeout: 260 seconds]
<drmeister>
I've lost way too much code because I wrote it in poor choices like Python, TCL, and Smalltalk etc.
<dbotton_>
that my investment in a language will be there years from now, ie I can compile and run what I wrote 20 years ago
<dbotton_>
I hear you
Alloc has joined #lisp
<drmeister>
Right - and I think C++ is a reasonable domain specific language for working with tightly packed structures - but I don't want to write anything too complicated or exploratory in it.
smazga has quit [Ping timeout: 240 seconds]
<drmeister>
As your program grows the build time grows and you get trapped in the complexity.
<drmeister>
I didn't think Clasp would be as much work as it turned out to be. Writing an efficient language implementation is HARD.
<drmeister>
But I learned a lot - and now I have my own software development toolchain.
<drmeister>
I like that a lot.
Alloc has quit [Read error: Connection reset by peer]
<dbotton_>
I can appreciate that
Alloc has joined #lisp
Alfr has quit [Quit: Leaving]
Alloc has quit [Ping timeout: 240 seconds]
gravicappa has joined #lisp
ldbeth has joined #lisp
narimiran has joined #lisp
<ldbeth>
for building system, anything better than `make' can done its job
<dbotton_>
drmeister looking at a talk of yours neat stuff
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<drmeister>
Good night - its late here.
<no-defun-allowed>
Take care.
Alloc has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
galex-713 has quit [Ping timeout: 246 seconds]
smazga has joined #lisp
ldbeth has quit [Quit: ERC (IRC client for Emacs 26.3)]
smazga has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
Alloc has quit [Ping timeout: 258 seconds]
dbotton_ has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
galex-713 has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
karlosz has quit [Quit: karlosz]
Alloc has joined #lisp
karlosz has joined #lisp
Alloc has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
Alloc has joined #lisp
Alloc has quit [Ping timeout: 258 seconds]
Cymew has joined #lisp
Alloc has joined #lisp
amb007 has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
Volt_ has quit [Quit: ]
kir0ul_ has quit [Ping timeout: 256 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
ccl-logbot has quit [Quit: Client terminated by server]
ccl-logbot has joined #lisp
pankajsg has joined #lisp
isaac_ has joined #lisp
iissaacc has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 260 seconds]
smazga has joined #lisp
rwcom60280385034 has joined #lisp
ccl-logbot has quit [Ping timeout: 260 seconds]
smazga has quit [Ping timeout: 258 seconds]
miasuji has quit [Ping timeout: 240 seconds]
ccl-logbot has joined #lisp
ccl-logbot has quit [Remote host closed the connection]
smazga has joined #lisp
rwcom6028038503 has quit [Ping timeout: 258 seconds]
Alfr has joined #lisp
ccl-logbot has joined #lisp
miasuji has joined #lisp
shinohai has quit [Quit: ZNC 1.8.x-git-190-d3011c6e - https://znc.in]
shinohai has joined #lisp
ccl-logbot has quit []
ccl-logbot has joined #lisp
smazga has quit [Ping timeout: 258 seconds]
miasuji has quit [Ping timeout: 260 seconds]
isaac_ has quit [Ping timeout: 240 seconds]
ccl-logbot has quit [Ping timeout: 272 seconds]
amb007 has quit [Ping timeout: 272 seconds]
smazga has joined #lisp
ccl-logbot has joined #lisp
liberliver has joined #lisp
smazga has quit [Ping timeout: 258 seconds]
pve has joined #lisp
defaultxr has left #lisp ["WeeChat 2.9"]
orivej has joined #lisp
frost-lab has joined #lisp
jonatack has quit [Ping timeout: 264 seconds]
smazga has joined #lisp
gravicappa has quit [Ping timeout: 260 seconds]
rwcom60280385034 has quit [Ping timeout: 258 seconds]
smazga has quit [Ping timeout: 258 seconds]
msk has joined #lisp
msk__ has joined #lisp
msk__ has quit [Max SendQ exceeded]
msk__ has joined #lisp
davepdotorg has joined #lisp
msk__ has quit [Max SendQ exceeded]
msk has quit [Ping timeout: 240 seconds]
RedMallet has joined #lisp
ukari has joined #lisp
srhm has joined #lisp
smazga has joined #lisp
pankajsg has quit [Ping timeout: 260 seconds]
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
smazga has quit [Ping timeout: 265 seconds]
davepdot_ has joined #lisp
davepdotorg has quit [Ping timeout: 260 seconds]
davepdot_ has quit [Ping timeout: 260 seconds]
rgherdt has joined #lisp
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
rgherdt has quit [Ping timeout: 272 seconds]
jonatack has joined #lisp
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
davepdotorg has joined #lisp
pillton has quit [Read error: Connection reset by peer]
heisig has joined #lisp
frodef has joined #lisp
scymtym has quit [Ping timeout: 256 seconds]
smazga has joined #lisp
smazga has quit [Ping timeout: 256 seconds]
nicktick has quit [Ping timeout: 260 seconds]
dilated_dinosaur has joined #lisp
msk has joined #lisp
msk has quit [Max SendQ exceeded]
scymtym has joined #lisp
msk has joined #lisp
skapata has quit [Remote host closed the connection]
msk__ has joined #lisp
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
msk has quit [Ping timeout: 240 seconds]
smazga has joined #lisp
smazga has quit [Ping timeout: 256 seconds]
RedMallet is now known as treflip
treflip has quit [Remote host closed the connection]
yitzi has quit [Quit: yitzi]
davepdotorg has quit [Remote host closed the connection]
yitzi has joined #lisp
davepdotorg has joined #lisp
jesse1010 has joined #lisp
msk__ has quit [Ping timeout: 240 seconds]
smazga has joined #lisp
davepdotorg has quit [Ping timeout: 256 seconds]
smazga has quit [Ping timeout: 240 seconds]
yitzi has quit [Quit: yitzi]
davepdotorg has joined #lisp
TMA has quit [Ping timeout: 272 seconds]
smazga has joined #lisp
smazga has quit [Ping timeout: 256 seconds]
amb007 has joined #lisp
nefercheprure has joined #lisp
cairn has quit [Quit: killed]
ThaEwat has quit [Quit: killed]
no-defun-allowed has quit [Quit: killed]
santiagopim[m] has quit [Quit: killed]
infra_red[m] has quit [Quit: killed]
Gnuxie[m] has quit [Quit: killed]
pcgme[m] has quit [Quit: killed]
_whitelogger has joined #lisp
kinope has joined #lisp
smazga has quit [Ping timeout: 272 seconds]
nefercheprure is now known as TMA
davepdotorg has quit [Remote host closed the connection]
jw4 has quit [Read error: Connection reset by peer]
saganman has quit [Ping timeout: 240 seconds]
davepdotorg has joined #lisp
jw4 has joined #lisp
EvW has joined #lisp
Gnuxie[m] has joined #lisp
ThaEwat has joined #lisp
santiagopim[m] has joined #lisp
tekipeps[m] has joined #lisp
MrtnDk[m] has joined #lisp
Dmytro[m] has joined #lisp
pcgme[m] has joined #lisp
materialfuture[m has joined #lisp
autumn[m] has joined #lisp
infra_red[m] has joined #lisp
no-defun-allowed has joined #lisp
kelamir[m] has joined #lisp
hansbauer[m] has joined #lisp
katco has joined #lisp
cairn has joined #lisp
even4void[m] has joined #lisp
eriix[m] has joined #lisp
xzax_[m] has joined #lisp
goldrin1227[m] has joined #lisp
santiagopim[m]1 has joined #lisp
xzax_[m]1 has joined #lisp
smazga has joined #lisp
davepdotorg has quit [Ping timeout: 256 seconds]
Lycurgus has joined #lisp
Nilby has joined #lisp
smazga has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 272 seconds]
shifty has joined #lisp
saganman has joined #lisp
supercoven has joined #lisp
jonatack has quit [Ping timeout: 272 seconds]
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
dvdmuckle has quit [Ping timeout: 265 seconds]
davepdotorg has quit [Ping timeout: 265 seconds]
msk__ has joined #lisp
tankrim has joined #lisp
Alloc has quit [Ping timeout: 258 seconds]
Alloc has joined #lisp
Bike has joined #lisp
rgherdt has joined #lisp
Lycurgus has quit [Quit: Exeunt]
ex_nihilo has quit [Quit: Leaving]
orivej has quit [Ping timeout: 260 seconds]
bitmapper has quit [Quit: Connection closed for inactivity]
davepdotorg has joined #lisp
galex-713_ has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
smazga has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
smazga has quit [Ping timeout: 272 seconds]
gravicappa has joined #lisp
ggole has joined #lisp
_heisig has joined #lisp
heisig has quit [Ping timeout: 258 seconds]
jprajzne_ has joined #lisp
jprajzne has quit [Read error: Connection reset by peer]
jprajzne_ is now known as jprajzne
msk__ has quit [Quit: Leaving]
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
Alloc has quit [Ping timeout: 265 seconds]
Alloc has joined #lisp
jprajzne has quit [Remote host closed the connection]
wsinatra has joined #lisp
rumbler31__ has quit [Ping timeout: 240 seconds]
jprajzne has joined #lisp
random-nick has joined #lisp
_heisig has quit [Read error: Connection reset by peer]
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
jprajzne has quit [Quit: jprajzne]
jprajzne has joined #lisp
jprajzne has quit [Client Quit]
jprajzne has joined #lisp
nicktick has joined #lisp
hendursaga has quit [Quit: hendursaga]
hendursaga has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
jprajzne has quit [Quit: jprajzne]
smazga has joined #lisp
jonatack has joined #lisp
jprajzne has joined #lisp
jonatack has quit [Client Quit]
jonatack has joined #lisp
smazga has quit [Ping timeout: 264 seconds]
dbotton_ has joined #lisp
dbotton has quit [Ping timeout: 260 seconds]
dbotton has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
DGASAU has joined #lisp
dbotton_ has quit [Ping timeout: 244 seconds]
kir0ul_ has joined #lisp
smazga has joined #lisp
galex-713_ has quit [Ping timeout: 256 seconds]
narimiran has quit [Ping timeout: 265 seconds]
dvdmuckle has joined #lisp
galex-713 has joined #lisp
narimiran has joined #lisp
dbotton has quit [Ping timeout: 272 seconds]
smazga has quit [Ping timeout: 272 seconds]
jprajzne has quit [Quit: jprajzne]
shoshin has quit [Quit: Ping timeout (120 seconds)]
drewc has quit [Ping timeout: 260 seconds]
bytesighs has quit [Ping timeout: 260 seconds]
shoshin has joined #lisp
frodef` has joined #lisp
xi has quit [Quit: No Ping reply in 180 seconds.]
bytesighs has joined #lisp
frost-lab has quit [Quit: Connection closed]
xi has joined #lisp
dvdmuckle has quit [Ping timeout: 258 seconds]
drewc has joined #lisp
frodef has quit [Ping timeout: 260 seconds]
terpri has quit [Quit: Leaving]
Inline has joined #lisp
ukari has quit [Ping timeout: 265 seconds]
dbotton has joined #lisp
dbotton_ has joined #lisp
Inline has quit [Ping timeout: 272 seconds]
sammich is now known as amk
amk has quit [Remote host closed the connection]
amk has joined #lisp
amk has quit [Changing host]
amk has joined #lisp
dvdmuckle has joined #lisp
<jmercouris>
how to loop collecting a longer and longer string?
<jmercouris>
(loop for i in (list 0 1 2 3) collect "x") -> ("x" "x" "x" "x")
<jmercouris>
as expected
<jmercouris>
however, what if I wish to have "xxxx"
<pve>
for i across "xxxx"
<jmercouris>
I am not looking to iterate character by character
<pve>
oh sorry
<dlowe>
(with-output-to-string (s) (loop repeat 4 do (write-char #\x s)))
<pve>
jmercouris: then look at vector-push-extend
shifty has quit [Ping timeout: 272 seconds]
<jmercouris>
OK, so there is no loop construct that does this then?
<Bike>
there is not.
<jmercouris>
alright, thank you everyone
<Bike>
i would do: collect #\x into l finally (return (coerce l 'string))
<dlowe>
iterate might, and you could probably add one if it doesn't
<Bike>
if you're adding strings rather than characters, i would use concatenate or indeed with-output-to-string
<jmercouris>
the thing is I am not actually dealing with characters, but strings
<Nilby>
from my tests reduce by conatenate is fastest on sbcl and with-output-to-string is fastest on ecl
<phoe>
jmercouris: (loop for i in ... collect (make-string i :initial-element #\x))
<dlowe>
not being able to collect into a vector is a pretty big wart on loop
smazga has joined #lisp
<_death>
fun fact: format can take a string with a fill pointer
<phoe>
if you collect into a vector then you'll need to copy it anyway in order to have ("x" "xx" "xxx" "xxxx" ...)
<jmercouris>
I just ended up concat'ing all of the strings outside the loop body
<jmercouris>
(apply #'str:concat (loop ..))
<dlowe>
You might want to use reduce instead of apply so as to not hit argument number limits
<_death>
that's a terrible way to concatenate strings
choegusung has joined #lisp
rippa has joined #lisp
<jackdaniel>
(loop until (string-equal (random-string) (expected-result)) finally (return (random-string))) ; that will work under assumption, that random-string will generate the same string twice in a row
smazga has quit [Ping timeout: 256 seconds]
dbotton_ has quit [Ping timeout: 260 seconds]
<dlowe>
_death: you could be referring to any of the solutions offered here :p
<_death>
dlowe: I mean the O(n^2) solutions
<dlowe>
an efficient implementation would sum the lengths of strings, create a new string of the proper size, and REPLACE them all into the destination
<dlowe>
surely one of the utility libraries have this
<dlowe>
O(n^2) can be fine as long as n is small, tho
<dlowe>
depends on how often you use it
<_death>
if you know the length beforehand, allocating a string and replacing (or FORMAT :) is indeed good.. but w-o-t-s is also good enough, and apply concatenate should also be ok.. not reduce though
<Bike>
dlowe: that's just concatenate. like look at sbcl's implementation for example.
edgar-rft has joined #lisp
<Xach>
with-output-to-string has a chance of working well
<_death>
Xach: yeah, amortized cost
<dlowe>
Bike: yeah, but concatenate uses the argument list
Inline has joined #lisp
rumbler31__ has joined #lisp
smazga has joined #lisp
sjl_ has joined #lisp
<Bike>
is that an actual problem people hit? call-arguments-limit is usually pretty big
<Bike>
even if it is, you could probably break it up into multiple concate calls and then concat the results
dbotton_ has joined #lisp
<dlowe>
(defun concat-string-list (l) (let ((o 0)) (reduce (lambda (r s) (replace r s :start1 o) (incf\
<dlowe>
o (length s)) r) l :initial-value (make-string (reduce '+ l :key 'length)))))
<dlowe>
bah. terminal.
<dlowe>
the iterative version is about the same length and probably faster
ukari has joined #lisp
smazga has quit [Ping timeout: 240 seconds]
<dlowe>
(defun concat-string-list (l) (loop with r = (make-string (reduce '+ l :key 'length)) for o = 0 then (+ o (length s)) for s in l do (replace r s :start1 o) finally (return r)))
<jackdaniel>
(format nil "~{~a~}" l) ; is certainly shorter
noobineer has joined #lisp
<dlowe>
we can shorten the invocation by changing the function name :p
<dlowe>
(csl l) ; hah
<jackdaniel>
true that :)
smazga has joined #lisp
<_death>
{L
jprajzne has joined #lisp
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 260 seconds]
frodef` has quit [Ping timeout: 260 seconds]
<_death>
Bike: call-arguments-limit may be big, but in practice things don't go so well.. I just tried (progn (apply #'concatenate 'string (loop repeat 100000 collect "x")) nil) on sbcl
smazga has quit [Ping timeout: 265 seconds]
jprajzne has quit [Remote host closed the connection]
jprajzne has joined #lisp
<jackdaniel>
I think that if you try to concatenate 100k strings, you may have other problems than the call arguments limit :)
<jackdaniel>
hm, too many ":)", that was obviously a joke, but not a sarcastic one, mind that!
<_death>
other problems.. I just compiled sbcl from head and trying to figure out what some strange new warnings mean
<phoe>
instead that's some system compiled with SBCL
<_death>
yes, and these also include all the third party libraries
<phoe>
AFAIK the new SBCL warns about variables which are written to but not read
<_death>
I saw that commit before I merged to my master ;)
<phoe>
but I don't know about others
<_death>
but the warning that confounds me at the moment is a type derivation one
<phoe>
are you able to post that warning alone without infriging on any copyright?
choegusung has quit [Quit: leaving]
<_death>
sure.. it's my personal snippets code base after all.. but I think I'll take more time to understand it
jprajzne has quit [Remote host closed the connection]
Oladon has joined #lisp
smazga has joined #lisp
dbotton_ has quit [Ping timeout: 272 seconds]
frodef has joined #lisp
random-nick has quit [Quit: quit]
random-nick has joined #lisp
rumbler31__ has quit [Ping timeout: 260 seconds]
dbotton_ has joined #lisp
gaqwas has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 256 seconds]
dbotton_ has quit [Ping timeout: 260 seconds]
eddof13 has quit [Ping timeout: 264 seconds]
<_death>
anyway, the warning said that the derived type of something is (values null &optional) not number because it's the result of CAR, and although I know it to always be a cons (with a number in car) sbcl thought NIL might be passed to CAR
liberliver has quit [Quit: liberliver]
<phoe>
uh wait a second
<phoe>
the only object of type (VALUES NULL &OPTIONAL) is NIL
narimiran has quit [Quit: leaving]
<_death>
indeed, that's what got my confused
ThaEwat has quit [Ping timeout: 246 seconds]
<phoe>
can you post a code snippet? this is weird
ThaEwat has joined #lisp
<_death>
creating a minimal test case
dbotton_ has joined #lisp
<_death>
ok, by creating the minimal case it's obvious why it happens
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
dbotton_ has quit [Quit: Leaving]
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
davepdotorg has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
clintm has joined #lisp
Oladon has quit [Quit: Leaving.]
davepdotorg has quit [Read error: Connection reset by peer]
dbotton_ has joined #lisp
davepdotorg has joined #lisp
dbotton has quit [Ping timeout: 240 seconds]
rumbler31__ has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
gaqwas has joined #lisp
gaqwas has joined #lisp
davepdotorg has quit [Ping timeout: 264 seconds]
<phoe>
so after line 2 SBCL asserts that X must be of type CONS
dbotton has joined #lisp
<phoe>
or rather, LIST
<phoe>
and then at line 5 it must be of type (NOT CONS) too
<phoe>
(AND LIST (NOT CONS)) == NULL
<phoe>
so it warns that this branch multiplies 1.0 by NIL
yk42bb has joined #lisp
<_death>
yes.. but if the inner IF actually comes from an inline function, that warning may not be so useful (not to mention it may cause compilation to fail...)
dbotton_ has quit [Ping timeout: 260 seconds]
<phoe>
is it a WARNING rather than a STYLE-WARNING?
<_death>
yes
scymtym has quit [Ping timeout: 244 seconds]
<_death>
one solution is to (declare (type (or cons real) x)) in the inline function
<phoe>
it still sounds like a type bug in the code though
<phoe>
(CAR X) succeeds, hence X must be a list
<_death>
how come?
<phoe>
because it succeeds in line 2
<phoe>
and later you attempt to call * on a list argument, which is a type error
<_death>
if you never pass NIL to THING, then there is no type error
<phoe>
if you never pass NIL to thing, then (* 1.0 x) is never executed
<phoe>
and so it is unused code
<_death>
correct, but like I said, change the inner IF to (F X) and have (defsubst f (x) (if (consp x) 'it-is-a-cons (* 1.0 x)))
<phoe>
yes, you can hide this error from SBCL type inference this way
<phoe>
but making SBCL blind to it doesn't make it less of an error
<_death>
no, it doesn't hide, sbcl warns!
<phoe>
oh wait
* phoe
re-reads
<_death>
the point is that F makes sense because it expects (OR CONS REAL)
<_death>
and the code using it makes sense, because it expects CONS
<_death>
but SBCL will warn because of the dead code, because it doesn't know that the argument will always be CONS
<_death>
and because there's a layer of indirection (actually, there were several inline functions calling each other, so it was multiple layers) the warning was confusing
<phoe>
the real issue is the fact that SBCL derives the type of X in (defun f (x) (if (consp x) 'it-is-a-cons (* 1.0 x))) to be T, not (OR CONS REAL)
<phoe>
or rather, (OR CONS NUMBER)
quazimod1 has quit [Ping timeout: 240 seconds]
<_death>
I also note that sbcl doesn't warn on (> (CAR X) MAX) .. even though X may be NIL.. this is pragmatism.. but for example SBCL does warn on the result of POSITION
<phoe>
uh
<phoe>
(car nil) is well defined though
<_death>
yes, but (> NIL MAX) is not
<phoe>
oh! right
EvW has joined #lisp
<phoe>
possibly (optimize speed) would show more type hints though
<phoe>
well, nope
<phoe>
oh well
amb007 has joined #lisp
<_death>
the good news is that the new assign-but-no-read warning did find a small bug in some old code :)
<Nilby>
slime doesn't seem to save repl history permanently so I wonder if anyone has my problem
arpunk has quit [Remote host closed the connection]
arpunk has joined #lisp
smazga has joined #lisp
<_death>
there was also a blog post.. at the time I wonder why wouldn't a simple sqlite database suffice
gko` has joined #lisp
<Nilby>
That seems useful. But I don't use slime. I have 40k lines worth of REPL history. Some junk, but some magic. Everyday it grows and gets slower.
sbryant has quit [Ping timeout: 260 seconds]
avicenna_ has joined #lisp
<Nilby>
Since it searches every keystroke, I'm thinking I need to scale it.
chewbranca_ has joined #lisp
lukego_ has joined #lisp
Cthulhux` has joined #lisp
kingcons has quit [Ping timeout: 272 seconds]
greaser|q_ has joined #lisp
<Nilby>
It can already go in sqlite, but it seems like it needs tagging, and garbage collections, so I'm wondering if anyone else has such a problem.
smazga has quit [Ping timeout: 264 seconds]
<Nilby>
Seem like vseloved must have had the same problem.
arpunk has quit [Remote host closed the connection]
<Nilby>
unfortunately http doesn't seem like a performant thing for history searching keystrokes, although I guess browser search bars are a counterexample
<_death>
montezuma repl history
jprajzne has joined #lisp
<Nilby>
deaht: cool, thanks. that looks like it could scale. maybe jjwiseman had the problem too.
<Nilby>
ht^T
<_death>
Nilby: heh, I just concatenated the two strings, "montezuma" and "repl history".. not sure the former comes with support for the latter ;)
smazga has joined #lisp
rotty has quit [Ping timeout: 240 seconds]
<Nilby>
but it looks hackable :)
<_death>
indeed
xzax_[m]1 has joined #lisp
shinohai has joined #lisp
katco has joined #lisp
even4void[m] has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
aaaaaa has joined #lisp
pankajsg has joined #lisp
msk has joined #lisp
msk has quit [Remote host closed the connection]
msk has joined #lisp
didi` has joined #lisp
msk has quit [Max SendQ exceeded]
<didi`>
phoe: Congratulations on your book, "The Common Lisp Condition System".
msk has joined #lisp
<phoe>
didi`: thanks
<Inline>
already bought, gets delivered tomorrow i hope
<Inline>
heh
<Inline>
i gave the order months ago
smazga has joined #lisp
<Inline>
not sure why it was delayed that much
<phoe>
the production was finalized last week
<phoe>
back in July or so the preorder page was created
<Inline>
ah
sbryant has joined #lisp
kingcons has joined #lisp
mikecheck has joined #lisp
dale has joined #lisp
moon-child has joined #lisp
<Inline>
well, i thought of maybe corona so the shipping got delayed or so
<Inline>
heh
bitmapper has joined #lisp
arpunk has joined #lisp
<phoe>
that is also possible
<phoe>
I do not have full insight into the Apress book-finalizing process
smazga has quit [Ping timeout: 265 seconds]
smazga has joined #lisp
random-nick has quit [Quit: quit]
amb007 has quit [Ping timeout: 264 seconds]
amb007 has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
frodef has quit [Ping timeout: 256 seconds]
cantstanya has joined #lisp
smazga has quit [Ping timeout: 265 seconds]
clintm has quit [Remote host closed the connection]
random-nick has joined #lisp
madage has joined #lisp
Aurora_v_kosmose has joined #lisp
ech has joined #lisp
drot has joined #lisp
tamarindo has joined #lisp
gxt has joined #lisp
hendursaga has joined #lisp
<sjl_>
mine was delivered today
<sjl_>
(ordered through amazon)
<phoe>
gasp!
<phoe>
you mean the physical paper one?
<phoe>
please give me some photos of it, my copies are still in transit
<sjl_>
rotate a knob to move up/down the debugger stack or inspector stack
didi` has left #lisp ["O bella ciao bella ciao bella ciao, ciao, ciao."]
<sjl_>
... might be a little ridiculous
<Inline>
oh yeee
<Inline>
heh
<phoe>
hit KILL and LAUNCH after one another to execute ,restart-inferior-lisp
<Inline>
whaat the heeeeeck
<Inline>
3 knobs ?
<Inline>
wooo
<Inline>
lol
<phoe>
but I think knob discussion is already borderline #lispcafe
<sjl_>
anyway yeah, I got my paper copy of your CL book today. Already started reading Holms' book and Lisp in Small Pieces though, so it'll have to get in line, hah.
<phoe>
perfect
<Inline>
welp, i only have the 2.nd edition of Holms i think
<Inline>
and quinnecs has to wait a little more.....
<ane>
what sort of testing is run to ensure a quicklisp distribution "works" and is in releasable condition?
<phoe>
ane: it builds and compiles together on Linux amd64 SBCL
<ane>
right... each package is basically done a asdf:load-system?
<phoe>
each system
<phoe>
Quicklisp is a distribution of systems, not packages; packages mean a different thing
<Inline>
yeh
<Inline>
i just don't get what systems are
<ane>
sorry, yes system
<dlowe>
they're just names for the build program
<phoe>
a system is an ASDF thing
<dlowe>
not just asdf
<Inline>
especially the difference to module
<phoe>
well... nowadays, an ASDF thing; previously it was also for mk-defsystem and other build systems that are no longer around
<Inline>
i see mk-defsystem still referenced
<Inline>
maybe for portability
<ane>
I'm asking because folks over at GNU are building yet another package repository for emacs lisp and I was thinking of suggesting to have it do monthly/<x>ly distributions
<ane>
and well, if someone were to ask "what does quicklisp do"
<Inline>
so a module is in a package, and packages are in a system ?
<phoe>
try to build everything together and ensure no errors/warnings happen
<ane>
and then I hit a blank :-)
<phoe>
or, if warnings happen, they're style-warnings or their emacs equivalents
<ane>
yeah
<Inline>
module, a group of files
<Inline>
system, a group of packages ?
<Inline>
does that translate well ?
<phoe>
not really
cosimone has joined #lisp
<Inline>
hmmm
<phoe>
a system is a group of files
<ane>
a package is a namespace for symbols
<phoe>
a module is a deprecated CL term that is not really used because it's too generic and because ASDF systems have taken over
<Inline>
ok
<dlowe>
module is also an asdf term :p
<Inline>
yep
<dlowe>
but *only* an asdf term
<Inline>
i've seen it in defpackage forms
<phoe>
yes, ASDF also claimed the term "module"
<phoe>
and in ASDF it can mean a subfolder relative to the .asd file
amb007 has quit [Read error: Connection reset by peer]
<phoe>
sigh, the naming confusion
<dlowe>
in defpackage, the only place you see it is if someone calls a thing a module
<dlowe>
but that's a programmer decision
amb007 has joined #lisp
<Inline>
right, when you are referring even to 1 file which is in a subfolder, sometimes the pathname stuff doesn't work or gets cumbersome or so
smazga has joined #lisp
<phoe>
actually pathnames and namestrings work well enough with those, or they have at least worked well enough for me
amb007 has quit [Read error: Connection reset by peer]
<ane>
phoe: do you know where the scripts/programs for the quicklisp test runs etc.?
amb007 has joined #lisp
<Inline>
problem is when you are trying to group files together from different subfolders i suppose
<phoe>
ane: Xach will know
<Inline>
then one has to combine all that stuff in one pathname, via merge-pathnames or so, not sure if that works, i'm just making that up now
<phoe>
why would you combine multiple unrelated directories in a single pathname
<phoe>
I mean you could do things like #P"foo/bar/../baz/quux.lisp" but that would be, uh, kinda pointless
<Inline>
to give the module a reference point ?
<Inline>
like to say this is your toplevel, and these are your subdirs, only these which are given explicitly etc...
<dlowe>
yeah, just because you have the flexibility to do a thing doesn't mean it's a good idea
<dlowe>
the lisp story
<phoe>
Inline: a reference point?
<phoe>
that can be absolute though
<Inline>
right
cosimone has quit [Remote host closed the connection]
<phoe>
like #p"/home/phoe/Projects/Lisp/phoe-toolbox/"
cosimone has joined #lisp
smazga has quit [Ping timeout: 260 seconds]
<Inline>
yes, or relative, which might make things combsersome to use from the toplevel as a toplevel load thing tho
<phoe>
and then you can go (asdf:system-relative-pathname :phoe-toolbox #P"package.lisp")
EvW has joined #lisp
<phoe>
see how that second pathname is relative
<Inline>
cause then you have to override the relativeness ofc
<Inline>
kinda like a hint or a protocol spec, like in saying "not thought to be used from toplevel"
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<phoe>
but ASDF knows the system-definition-pathname of :phoe-toolbox and can therefore construct a full absolute pathname
galex-713 has quit [Ping timeout: 272 seconds]
<Inline>
yes, but suppose you wished to not use asdf for some reason
<phoe>
then you need to use pathnames
<phoe>
and provide sane *default-pathname-defaults*
smazga has joined #lisp
<Inline>
effectively doubling the work of asdf, because you do it twice now
rgherdt has quit [Remote host closed the connection]
smazga has quit [Ping timeout: 265 seconds]
galex-713 has joined #lisp
<phoe>
hey
<phoe>
it was you who said that I wished to not use asdf for some reason
frgo has joined #lisp
<Inline>
just for the sake of maybe isolating a system definition, which might got stray because you pasted the wrong thin in the wrong buffer, or the developer had a glitch in his/her last git push, and you are not social enough to mail them about their failings, or not willing to wait for next git push......
<Inline>
lol
bocaneri has quit [Read error: Connection reset by peer]
orivej has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
<Inline>
actually i'd not know if it would be polite or just asocial to not mail them in that case either .....
<Inline>
hahahah
cosimone has quit [Client Quit]
cl-arthur has joined #lisp
<phoe>
that's already a social problem
<phoe>
nothing that a build system can solve reliably
ech has quit [Ping timeout: 240 seconds]
smazga has joined #lisp
treflip has joined #lisp
ech has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
ukari has quit [Remote host closed the connection]
<loli>
how does ASDF deal with breaking package changes nicely, just have a local path and grab the dependencies you suspect which might change?
<phoe>
breaking package changes?
<phoe>
what do you mean?
<loli>
say you rely on package with a function Y, and that package updates, and either Y takes different types of arguments or maybe that function was deprecated and removed, or maybe the exports got changed and now you have a shadowing conflict
rumbler31__ has quit [Ping timeout: 260 seconds]
<dlowe>
you mean relying on a system?
<dlowe>
sorry to fuss about this, but they really do mean different things in lisp-land
<phoe>
loli: basically, it doesn't
<cl-arthur>
3
EvW has quit [Ping timeout: 260 seconds]
<loli>
yes I mean system, I am sorry
<loli>
I do a lot of haskell, and tend to just call them packages, due to that
<phoe>
a system might want to provide its own mechanisms to gracefully upgrade itself, but there's nothing built-in in ASDF
<dlowe>
I know, it would be a lot easier if everyone would just call the things the same
<dlowe>
but it's not gonna happen :D
<phoe>
in case of API change, there's no real way of updating clients of that API in any way
<loli>
that is a shame, I rather like haskell's LTS system of dealing with dependencies.
<phoe>
that scheme doesn't work well with the current state of Common Lisp tooling
<phoe>
that's why people rarely break stable APIs around here
<phoe>
that's e.g. why Alexandria is effectively immutable
<dlowe>
if you want to make a breaking api you can just make another library
<dlowe>
which is friendlier anyway
<dlowe>
how much anguish could have been saved if they had made Python 3 just be called Snek 1
<Inline>
lol
<loli>
they should have called it SBCL2
<phoe>
protip: they have
<phoe>
2.0.0 came after 1.5.9
<Inline>
python was the compiler in cmucl
<phoe>
oh
<phoe>
oh god I just got the joke
<loli>
yes hence CMUCL3 or SBCL2
<Inline>
nothing todo with python2 or python3
resu has joined #lisp
rumbler31__ has joined #lisp
<Inline>
when is a python called a boa constrictor and why ?
<Inline>
lol
<dlowe>
BOA constructors are initializers for structs.
terpri has joined #lisp
galex-713 has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 258 seconds]
galex-713 has joined #lisp
shifty has joined #lisp
dbotton_ has joined #lisp
dbotton has quit [Ping timeout: 264 seconds]
shifty has quit [Ping timeout: 258 seconds]
shifty has joined #lisp
shka_ has quit [Ping timeout: 272 seconds]
terpri has quit [Ping timeout: 260 seconds]
shifty has quit [Ping timeout: 240 seconds]
<sjl_>
phoe: *squinting, trying to figure out how to reply to a mastodon tweet*
shifty has joined #lisp
gxt has quit [Remote host closed the connection]
* sjl_
thinks he figured it out
gxt has joined #lisp
<phoe>
you did figure it out
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
shifty has quit [Ping timeout: 260 seconds]
shifty has joined #lisp
ggole has quit [Quit: Leaving]
EvW has joined #lisp
terpri has joined #lisp
mathrick has quit [Ping timeout: 258 seconds]
aartaka_d has quit [Ping timeout: 260 seconds]
rumbler31___ has joined #lisp
jesse1010 has quit [Quit: Leaving]
<johnjay>
dlowe: python3 is a good example of why you can't really fundamentally change your language or platform, esp after a long time
<Xach>
hmm, the text of the issues in the hyperspec do not appear to be in the dpans sources.
<johnjay>
they should have just waited for some more ideas and did what perl did
<johnjay>
call the new thing a new platform and a weird name
<Xach>
where are the issues from?
<johnjay>
,rakudo
<johnjay>
,raku
<johnjay>
oh wrong channel
<aeth>
johnjay: Perl 6 was the only larger failure than Python 3 as far as language transitions go. At least people mostly wound up on Python 3 eventually
<johnjay>
did they? it seems to be a 50/50 split
<johnjay>
i would have just announced ok, python2 receive 0 support or update now
<johnjay>
if you want that go with Snake or Anaconda or something
shifty has quit [Ping timeout: 246 seconds]
shifty has joined #lisp
rumbler31__ has quit [Ping timeout: 264 seconds]
<aeth>
johnjay: People procrastinated the 2->3 transition for over a decade until the deadline, early this year. Now most things are finally on Python 3, although Python probably lost a lot of language momentum
<johnjay>
yeah they should have done it early on to minimize the damage
<johnjay>
you can't just fundamentally change language features decade in that break a lot of existing code and not expect resistance to that
rumbler31___ has quit [Ping timeout: 260 seconds]
<johnjay>
also ubuntu comes with python 2 as the default i thought
<aeth>
What they should've done is let the interpreter run both flavors of the language.
<johnjay>
at least when i type python i usually expect to get python2
<aeth>
Ubuntu probably transitioned a year or so ago. Fedora did, too.
mathrick has joined #lisp
<aeth>
"python" brings up python3, but it did so no earlier than 2019 or so. "python2" still exists because not everything has migrated.
wsinatra has quit [Quit: WeeChat 2.9]
<Xach>
Friends, let is talk of Lisp.
<Xach>
Specifically, the text of the CL spec issues! Is it hidden away on the old xerox ftp site somewhere?
<phoe>
possibly, yes
<phoe>
I remember that kmp assembled those on his own since these weren't a part of the formal standard
<edgar-rft>
Xach: AFAIK the code examples and the "issues" pages of CLHS are from Kent pitman private collections.
<edgar-rft>
it' explained on the CLHS "Copyright" page
<pve>
dbotton: I'm doing Smalltalk to CL, mostly just for fun
<dbotton>
phoe while I do not plan on using it for my code, I want to allow certain user extensions to a project (a dsl) and I want to offer a more familiar look and feel to those refusing to use a lisp like dsl
arpunk has quit [Remote host closed the connection]
isaac_ has joined #lisp
<phoe>
dbotton: you could try with-c-syntax to parse existing snippets of c-like code then
<phoe>
bam, you have Lisp forms that you can evaluate
shifty has quit [Ping timeout: 260 seconds]
sm2n_ is now known as sm2n
<dbotton>
not really looking to use it as a learning tool (I have already seen how wide the differences are to be useful beyond teaching someone to read a code example or two a direct translation)
gaqwas has quit [Ping timeout: 265 seconds]
srhm has quit [Read error: Connection reset by peer]
arpunk has joined #lisp
<_death>
you can check out CGOL or, for C to CL, Vacietis
<dbotton>
was just now looking at Vacietis, thanks
ech has quit [Remote host closed the connection]
dbotton has quit [Remote host closed the connection]