Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
judson_ has joined #lisp
incidentist has joined #lisp
Alfr has quit [Quit: Leaving]
Bike has quit [Quit: Lost terminal]
aartaka_d has joined #lisp
wxie has joined #lisp
aartaka has quit [Ping timeout: 256 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
msk has joined #lisp
msk has quit [Client Quit]
msk has joined #lisp
aartaka_d has quit [Ping timeout: 260 seconds]
rumbler3_ has joined #lisp
<moon-child>
morning beach
rumbler31 has quit [Ping timeout: 260 seconds]
Alfr has joined #lisp
judson_ has joined #lisp
Kaisyu has joined #lisp
sjl has joined #lisp
technobean has joined #lisp
Alfr has quit [Quit: Leaving]
shifty has quit [Ping timeout: 260 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
Codaraxis_ has quit [Ping timeout: 260 seconds]
fitzsim has quit [Ping timeout: 272 seconds]
judson_ has joined #lisp
ggole has joined #lisp
andreyorst has joined #lisp
bilegeek_ has joined #lisp
bilegeek has quit [Ping timeout: 260 seconds]
Usersda has joined #lisp
<Usersda>
Hello. I had a question about lisp i was wondering what you a ll thought.
<beach>
Go right ahead.
<Usersda>
Why can't lisp be used the HTML and css are used to design webpages
<Usersda>
*the way*
<beach>
Do you mean "why is it theoretically impossible?", or "why is the world currently set up so that it can't?"
<Usersda>
2
<beach>
As I understand it, it can. But I am not very good with web stuff, so I'll let someone else answer that.
<Usersda>
theoretically a server could be set up to parse a lisp convention/dialect the way it interprets html, no ?
saganman has joined #lisp
<beach>
Usersda: Isn't that basically what we do in things like Hunchentoot?
oni-on-ion has quit [Remote host closed the connection]
<Usersda>
hmmm
<beach>
Again, web stuff is not my thing, so I may be misunderstanding your question.
luis8 has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
X-Scale` has quit [Ping timeout: 272 seconds]
luis has quit [Ping timeout: 240 seconds]
luis8 is now known as luis
<Usersda>
I think hunchentoot is halfway to what i mean.
[X-Scale] has joined #lisp
NorthStar has joined #lisp
Alfr has joined #lisp
[X-Scale] is now known as X-Scale
<Usersda>
I haven't seen any websites built with it.
<beach>
What does Tymoon use?
<no-defun-allowed>
It wouldn't be the Web then.
<no-defun-allowed>
I think Tymoon uses a HTML-lookalike templater, which you can put embedded Lisp forms in. At least the plaster tool did when I modified it.
<beach>
Oh, good. Someone more knowledgeable than myself can provide more information.
<no-defun-allowed>
You can generate HTML, CSS and JavaScript from Lisp macros, and I've used some libraries for those a few times before.
_whitelogger has joined #lisp
<Usersda>
can you give me an example ?
<Usersda>
what i mean is, why does firefox for example interpret html, but any number of browsers can't read a lisp file. can't lisp be written in a hyper text markup way ?
technobean has quit [Ping timeout: 240 seconds]
<Usersda>
I don't think i'm articulating what i mean very well, but it's clear in my head
<beach>
Usersda: You are basically asking why current technologies have made crappy choices. That's a very tough question.
bocaneri has joined #lisp
<Usersda>
for instance, <html> <href:www.com
<Usersda>
\>
<Usersda>
could be written using lisp conventions
<Usersda>
There's nothing intrinsic about html syntax right ?
<Usersda>
it's all habit
incidentist has quit [Quit: incidentist]
<phadthai>
(:html (:head (:title ...)) (:body ...)) ? If so some systems provide macros for such
<Usersda>
yeah, something like that
<beach>
Usersda: Yes, it's all habit. Like I often put it, people spend a lot of time and energy to avoid having to learn Common Lisp.
rumbler3_ has quit [Remote host closed the connection]
<no-defun-allowed>
That is basically what cl-who accepts.
rumbler31 has joined #lisp
<Usersda>
more complex reltionships like DOM in javascript, frames ect could all be expressed in the same language. Instead of having employers for instance asking you if you are proficient in spanish, arabic and chinese, they would be like, how experienced are you with english applied to dynamic web design.
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Usersda>
can cl-who be used to create an uber like clone or other such app.
<no-defun-allowed>
If I redid the web, I would make it a distributed object system, and ask objects to draw themselves on the screen and handle events, instead of emitting a markup language no one knows how to reimplement.
incidentist has joined #lisp
<no-defun-allowed>
But, yes, you can make an Uber clone using Lisp libraries. (Except that it won't handle the legal actions to not consider your drivers employees.)
<Usersda>
Like i was recently getting a quote from linode, and their estimate wizard was intense. I still don't know if I were to rent some server space, would i be able to implement lisp in a large production that can scale.
<fiddlerwoaroof>
If you want to generate HTML for a website, you can use something like spinneret
<fiddlerwoaroof>
hello, everyone!
<fiddlerwoaroof>
Hi
<no-defun-allowed>
Hello fiddlerwoaroof.
<fiddlerwoaroof>
Sorry, my IRC client had an issue :)
<Usersda>
no-defun-allowed: i feel like that would reduce the attack surface aswell
<Alfr>
no-defun-allowed, hm ... do these objects act themselfes or are they callable?
bocaneri has quit [Max SendQ exceeded]
<no-defun-allowed>
I'm not exactly sure yet.
bocaneri has joined #lisp
<no-defun-allowed>
Usersda: We have run projects on OVH with a small budget. There is also Heroku (with <https://github.com/jsmpereira/heroku-buildpack-cl>) which is free, if you can handle the "serverless" management stuff they do.
bocaneri has quit [Max SendQ exceeded]
bocaneri has joined #lisp
Blukunfando has quit [Ping timeout: 240 seconds]
<Usersda>
fifflerwoaroof: i'm not so much exploring ways to translate. I'm wondering what the actual advantage of html is. Like the chinese counting system is said to be easier or faster to sum totals. to
<fiddlerwoaroof>
Most $5-$10/month VPCs can handle most people's websites
<fiddlerwoaroof>
Usersda: network effects
incidentist has quit [Quit: incidentist]
bocaneri has quit [Max SendQ exceeded]
<no-defun-allowed>
A web browser is the most portable virtual machine ever made. Even Java doesn't have nothing on its usage.
<fiddlerwoaroof>
Most things are the way they are because of relatively arbitrary decisions made sometime in the past
bocaneri has joined #lisp
<fiddlerwoaroof>
Now, we're stuck with HTML/CSS/JS just because people already know them, so it's easy to find people to work for you
bocaneri has quit [Max SendQ exceeded]
technobean has joined #lisp
technobean has quit [Client Quit]
<fiddlerwoaroof>
It's an annoying cycle, and it's nearly impossible to break because unusual technologies generally get scapegoated
bocaneri has joined #lisp
<Usersda>
I think you're right, and i'm glad i asked you guys. but that's deeply unsettling.
<Usersda>
from an efficiency standpoint.
<fiddlerwoaroof>
The fact is, when it comes to things like picking programming languages, companies look for the languages that are easiest/cheapest to hire for
bocaneri has quit [Max SendQ exceeded]
treflip has joined #lisp
bocaneri has joined #lisp
bocaneri has quit [Remote host closed the connection]
<Usersda>
well python is only easy/cheap to hire for because it blew up in the 2010's for some reason.
<no-defun-allowed>
Efficiency is not well defined. "The cheapest to hire for" may be the most efficient to an accountant.
<fiddlerwoaroof>
Usersda: exactly
<fiddlerwoaroof>
Something like Java is popular because Sun and other companies spent billions of dollars marketing it
<fiddlerwoaroof>
And then universities all decided it was the future and started teaching it to everyone in CS
<Usersda>
i can define it as such : if i have to hire someone who has to be experienced in chinese, spanish and arabic to write an ping pong slideshow in english....like wtf ?
<fiddlerwoaroof>
The thing is, programming languages aren't as hard to learn as natural languages
<Usersda>
ooooh that's why. the marketing , makes sense. that;s criminal though
<fiddlerwoaroof>
I can, and have, gotten a job writing mainly a language I didn't know and learned enough to do good work over a couple weeks
<Usersda>
even before i came accross lisp i would look at python and c++ and be like...there must be a better way.
jonatack has quit [Ping timeout: 260 seconds]
<Usersda>
it's really affecting me, because i feel like lisp was hidden from me *insert zoolander crazy person meme*
<Usersda>
it's to the point where i'm discouraged. why did they push python so hard.
<fiddlerwoaroof>
I don't actually understand python
<no-defun-allowed>
"It's easy to learn", they said.
<fiddlerwoaroof>
I learned it a long time ago, and I never really noticed marketing the way Java was
<fiddlerwoaroof>
But, I think libraries like numpy and it's relatively readable syntax made a huge difference
<no-defun-allowed>
"It will be like readable pseudocode", they said.
jonatack has joined #lisp
<no-defun-allowed>
(I really dislike most pseudocodes, so that's not a very high standard. But they do say that.)
<fiddlerwoaroof>
And, it's standard library has enough to cover most of the utility scripts I write
<fiddlerwoaroof>
There are some things that are really annoying to do in CL: like, there's no high-quality library for dealing with IMAP
<fiddlerwoaroof>
(unless something has changed in the last 6 months or so)
<Usersda>
technically we could have different formalization of lisp for web service and a different one for locally executed scripts. The way you don't use the same terms and structures or tones at church as you do with friends.
andreyorst_ has joined #lisp
<Usersda>
"The original Interim Mail Access Protocol was implemented as a Xerox Lisp machine client and a TOPS-20 server. " wtf
kir0ul_ has quit [Ping timeout: 256 seconds]
<Usersda>
even reddit was originally written in lisp. then all of sudden somebody decided we needed 50 languages and 3 years of comp sci to work on a underwear renting website.
sdumi has quit [Ping timeout: 265 seconds]
aartaka has joined #lisp
Kundry_Wag has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
aorst has quit [Remote host closed the connection]
<Usersda>
"Our point of view is that most data bases are accessed by programs written in several differentlanguages, and we do not see any programming language Esperanto on the horizon." lol
aorst has joined #lisp
andreyorst_ has quit [Ping timeout: 260 seconds]
rumbler31 has quit [Remote host closed the connection]
shka_ has joined #lisp
<fiddlerwoaroof>
Is the code for the lisp version of postgres still available?
saganman has left #lisp ["Leaving"]
<Usersda>
fiddler, according to the wiki article it was lost.
<Usersda>
which in light of the constant cature of lisp projects by other languages once they start scalling , is like illuminaty territory
<Usersda>
capture **
jprajzne has quit [Quit: jprajzne]
<Usersda>
that code is in some basement next to the ark of the covenant.
<Usersda>
anyways , thank for your input friends, i get mad sometimes so sorry about the rants , i just feel like so much time has been wasted
<phadthai>
I know the feeling
rumbler31 has joined #lisp
aartaka_d has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
aartaka has quit [Ping timeout: 260 seconds]
aartaka_d has quit [Ping timeout: 264 seconds]
aartaka has joined #lisp
shifty has joined #lisp
Cymew has joined #lisp
jprajzne has joined #lisp
daphnis has joined #lisp
aeth has quit [Ping timeout: 260 seconds]
SirVolta has joined #lisp
phadthai has quit [Ping timeout: 265 seconds]
phadthai has joined #lisp
zaquest has quit [Quit: Leaving]
liberliver has joined #lisp
bilegeek_ has quit [Quit: Leaving]
zaquest has joined #lisp
aeth has joined #lisp
sdumi has quit [Read error: Connection reset by peer]
sdumi has joined #lisp
wxie has quit [Quit: wxie]
lottaquestions_ has quit [Remote host closed the connection]
lottaquestions_ has joined #lisp
Usersda has quit [Quit: Leaving]
pve has joined #lisp
Alfr has quit [Quit: Leaving]
flip214 has quit [Ping timeout: 260 seconds]
flip214 has joined #lisp
jeosol has joined #lisp
cl-arthur has joined #lisp
<jeosol>
Good morning!
<beach>
Hello jeosol.
<jeosol>
Hi Beach, I am borrowing your greeting
<beach>
Fine with me.
<jeosol>
Been away from here, but back now. Recently moved cross-country
<beach>
What country is that?
<jeosol>
US; West-Coast (LA) to central (TX)
<beach>
I see. Austin?
<jeosol>
belle ville. No Houston; but maybe I will move there soon if sth gets me there
<beach>
OK.
<jeosol>
How is your admittedly small family doing
<beach>
Fine as usual. Enjoying her retirement.
<jeosol>
I think it's you that use that phrase
<flip214>
right
<beach>
Indeed.
<jeosol>
that's great. you told me she worked with ILOG
<beach>
Yes, but ILOG was bought by IBM some time ago.
<jeosol>
I recently dabbled with it again, and someone here ( i forgot who), I think Luis, showed me some lisp interface libs
<beach>
Yes, Masai.
<beach>
Forget the lower-level one.
<jeosol>
I tested CPLEX since it's the one one I could get a license
<beach>
My (admittedly small) family was in charge of the documentation for CPLEX for a long time.
<jeosol>
Oh really. That's great.
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
<jeosol>
She will have a lot of useful experience. I was looking at network applications
<beach>
I see.
<jeosol>
btw, been trying to do remote calls to scale my applications. I recently started using docker and learned about swank-client.
<jeosol>
I am doing some benchmark now running async jobs, seeing how may connections I can make to a docker running lisp (one container).
bocaneri has joined #lisp
orivej_ has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
<jeosol>
beach: how is SICL coming along - watching the repo so get the updates.
<beach>
jeosol: Very slow but also very steady progress.
<jeosol>
that's great. Now I am back, I'll look over the backlog see what I can work/take on.
<jeosol>
I am not a compiler expert like you guys, mostly working on applications
hendursa1 has joined #lisp
<beach>
Actually, Bike and karlosz are the ones working on the compiler these days. I am doing bootstrapping.
bocaneri has quit [Max SendQ exceeded]
bocaneri has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
supercoven has joined #lisp
<beach>
jeosol: We have also forked off a few projects. Eclector is quite good these days. Trucler (lexical environments) seems to work. So does Clostrum (first-class global environments). Incless (Common Lisp printer) is being worked on.
<beach>
Cyclosis (streams) is also a separate library, but still embryonic.
Kundry_Wag has quit [Ping timeout: 256 seconds]
<beach>
And of course there are several tools that are independent from the SICL project, like Clouseau, McCLIM, CLIM flamegraph, etc.
_oldtopman has joined #lisp
lansiir has quit [Ping timeout: 260 seconds]
villanella has joined #lisp
imode has quit [Ping timeout: 264 seconds]
dreamcompiler has quit [Read error: No route to host]
dreamcompiler has joined #lisp
daphnis has quit [Ping timeout: 260 seconds]
hiroaki has quit [Ping timeout: 256 seconds]
rumbler31 has joined #lisp
Alfr has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 264 seconds]
daphnis has joined #lisp
jonatack has quit [Ping timeout: 260 seconds]
IPmonger has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
IPmonger has joined #lisp
terpri has quit [Ping timeout: 272 seconds]
HolosTrain has joined #lisp
aartaka has quit [Ping timeout: 265 seconds]
aartaka has joined #lisp
terpri has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
kmeow has joined #lisp
kmeow has quit [Remote host closed the connection]
Kaisyu has quit [Quit: Connection closed for inactivity]
heisig has joined #lisp
HolosTrain has quit [Ping timeout: 245 seconds]
treflip has quit [Ping timeout: 256 seconds]
flip214 has quit [Ping timeout: 264 seconds]
flip214 has joined #lisp
<heisig>
What is the state of Common Lisp in Visual Studio Code these days? I am asking because some of my students are very interested in working with Lisp, but don't want to switch to Vim or Emacs.
<moon-child>
heisig: maybe try https://portacle.github.io/? It's an 'emacs distro' bundled up with slime and sbcl
<heisig>
I know about Portacle. That is what I usually recommend newcomers. But I still need to explain plenty of C-c C-... tricks before they start enjoying it.
<flip214>
heisig: just force them to, they'll appreciate it in 10 years or so.
<moon-child>
heisig: fair enough. Don't know about vscode, but it's probably fine
<heisig>
flip214: Sure, that works for some people. But I still feel I am scaring away 50% of the potential Common Lisp programmers.
<moon-child>
yeah, you need a gateway drug. Don't try to sell them everything at once
<no-defun-allowed>
It seems a bit short of the capabilities of Swank in general.
<heisig>
Interestingly, the group of people that doesn't want to learn Emacs also doesn't care about the full power of Swank. They usually just want completion and indentation.
<beach>
That's very sad.
<beach>
"Nah, I want to continue being low productive"
<beach>
If I were an employer, I would ask the university for a list of those, so that I wouldn't bother interviewing them for a possible job.
<beach>
jackdaniel: Heh, nice!
<jackdaniel>
:)
<flip214>
heisig: I think that's a good initial filter... just make "learn vim or emacs" (or in the other order) 20% of the final rating of that class ;)
<flip214>
only people who're interesting in learning the right tools will know the right tools later on!
<jackdaniel>
that said, I'm sure that it would be easier to sell unknown features like slime had the person not need to learn about emacs first
<jackdaniel>
(and there are efforts towards that goal, there is i.e slimv for vim, and I think that there is a client for the "atom" editor)
<jackdaniel>
so things are not that bad, probably more a discoverability problem than a wall for newcomers
<beach>
When I was in charge of the undergraduate program, we had a first-year course called "development environments" where we taught them Unix tools, Emacs, version control, GDB, etc.
<phoe>
heisig: there's slime clients for sublime text and atom, have you evaluated those?
<jackdaniel>
beach: we had something similar and that was very useful course
<beach>
My younger successors don't understand the value of such a course, naturally.
<phoe>
slima and slyblime, namely
<beach>
jackdaniel: Exactly! And during the rest of the teaching program, we can assume knowledge of those tools.
<phoe>
these are important because they still make use of swank, and they reimplement just the frontend/slime part
<no-defun-allowed>
heisig: I agree with beach, I think they're missing out. There's still a bit more one can get out of that VS Code extension though, but it may just be a hassle to set up.
<heisig>
I don't fully buy the initial filter theory.
<phoe>
I assume that someone with enough patience could implement a swank frontend in vscode, too; it just hasn't been done because nobody did it
<heisig>
Firstly, it is not the case that you can't be productive outside of Emacs (blasphemy, I know).
<jackdaniel>
beach: that reminds me the book "concrete mathematics", very useful things. but I'm getting into offtopic :)
<beach>
no-defun-allowed: heisig may not be in charge of the entire program, though.
<heisig>
But more importantly, I see that many people learn new languages after casually tinkering with them.
<heisig>
And I don't see many people casually using Emacs.
<heisig>
phoe: Thanks for pointing me towards the sublime and atom plugins. That could be useful.
mokulus has quit [Read error: Connection reset by peer]
<no-defun-allowed>
To some extent, it would be like learning Smalltalk with just terminal IO (like with GNU Smalltalk or that didactic subset from that miniature interpreter tutorial) - but I guess you can still use SBCL's debugger and stuff with just a terminal emulator.
mokulus has joined #lisp
aartaka_d has joined #lisp
karlosz has quit [Ping timeout: 240 seconds]
<phoe>
yes, and the SBCL debugger is pretty damn handy sometimes
<no-defun-allowed>
I do hear SLIMA is much closer to the capabilities of SLIME though.
<jackdaniel>
16GB and swapping
<beach>
heisig: You seem to suggest that the problem is just one of documentation. Like, if it weren't presented as "First learn Emacs", but as a complete environment, then it would be an easier sell.
<phoe>
beach: no, it's a problem of time
<phoe>
learning emacs takes time even if you have complete documentation
aartaka has quit [Ping timeout: 260 seconds]
<ck_>
maybe incentive is also a factor, a demonstration of what value can be gained by investing the time
<phoe>
emacs has multiple idiosyncracies that do not make sense to people used to other editors, with the most famous one being C-z C-x C-c C-v not doing what the average non-Emacs user expects them to do
<jackdaniel>
one could argue, that learning emacs increases productivity, and that position could be defensible, however when someone wants to learn common lisp to increase productivity, having an emacs as a prerequisite seems like a big distraction -- that said, I have a strong recollection of such discussions on this channel :)
<ck_>
I remember fondly a little swf screen recording on the slime website, narrated by a person called yusuke I believe
<phoe>
I am currently helping one person learn Common Lisp. learning Emacs, as much it is a contemporary prerequisite for real CL work, is also a distraction because I want to spend time teaching CL, not to spend time answering "how do I undo the last thing I did in this editor, control-z does a weird thing"
<phoe>
ultimately, to total newbies, I want to teach Common Lisp, not Emacs - and Emacs makes this impossible
<jackdaniel>
that's why it is good that there are so many swank clients :)
<phoe>
yes
aartaka has joined #lisp
<phoe>
it's an amazing recent development; I might actually try it someday with slima instead of emacs
Kundry_Wag has joined #lisp
<heisig>
We were also discussing a fundraiser for better VSCode integration at SBCL20. But I think that discussion went nowhere.
<heisig>
I'd be totally willing to contribute to such a fundraiser though.
aartaka_d has quit [Ping timeout: 256 seconds]
<jackdaniel>
wouldn't that involve implementing LSP protocol?
<beach>
phoe: So that suggests that only known tools are allowed. But doesn't that contradict the fact that people seem to be willing to learn a new IDE for a new language? Or have I misunderstood that?
<jackdaniel>
there is something nice to the name
<heisig>
jackdaniel: Yes, I think it would mostly be LSP work.
<scymtym>
jackdaniel: there are already multiple LSP implementations in CL
<jackdaniel>
that sounds promising
<heisig>
scymtym: That is why I was asking about the current state of things. Is some of this already in a presentable state?
<scymtym>
sounds like "each is 70 % complete" to me
<beach>
phoe: If it just a problem with Emacs key sequences, then one could teach them the use of the menus.
<jackdaniel>
then let's use two and we'll have 140%, better than native MS tools :-)
<scymtym>
heisig: i don't know. mine isn't. it is a vehicle for playing with static analysis. one other one is a SWANK adapter, i think
Kundry_Wag has quit [Ping timeout: 256 seconds]
<jackdaniel>
beach: emacs has more unusual quirks that are annoying at times - like automatic frame managament when a debugger pops up
daphnis has quit [Ping timeout: 246 seconds]
<phoe>
beach: there is the bootstrapping problem.
daphnis has joined #lisp
<phoe>
If you try to bootstrap knowledge from an environment that is already somewhat familiar to people, then there is less to learn in order to be able to use the language.
<phoe>
If you try to bootstrap knowledge from an environment that is unfamiliar to people, then there is much more to learn in order to be able to use the language.
* jackdaniel
gets back to his emacs environment with slime, later o/
<phoe>
The latter means that people need to invest more of their time.
<phoe>
And that's not a deal that everyone wants to make, since time is the ultimate currency.
<heisig>
beach: Selling a programming language is not so much different than selling, e.g., clothes. The most important part is (unfortunately) not the quality of your products but to get people into your shop in the first place.
<heisig>
And if entering the shop involves installing Emacs, that is bad for business.
<scymtym>
"see, you have invoke M-x buy-pants with a negative prefix argument to get shorts"
<heisig>
:D
gproto23 has joined #lisp
cosimone has joined #lisp
mokulus has quit [Read error: Connection reset by peer]
cosimone has quit [Client Quit]
mokulus has joined #lisp
cosimone has joined #lisp
<beach>
I still feel that some important piece of the puzzle is missing here. I guess I'll think about it over my lunch break.
cosimone has quit [Client Quit]
<phoe>
beach: please do! I'm curious what you find out
cosimone has joined #lisp
green_ has joined #lisp
<scymtym>
i wonder how pharo is sold to people. maybe it is easier since the editor question doesn't come up if you only offer one complete environment
aartaka has quit [Ping timeout: 260 seconds]
<TMA>
I know how Pharo was "sold" to me... it was a course requirement at the university.
<green_>
oh, after all of these years it's not fixed?
<green_>
who maintains it?
<jackdaniel>
it is a ~verbatim ansi standard
<jackdaniel>
the last standard draft before publication namely
<jackdaniel>
so fixing it would imply rolling out a new standard
villanella has quit [Ping timeout: 240 seconds]
<green_>
is anyone thinking of doing that.. just with fixes like this, which is an obvious error?
<green_>
or are we stuck with the current
<jackdaniel>
since it is obvious, there is not much incentive to undertake a massive endavour of pushing for a new standard
ljavorsk has joined #lisp
<scymtym>
beach has plans for such a document which would focus on corrections and clarifications. i don't think the result is intended as a new standard, though
<phoe>
there were several initiatives to produce a new CLHS-like document, but nothing conclusive just yet - it's a massive amount of precise and thankless work to do something like that
<phoe>
(and I say as someone who attempted to do that once, and did not finish)
<phoe>
(*especially* if your want the document to be machine-reproducible from source TeX files that CLHS was generated from)
<green_>
thanks. the :start-end fix isn't in that list. I wonder if there are many more of those.
In0perable has quit [Quit: All your buffer are belong to us!]
<phoe>
green_: !
<phoe>
good find!
<mfiano>
I can also speak from experience. I spent about a month total and got less than 1% finished.
<phoe>
green_: added, thank you for the catch
<green_>
thanks!
<green_>
when was the last time you had to update that doc?
<green_>
somebody should make a browser plugin that applies these changes to the online spec :)
<phoe>
green_: I remember adding something there this year
<phoe>
there were ideas for such a browser extension, but again, that's kinda thankless work
<green_>
uh.. I'm a free software developer -- thankless work is my thing
<ck_>
green_: well, is it done yet??
<ck_>
(scnr)
<phoe>
green_: ha
<phoe>
well, if you feel like it, no one is going to stop you
<phoe>
and some people might even thank you for that
<green_>
it wouldn't be thankless then. forget it.
<phoe>
:(
gxt has quit [Remote host closed the connection]
EvW has joined #lisp
hendursa1 has quit [Ping timeout: 240 seconds]
gxt has joined #lisp
hendursa1 has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
orivej has joined #lisp
FreeBirdLjj has quit [Ping timeout: 246 seconds]
quazimodo has quit [Ping timeout: 265 seconds]
quazimodo has joined #lisp
skapata has joined #lisp
Kundry_Wag has joined #lisp
daphnis has quit [Quit: leaving]
gproto023 has joined #lisp
gproto23 has quit [Ping timeout: 256 seconds]
aartaka has joined #lisp
fiddlerwoaroof[m has left #lisp ["Kicked by @appservice-irc:matrix.org : issued !quit command"]
frgo has joined #lisp
frgo_ has quit [Ping timeout: 240 seconds]
Bike has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
gproto0023 has joined #lisp
gproto023 has quit [Ping timeout: 240 seconds]
Mrbuck has joined #lisp
technobean has joined #lisp
Lambdaver has joined #lisp
SirVolta has left #lisp ["ERC (IRC client for Emacs 26.3)"]
hlisp has joined #lisp
green_ has quit [Ping timeout: 246 seconds]
hlisp has quit [Remote host closed the connection]
galex-713 has quit [Ping timeout: 272 seconds]
random-nick has joined #lisp
gxt has quit [Quit: WeeChat 2.9]
wsinatra has joined #lisp
dbotton has joined #lisp
galex-713 has joined #lisp
green_ has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
rotty has joined #lisp
rumbler31 has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
<jmercouris>
because swine is a noun, and I'm having a lot of trouble thinking about it as a method
<jackdaniel>
no, swine was an implementation of the swank protocol for climacs, I have no interest in swimming
<jmercouris>
and what is deerp? check if an object is a deer?
<jackdaniel>
does it matter?
<jmercouris>
it sure does, because the error says "not a deer"
<jackdaniel>
the point is that you may put an around method specialized on t that checks preconditions
<jmercouris>
I see, so you think that's what I should do then?
<jackdaniel>
no, I don't know what you should do because I don't know the problem
<jackdaniel>
this is an answer to your question
<jmercouris>
do you have any other possible solutions?
<jackdaniel>
to what?
flazh has quit [Ping timeout: 260 seconds]
<jmercouris>
to my question
judson_ has joined #lisp
gproto23 has quit [Ping timeout: 260 seconds]
<jackdaniel>
that would be answers. yes, you could use a library traits, define a :before method instead, define a non-standard generic function that checks the type of an argument
<jmercouris>
interesting ideas
<jackdaniel>
there are numerous ways to error when the object is not of a desired type
<jmercouris>
thanks, I will think about them
<jmercouris>
yes, I know that
<jmercouris>
but I am really thinking about how to indicate that a specific object should conform to a protocol
<jmercouris>
how to show that it should support some set of behavior
<jackdaniel>
uhm, good luck
<jmercouris>
it's not really about the type of the object, as it is can the object quack
<jmercouris>
I guess I could check to see if there exists a method that specializes quack on that object
Nilby has joined #lisp
gareppa has joined #lisp
hiroaki has joined #lisp
Kundry_Wag has joined #lisp
<phoe>
jmercouris: see my PROTEST/PROTOCOL library
<phoe>
in particular, protest/protocol:validate-implementations
<phoe>
which I guess should still work even though I have not taken a look at it in a long while
<jeosol>
phoe: checked the repo, its fresh of the boat (5mins)
<phoe>
jeosol: yes
aartaka_d has quit [Ping timeout: 256 seconds]
<mfiano>
the diamond macro would need to be better supported
aorst has quit [Quit: aorst]
andreyorst_ has joined #lisp
<phoe>
mfiano: what do you mean?
<mfiano>
I only know of one threading macro library in CL that handles diamond symbols at an arbitrary depth, and at first glance it appears this one does not.
<phoe>
clojure's swiss-arrows doesn't support diamonds in subforms
<phoe>
arrow-macros depend on a code walker to implement this, but the author of arrows does not want to depend on such a heavy piece of machinery
<phoe>
hence, no, code-walking diamond support is out of scope
Mrbuck has quit [Quit: WeeChat 2.9]
<mfiano>
Wonder if tree-leaves is out of scope
wsinatra has quit [Read error: Connection reset by peer]
<mfiano>
That would cover most of it
<phoe>
this will replace in situations like (list '<>)
wsinatra has joined #lisp
<phoe>
which is rare, but possible
Steeve has joined #lisp
<phoe>
this is unsolvable in the general case without code walking
<mfiano>
TREE-LEAVES is a naive code walker in a couple lines of code
<mfiano>
See TREE-LEAVES from Let Over Lambda
<phoe>
no idea; feel free to suggest this in the PR
<mfiano>
When I used threading macros, I switched to arrow-macros because limiting diamonds to the top level is pretty restrictive in the code I was writing
<Bike>
looks like it would happily replace the <> in '<>, since it doesn't know anything about lisp?
<mfiano>
Right
hnOsmium0001 has joined #lisp
<Bike>
this isn't really a code walker, it's just a dumb subst thing
<mfiano>
I agree completely, though he introduces it as a naive code walker IIRC.
lotuseater has joined #lisp
jprajzne has joined #lisp
<phoe>
yes
<phoe>
it is naïve
cosimone has quit [Read error: Connection reset by peer]
pankajsg has joined #lisp
<Josh_2>
What keyword shares a slots value between all instances of a class?
<phoe>
keyword?
<phoe>
you mean :allocation :class?
<Josh_2>
maybe
<lotuseater>
i think that is it
dra has joined #lisp
<jeosol>
Is there anyway, I can build an executable (SBCL) but have it run and enter a repl. I understand building application takes an entry function. I am trying to avoid (re)building a docker, if I can just rebuild on my local machine, then push to docker.
ikki has joined #lisp
<jeosol>
Using core files, I obviously run into the issue of different runtime. Is there some hack around this?
<phoe>
jeosol: if you don't pass the entry point then it should reenter the repl
<lotuseater>
but in a class that inherits from superclasses the :allocation :class isn't given to the subclass
<phoe>
different runtimes? what do you mean?
<jeosol>
really. I tried to build a core file on my box but push it to the docker image and do sbcl --core corefile
<jeosol>
it complains about the corefile
<phoe>
the SBCL binaries *must* match in such case
<jeosol>
so maybe that is the hack I need, build an executable but leave out the entry function
<lotuseater>
ah yes i remember
<jeosol>
phoe: yes
<jeosol>
phoe: there is a mismatch, which is to be expected I guess. Thanks
<ebrasca>
What is this threading macros?
<phoe>
ebrasca: special syntax for binding anonymous variables
<phoe>
to avoid having gensyms and ## #= reader macros in source code
rumbler31 has quit [Ping timeout: 240 seconds]
<jeosol>
phoe: for my learning, when you say match, that's takes into account the machine/os. So using the same SBCL compiler v2.0.10 and say OpenSuSe, will not work for SBCL v2.0.10 and Debian
andreyorst_ has quit [Quit: andreyorst_]
<phoe>
jeosol: AFAIK they must have the identical binary, so differently compiled binaries with different md5 hashes likely won't work
* ebrasca
don't undestand why arrows are needed.
<jeosol>
ha, that's what it is.
andreyorst_ has joined #lisp
andreyorst_ is now known as andreyorst`
<lotuseater>
as far as i understand yet arrows are coming from category theory und functional programming for concurrency
<phoe>
ebrasca: they aren't needed; they are just some syntactic sugar over LET*
<_death>
ebrasca: they may make sense in cases where you have a lazy processing pipeline, e.g. with series (->> (scan-file ...) (map-fn t ...) (choose-if ...) (collect)) but otherwise they're just massively abused
dra has quit [Quit: Leaving]
<jackdaniel>
is it possible on sbcl for the object to change its address (or whatever that number means) asynchronously? I mean the number in #<some-class {123412341234}>
<jackdaniel>
say, I print the object repeatedly in a loop
<Bike>
i think so? the garbage collector moves stuff, right?
<jackdaniel>
and I observe #<foo {1234}> and after some time it becomes #<foo {aa12}>
<beach>
jackdaniel: I think so, yes, and that's not asynchronous.
<jackdaniel>
hm, that may be the case, thank you
<jackdaniel>
well, asynchronous in a sense that I'm not doing anything what could cause side effects, that's not the right term
<beach>
But it could allocate memory, and call the GC.
<jackdaniel>
but it "looks like asynchronously", and it confused me quite a bit, because I was trying to find a piece of code that swapped my object (and find out when that has happened)
hlisp has joined #lisp
<beach>
I agree that it's very confusing for the person trying to debug the code.
<jackdaniel>
thanks Bike and beach, that's the only explanation I could come up with - and printing a gensym seems to "prove" that it is the same object
jayspeer has quit [Ping timeout: 264 seconds]
<jackdaniel>
s/I could come up with/that makes sense/
<beach>
Sure. It happens to me all the time, given that I probably allocate huge amounts of memory, so the GC runs all the time.
hlisp has quit [Ping timeout: 240 seconds]
<jeosol>
I know there is talk about CL libs having poor documentation, but given most libs are developed by small teams/individuals, there isn't much time to do full documentation for every function and also show how to use them.
<jeosol>
I say that in the light of having discovered gems and use cases by actually looking at library source code.
<beach>
jeosol: I don't think you can generalize that way. The libraries I mentioned before are usually well documented.
<phoe>
jackdaniel: yes, the GC is moving these objects - I asked about specifically this on #sbcl some time ago
<jeosol>
And also the associated test library
<phoe>
in other words, the identity printed by print-unreadable-object is allowed to change at any time
<jeosol>
beach: I wasn't referring to any specific case per se.
<jeosol>
Pardon if my comment came out as a generalization. it is also not intended to mean we should not document or make things clearer
dbotton has quit [Quit: Leaving]
<beach>
OK.
<ebrasca>
I don't know how to make good documentation.
<jeosol>
I am considering teaching CL in a class setting, not formal, but introducing the students, so look for ways to avoid the frustration I hear with emacs and other tooling. I am no expert though
incidentist has joined #lisp
<jeosol>
esbrasca: I guess, I conflated "tutorial/examples" with documentation. I meant the former.
<jackdaniel>
sure, I'm usually recommending this writing by sjl_ when the topic of documentation comes up, because I've really enjoyed reading it
g0d_shatter has joined #lisp
<jeosol>
jackdaniel: sjl_? he authored that page
<jackdaniel>
yes
<jeosol>
beach: I do remember your metamodular document has a section about guidelines for documenting libraries
<lotuseater>
i like literate programming with org-mode
<beach>
jeosol: Oh? Great! I can never remember what stuff I write. People keep reminding me all the time.
<jeosol>
I remembered that section because around that time, I was trying to write and document better; so I looked at the google guide, norvig/pitman guide etc.
gproto23 has quit [Ping timeout: 260 seconds]
technobean has quit [Quit: ERC (IRC client for Emacs 27.1)]
<beach>
I believe you.
<jeosol>
beach: IIRC, in one of your libs you recommented for better doc, you advocted prepended % to slot names
hlisp has joined #lisp
<beach>
That sounds plausible.
<beach>
jeosol: I have to vanish. My (admittedly small) family just announced that dinner is served. I'll be back tomorrow morning (UTC+1).
<jeosol>
Great have a nice evening.
<beach>
Thanks!
rippa has joined #lisp
gproto23 has joined #lisp
jayspeer has joined #lisp
hlisp has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 240 seconds]
<ebrasca>
jackdaniel: Probably I need to practice this fantastic tips of how to write documentation, instead of only reading it.
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
sdumi has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
<lotuseater>
ebrasca and examples are good :)
sdumi has joined #lisp
cosimone has joined #lisp
orivej has joined #lisp
* ebrasca
think if he master documentation he is going to have 2 topics to learn left : profiling and testing.
<lotuseater>
oh yes
<lotuseater>
don't forget in testing powerful property tests :)
<lotuseater>
but I just used them in haskell yet, not in CL
<fiddlerwoaroof>
Testing isn't so hard in lisps: the sorts of things you do to make a codebase nice to work with in the REPL makes testing easier too
<fiddlerwoaroof>
And things like WITH-INPUT-FROM-STRING make a huge difference here, compared to Java or somethign
<ebrasca>
I get confused when making testing for file systems. Like ext4/fat32
<lotuseater>
so much to learn left ._.
cosimone has quit [Quit: cosimone]
<ebrasca>
Don't know how to test everity combination of input/output.
<fiddlerwoaroof>
What I've found is that separating the part of code that interacts with outside things (disks/etc.) from the code that doesn't need to (file format parsers, etc.) makes a huge difference
<fiddlerwoaroof>
ebrasca: that's tricky :) property testing helps there, but it can be relatively slow
<fiddlerwoaroof>
I find well-chosen unit tests are often sufficient for the certainty you need in most cases
<lotuseater>
OR you prove some parts :P
<ebrasca>
fiddlerwoaroof: How can you be sure you have 100% coverage or data waiting to be lost?
ikki has quit [Quit: Leaving]
hlisp has joined #lisp
<lotuseater>
unit testing just gives you what you think about
g0d_shatter has quit [Quit: Leaving]
hlisp has quit [Ping timeout: 256 seconds]
<fiddlerwoaroof>
ebrasca: yeah, for filesystems it gets more complicated because the stakes are higher
<fiddlerwoaroof>
In my experience, though, unit tests are a good way to discover edge cases and especially because they're easier to write and maintain than a lot of other sorts of tests
<fiddlerwoaroof>
Proofs, for example, often are too difficult to change to be feasible for anything except the most important code
<fiddlerwoaroof>
Property tests are often too slow to run frequently while working
<fiddlerwoaroof>
All of these things have their place, obviously
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hlisp has joined #lisp
hlisp has quit [Ping timeout: 240 seconds]
<ebrasca>
fiddlerwoaroof: How do you recomend me to test my case?
judson_ has joined #lisp
hlisp has joined #lisp
hlisp has quit [Ping timeout: 265 seconds]
<phoe>
okay
<phoe>
it seems that I have achieved arrows as places
<ebrasca>
fiddlerwoaroof: Thanks!
<phoe>
which is an original development, not coming from clojure - mostly because clojure doesn't have places
<fiddlerwoaroof>
ebrasca: well, I'd say the first thing to do is to write unit tests, because that's easy to do and it'll help you think about things like API design and code structure
<fiddlerwoaroof>
phoe: is that just relying on the macroexpansion provisions of the specification?
<phoe>
fiddlerwoaroof: not really; I am currently rewriting arrows to expand into LET* for readability
<phoe>
and LET* forms make very poor places
<phoe>
hence I need to play with a custom setf expander for them
jonatack has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
EvW has joined #lisp
<fiddlerwoaroof>
Hmm, doesn't expanding to LET* break things?
<phoe>
not if you are only reading values
<phoe>
I need a custom setf expander if I want to write things
<fiddlerwoaroof>
like (->> (expensive) (or t))
<fiddlerwoaroof>
I mean, the arrows misbehave
<phoe>
hmmm
<fiddlerwoaroof>
I'd expect that to return t quickly
Nilby has quit [Ping timeout: 256 seconds]
<fiddlerwoaroof>
The benefit in clojure is that it's purely syntactic
<phoe>
yes, I have not taken this into account
jonatack has quit [Ping timeout: 265 seconds]
hlisp has joined #lisp
jonatack has joined #lisp
jonatack has quit [Client Quit]
jonatack has joined #lisp
hlisp has quit [Ping timeout: 264 seconds]
jonatack has quit [Ping timeout: 240 seconds]
andreyorst` has quit [Ping timeout: 264 seconds]
jonatack has joined #lisp
andreyorst` has joined #lisp
hlisp has joined #lisp
hlisp has quit [Ping timeout: 260 seconds]
<phoe>
my current implementation of arrows makes the assumption that each form passed to the threading macro is going to be evaluated; splicing such a form into a form with special evaluation rules, e.g. OR, breaks this assumption
<phoe>
and now that I think of it, I have no idea if this is acceptable from an implementation of arrow macros
<phoe>
hmmm
<fiddlerwoaroof>
I've written a lot of Clojure code that uses arrows with macros that change evaluation rules
<phoe>
yes, I see, so that is a valid use case
bocaneri has quit [Read error: Connection reset by peer]
<pfdietz>
Property based tests are wonderful and powerful. I use them to find all sorts of bugs.
<phoe>
pfdietz: what did you find?
<pfdietz>
All those weird SBCL bugs I report? All due to various kinds of property based tests.
hlisp has joined #lisp
jibanes has quit [Ping timeout: 240 seconds]
<pfdietz>
Example property: "the SBCL compiler should never signal an error, even on erroneous input".
v3ga has quit [Quit: WeeChat 2.8]
<pfdietz>
Or: "a valid Common Lisp expression should do the same thing regardless of OPTIMIZE settings".
cosimone has joined #lisp
jibanes has joined #lisp
<fiddlerwoaroof>
pfdietz: yeah, it's a great tool my experience, though, is that I use the property tests to generate more deterministic test cases in my unit test suite.
hlisp has quit [Ping timeout: 246 seconds]
<pfdietz>
Sure, you want to capture the failures, just to make sure they dont unfix themselves later. But PBT keeps finding new bugs as development introduces them. And sometimes it finds a very low probability failure, something that took billions of inputs to expose.
<Bike>
they've been good for finding compiler problems in clasp
<Bike>
so, thanks
<pfdietz>
Nice! It's interesting that they have value later. That may say something deep about testing.
cosimone has quit [Quit: cosimone]
hlisp has joined #lisp
<easye>
"One test may be dumb, but a thousand dumb tests are smart."
liberliver has quit [Quit: liberliver]
aaaaaa has joined #lisp
qqqqqq has joined #lisp
qqqqqq has left #lisp [#lisp]
hlisp has quit [Ping timeout: 240 seconds]
<pfdietz>
I have considered using random test generation and minimization to generate unit tests, not by keeping failures, but by keeping tests that satisfy some other property (coverage, killing mutants). This might give a distilled unit test set that preserves some of the value of a prolonged run of the random tester.
<alandipert>
anyone know a good comparison of CL and ISLISP?
hlisp has joined #lisp
gproto23 has joined #lisp
<fiddlerwoaroof>
pfdietz: I think unit test's primary value is in helping you figure out the problem space as you're working
incidentist has quit [Quit: incidentist]
<fiddlerwoaroof>
Making it efficient to run 100+ picked examples every minute or so to verify that you're making progress
hlisp has quit [Ping timeout: 260 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
drl has joined #lisp
hlisp has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
hlisp has quit [Ping timeout: 265 seconds]
karlosz has joined #lisp
pillton has quit [Read error: Connection reset by peer]
pillton has joined #lisp
EvW has quit [Ping timeout: 260 seconds]
andreyorst` has quit [Ping timeout: 256 seconds]
jayspeer has quit [Quit: ERC (IRC client for Emacs 27.1)]
hlisp has joined #lisp
judson_ has joined #lisp
hlisp has quit [Ping timeout: 240 seconds]
ggole has quit [Quit: Leaving]
ebrasca has quit [Remote host closed the connection]
wsinatra has quit [Quit: WeeChat 3.0]
hlisp has joined #lisp
jw4 has quit [Read error: Connection reset by peer]
EvW has joined #lisp
jw4 has joined #lisp
hlisp has quit [Ping timeout: 240 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
incidentist has joined #lisp
judson_ has joined #lisp
andreyorst has quit [Remote host closed the connection]
dbotton has joined #lisp
hlisp has joined #lisp
Nilby has joined #lisp
MichaelRaskin has joined #lisp
hlisp has quit [Ping timeout: 240 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
aeth has quit [Ping timeout: 256 seconds]
hlisp has joined #lisp
aeth has joined #lisp
C-16 has quit [Remote host closed the connection]
imode has joined #lisp
andreyorst has joined #lisp
hlisp has quit [Ping timeout: 272 seconds]
aeth has quit [Ping timeout: 240 seconds]
Inoperable has joined #lisp
aeth has joined #lisp
cmatei has quit [Ping timeout: 272 seconds]
judson_ has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
<lotuseater>
to come back to documentation, how do you think of the common lisp hyperspec?
<no-defun-allowed>
The HyperSpec is a bit like a dictionary. It is rarely a good idea to try to learn how to do things from it, but you can clear up your understanding using it.
<lotuseater>
yes, some of the main symbols have good examples, others not
<lotuseater>
I don't even know all 978 symbols up to now :D
sjl has quit [Quit: WeeChat 2.2-dev]
<Xach>
978??
<Xach>
(loop for s being each external-symbol of :common-lisp count s) => 977
* Xach
runs
<lotuseater>
Xach yes if looking at symbol index
miasuji has joined #lisp
<phoe>
Xach: sigh
<lotuseater>
oh no :(
<phoe>
NIL is not counted
<phoe>
you need to count 1
<lotuseater>
phoe yes that's it
<phoe>
or count t
<lotuseater>
that would be a question in a certification test :D
<dbotton>
In quickproject the defpackage is placed in package.lisp is there a reason for not placing the defpackage in the actual package at the top?
<lotuseater>
but I'm not aware if something like this is existent in my country
<lotuseater>
dbotton I think if multiple files namespace is for the same package
<dbotton>
Then package order in the asd file would remove that as an issue
amb007 has quit [Read error: Connection reset by peer]
<mfiano>
Wait...
<lotuseater>
hmmm
<mfiano>
package order in the asd file?
<mfiano>
asd does not manage packages
<dbotton>
The components section defies order files would be loaded in
<dbotton>
Defines
<mfiano>
packages have nothing to do with files
<mfiano>
they are containers of symbols
amb007 has joined #lisp
<dbotton>
Correct, lotuseater was offering possible answer to my question that multiple files being used for same namespace
<dbotton>
In such a situation order is likely important anyways
<mfiano>
modules have dependencies, just like the root module. You don't have to load serially
<dbotton>
So we go back to my question, rephrased, what is the advantage of having a packages.lisp file instead of leaving defpackage at start of files
<mfiano>
Typically package.lisp is at the start of files
<lotuseater>
I also had this question in my mind when it comes to frequently changing some files
<dbotton>
Decoupling that from the actual "package" makes the files less portable
<dbotton>
Ie you have to copy out the definition of the package from the packages file when re-using the package
<dbotton>
Why would I want to do that?
<mfiano>
You're not making a ton of sense.
<mfiano>
I am having a hard time parsing what you are even saying. Maybe someone else can ask the right question so you can ask the right question.
<dbotton>
Let me give an example, if I have a file that defines a package of string functions
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<dbotton>
If I want to copy that file to a new project, I have to copy that file and also cut and paste from that packages.lisp
<mfiano>
Stop right there
<mfiano>
packages don't define functions
<dbotton>
Functions are in the namespace of the package?
<dbotton>
Some exported some not?
<lotuseater>
yes but just export to the system the set of symbols
<mfiano>
Common Lisp has multiple namespaces, and packages only care about _symbols_
hlisp has joined #lisp
gxt has joined #lisp
<Xach>
dbotton: if a project is big enough to have a separate package file, it's common to define a system for it, and depend on the system, not copy things around.
<Xach>
I sometimes copy rather than depend-on, but only for pretty small self-contained things. Single functions, or self-contained files of related things.
<dbotton>
Yes, but the idea is for reuse to other projects
<dbotton>
Unrelated
<dbotton>
To the current project
<Xach>
copying is a less-common way to reuse than defining a system
<dbotton>
Ok, so you find in large projects defining all the packages in one file works out well.
<Xach>
dbotton: In my experience, yes.
hlisp has quit [Ping timeout: 260 seconds]
<dbotton>
Then I'll keep to it for now :) Thanks
dbotton has quit [Quit: Leaving]
shifty has joined #lisp
rumbler31 has joined #lisp
pankajsg has quit [Ping timeout: 264 seconds]
hlisp has joined #lisp
rumbler31 has quit [Remote host closed the connection]
iskander- has joined #lisp
hlisp has quit [Ping timeout: 260 seconds]
cmatei has joined #lisp
iskander has quit [Ping timeout: 272 seconds]
FreeBirdLjj has joined #lisp
ecraven has quit [Quit: bye]
ecraven has joined #lisp
davisr_ has joined #lisp
davisr has quit [Ping timeout: 256 seconds]
aartaka has joined #lisp
Inline has joined #lisp
FreeBirdLjj has quit [Ping timeout: 256 seconds]
FreeBirdLjj has joined #lisp
<fiddlerwoaroof>
dbotton: package definitions are side effects on the reader
<fiddlerwoaroof>
I've found it more convenient to centralize packages in package.lisp because then, when I want to move a set of definitions to a new file, I just put (in-package :the-package) and copy/paste
<fiddlerwoaroof>
Ultimately, I want to store the code in the lisp image and treat files as disposable