<skidd0>
also Xach, and anyone else, do you have anything you remember when first learning lisp that you wish you knew sooner?
<skidd0>
basically, any key advice for a new guy
fikka has joined #lisp
Guest11393 has quit [Ping timeout: 256 seconds]
<Xach>
start making stuff, keep trying to do it better, ask for people to look at what you've done and suggest improvements or make you aware of stuff that would make life easier, interact with people and show your work
gabiruh has quit [Ping timeout: 264 seconds]
<Josh_2>
skidd0: programming newb or lisp newb?
<skidd0>
lisp newb
<skidd0>
thanks Xach
fikka has quit [Ping timeout: 268 seconds]
<skidd0>
I'm going to put my "learn lisp" to-do program on github once i've got a working version
<skidd0>
i'll post a link here once i do that for anyone interested in doing a code review
omilu has joined #lisp
<jeosol>
I agree with start to build stuff and refine as you go. I was able to build a very large system follow this, but I have done a lot of refactoring since.
FreeBirdLjj has joined #lisp
robotoad has quit [Quit: robotoad]
<skidd0>
I got really into web-dev with Flask (python) because of Miguel's well-structured Flask Mega Tutorial. I've looked at PCL, but are there other examples of project based learning for Common Lisp?
FreeBirdLjj has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
FreeBirdLjj has quit [Read error: Connection reset by peer]
sauvin has quit [Ping timeout: 244 seconds]
Kundry_Wag has quit [Remote host closed the connection]
fikka has joined #lisp
FreeBirdLjj has joined #lisp
makomo has quit [Ping timeout: 264 seconds]
Kundry_Wag has joined #lisp
sauvin has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
robotoad has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
<sabrac>
skidd0: I expect to be dropping a roadmap for potential postmodern development in another 24 hours or so. Migration support is on the roadmap
<skidd0>
oh awesome
<jeosol>
Sabrac, you are the man!!!
<jeosol>
Sabra Crolleton?
<sabrac>
yes?
<jeosol>
nice, I wanted to say this. I did benefit from your postmodern tutorials when I started, used that lib and clsql but mostly with postgresql
<jeosol>
good work man.
<sabrac>
Thank you. I want to find the time to write some tutorials that do not assume the reader already knows sql, but life gets in the way.
<sabrac>
I also get occasional reminders that I have not done a library comparison in awhile.
pierpa has quit [Quit: Page closed]
fikka has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
panji has joined #lisp
<jeosol>
you planned resource on the roadmap will be useful. Will look out for it.
<jeosol>
hahaha, that's funny. The reminders about the library comparison. Those where useful for sure. The ones on Json, time libraries, and csv business
ebzzry has joined #lisp
fikka has joined #lisp
Cthulhux has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 268 seconds]
newbie has quit [Ping timeout: 245 seconds]
pierpal has quit [Quit: Poof]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 248 seconds]
equwal has joined #lisp
<LdBeth>
Sup
fikka has joined #lisp
equwal has quit [Ping timeout: 276 seconds]
<skidd0>
sabrac: i see create-all-tables and create-package-tables, but neither seem to create the tables i identify when i (defclass something .. :table-name somethings)
<skidd0>
do i need to explicitely call (dao-table-definition 'something) for each class?
fikka has quit [Ping timeout: 276 seconds]
cgay_ has joined #lisp
equwal has joined #lisp
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
fikka has joined #lisp
<jeosol>
morning beach
<jeosol>
good morning beach
Fare has joined #lisp
<asarch>
Is the content of HyperSpec Lisp the same as "ANSI Common Lisp" book?
fikka has quit [Ping timeout: 276 seconds]
<skidd0>
no
<skidd0>
ANSI Common Lisp by Paul Graham?
<asarch>
Yeah, that book
<beach>
asarch: Yes, the Common Lisp HyperSpec has only minor differences compared to the ANSI standard.
<beach>
asarch: But Paul Graham does not mention the full language.
karlosz has quit [Quit: karlosz]
<asarch>
What do you mean with "the full language"?
<beach>
The book is too thin to mention every function, every macro, every class, every special form.
<asarch>
I see
<asarch>
Since I already know Kung-Fu, I was thinking to get a book about, for example, "how would I parse a file reading only...?" to check those functions related
Kundry_Wag has joined #lisp
<asarch>
There is a package of HyperSpec Lisp in OpenBSD ports
<asarch>
The Common Lisp HyperSpec (TM) from LispWorks Ltd. The Common Lisp HyperSpec is a hypertext version of the ANSI Common Lisp
<asarch>
standard.
<asarch>
clisp-hyperspec-7.0.tgz
graphene has quit [Remote host closed the connection]
terpri has quit [Ping timeout: 264 seconds]
<beach>
Almost, but not quite. The standard is owned by ANSI and not even LispWorks has the right to create a derived work from it. However, the draft standard is available for everyone to use, and there are only very minor differences between the draft and the final standard.
<asarch>
Is it expensive the standard?
<asarch>
I mean, could I buy a copy and then use that info as reference manual?
<beach>
Maybe. And they lost the source so they only sell badly scanned copies of it.
graphene has joined #lisp
<asarch>
D'oh!
<asarch>
Really?
<beach>
What is it that you want to do?
<asarch>
The STL (for C/C++) reference manual for Common Lisp?
<beach>
For all practical purposes, the Common Lisp HyperSpec is the reference. Except if you want to include it in the bibliography of a paper or a book. Then you need to refer to the standard.
<beach>
Again, what is it that you want to do?
<beach>
Create a manual and publish it?
<beach>
Just use it on your machine?
<asarch>
No, for my personal use
<beach>
Then copy the Common Lisp HyperSpec.
<beach>
LispWorks explicitly gives you the right to do that.
fikka has joined #lisp
<asarch>
Just the same I did with the PCL web: to get a hard copy and then read it every time I want to know something specific
<beach>
Oh, you want a paper version?
<asarch>
Yeah
<beach>
Then use the dpANS draft. It is in TeX format and it is free to use.
<beach>
Someone recently did a script to create a complete PDF for it.
<asarch>
YESSS!!!
<asarch>
Thank you beach, thank you very much
<asarch>
Why it is a "draft"?
<asarch>
A draft about what?
* asarch
takes notes...
<beach>
"draft" means "not the final version".
<beach>
It is the version that was distributed for people to comment on.
<beach>
The contents is identical to that of the Common Lisp HyperSpec, because LispWorks used the draft to create the Common Lisp HyperSpec.
<beach>
asarch: Are you sure you want that though. It is around 1000 pages as I recall.
<asarch>
:'-(
<asarch>
Every page cost $0.3 with large volumes here in México
fikka has quit [Ping timeout: 276 seconds]
<asarch>
I could ask full duplex for that
<asarch>
Is still the Meta Class System available in Common Lisp?
<beach>
?
<beach>
What is the "Meta Class System"?
<asarch>
I found a paper about it
<beach>
Do you have a reference?
<asarch>
Sure. I am uploading the file to the Mega cloud
<beach>
The title, the authors, and the abstract would be enough.
Fare has quit [Ping timeout: 276 seconds]
<asarch>
Sorry, medical emergency. I'll post you later
<asarch>
"Many people apparently use the Common Lisp Hyperspec, but I personally find this document highly confusing and difficult to learn from in any meaningful way." <- I thought I was the only one
fikka has quit [Ping timeout: 268 seconds]
<beach>
Sure, you can email it to me.
<beach>
The Common Lisp HyperSpec is not meant to be learned from. It is meant for people who implement Common Lisp systems.
<beach>
Also as a reference document for those who already know how to use Common Lisp.
nika has quit [Quit: Leaving...]
dddddd has quit [Remote host closed the connection]
<beach>
asarch: I am off for a while. Back in a few hours.
<johnnymacs>
Is garbace collection in the lisp specification
fikka has joined #lisp
<beach>
No.
<johnnymacs>
Then the satement "lisp is not suitable for kernel writing because it has garbage collection" iis objectively false.
<johnnymacs>
However if you said "sbcl is..." then it is techincally true unless you edit sbcl to not have garbage collection
<johnnymacs>
afaik
<beach>
Yes, the person who uttered that would have to come up with a reason why kernels could not have garbage collectors as well.
<pjb>
For example, Movitz is a CL implementation without a GC.
<pjb>
Since it was designed to write kernels…
<random-nick>
also, Mezzano is an OS with garbage collection
<beach>
pjb: Oh?
<pjb>
Which disproves the above statements two ways.
<johnnymacs>
One could argue because it is so expensive to port all linux software to a new and radically different kernel and because it is also so expensive to add garbage collection to the linux that they refuse to accept it
<johnnymacs>
*to a new kernel
<beach>
johnnymacs: That's a different argument all together.
<johnnymacs>
Indeed
<jackdaniel>
johnnymacs: I think that what the claim really is (as in sense - means) is that language without manual memory managament is not suitable to write kernels. I don't have opinion on that, just pointing out that taking causal claims verbatim and 'disproving' them is not especially ahrd
hhdave has quit [Ping timeout: 240 seconds]
<johnnymacs>
thoughough that particular argument has to do with real world logistics thus making it more complicated than abstract things like the hyperspec
<beach>
johnnymacs: While garbage collection is not in the specification, in practice you must have it.
<johnnymacs>
lots of mutable state involved in indsutry
<beach>
johnnymacs: So "SBCL is ..." is not technically true either.
<johnnymacs>
sure
<johnnymacs>
What would you say to someone who thinks a kernel should not have garbage collection
<pjb>
Give a good reason why?
svillemot has quit [Ping timeout: 240 seconds]
<jackdaniel>
that he might be right, but there is no evidence for that
<beach>
johnnymacs: That he or she would have to make an argument for it, and that argument would be easy to poke holes in.
<johnnymacs>
Well I don't know why they think that because I am not a kernel writer. I was hoping you would have a guess as to why they think that
<johnnymacs>
Do you have an idea of what arguments they commonly give?
<pjb>
Notice that linux, minix, etc all have a whole module consacred to memory management.
<beach>
johnnymacs: Many people think that GC is slower than manual memory management, or that it must have long pauses. Neither is true.
<jackdaniel>
johnnymacs: one argument could be GC pauses; another could be overhead (and kernel must be as fast as it can) etc. of course these are arguable
svillemot has joined #lisp
<beach>
johnnymacs: So it usually shows the ignorance of the person in question.
<beach>
jackdaniel: Tracing GC is typically way faster than malloc()/free().
<johnnymacs>
True but when I argue with them they will call me ignorant and their friends will be convinced they are right and all gang up on me asking me for evidence
<beach>
johnnymacs: Oh, I strongly advise you to avoid such an argument.
<beach>
johnnymacs: Instead, just ask questions...
<johnnymacs>
The thing is i am really strongly convinced that SBCL is a superior language than most languages but it is hard to convince others of it.
<jackdaniel>
beach: could be, I'm not familiar with the subject enough to argue. I could guess, that some tradeoff exists, i.e long pauses OR moderate overhead
<beach>
johnnymacs: "Why do you think GC is unsuited?"
<beach>
johnnymacs: "What makes you think necessarily has GC has long pauses?"
<johnnymacs>
I still do not think I am at the point where no matter what answer they give I will have a comeback demonstrating gc is just as suited
<beach>
johnnymacs: "What makes you think that real-time GC is impossible?"
<beach>
johnnymacs: That's why I say, don't answer, just ask.
<johnnymacs>
You can ask that question because you possess the knowledge to poke holes in their argument
<pjb>
Basically, it's like you're comparing two 400 m runners. They argue whether you're taking the inside lane or the outside line, and whether you have crocheted shoes or not. But lisp just cut straight thru the grass toward the finish line.
<puchacz>
shka1: thanks for the link
zmt01 has joined #lisp
<beach>
johnnymacs: No, just answer that you would like to see the reference.
<beach>
johnnymacs: Just don't be satisfied with the "Oh, everybody knows that" answer.
<johnnymacs>
beach: invariably if I do not fully undestand or not if the reference proves garabge collection is bad I will have to come hear for your evidence for why it is a hole in thair argument
<johnnymacs>
until I stop coming across holes I can not identify
<beach>
johnnymacs: I strongly advise against arguing. Just ask them to justify. In the end you can accept the argument if you like, or come back later with a pointer to an article that says the contrary.
<beach>
johnnymacs: Like if they say "real-time GC is not possible", you show them (later) the chapter from the book or an article about it.
<johnnymacs>
I consider it worth my time to convince the world of the speriority of languages which are written in compliance and according to the philosophy of the common lisp hyperspec until more efficient yet equally capable hyperspec comes along.
<johnnymacs>
Or even a more capable hyperspec which is unlikely unless we invent a new kind of computer.
<beach>
johnnymacs: You are wasting your time. People won't let themselves be convinced that easily.
mm__redacted has quit [Ping timeout: 265 seconds]
* jackdaniel
doesn't believe in superiority among incomparable (in sense of aesthetics, functionality, hackability etc) languages
<johnnymacs>
Let me express this then
<jackdaniel>
also this may be a bad strategy to convert people to the language you like: your language sucks because mine is better (in essence!) ;-)
<johnnymacs>
brainfuck is as superior as lisp because you can use brainfuck to write a lisp compliant with the common lisp hyperspec and run it. However it takes more work to do that in brainfuck than it takes to do it in sbcl thus making sbcl the victor. And if you are in braknfuck and you don't add in the capabilities of common lisp it objectively is worse thanc common lisp.
<beach>
johnnymacs: The psychological barriers are just way too great. You are asking people who spent many years of their life investing time and energy into a particular technology to admit that they made the wrong choice. Our brains have very strong mechanisms preventing that.
<johnnymacs>
First of all I think anyone who is willing to listen to evidenc and has the capacity to understand lisp will given enough tiem see the truth about lisp if explained to them with the right algorithm.
<johnnymacs>
Second of all I find humans to be a resource which should be allocated to lisp instead of python whenever possible.
<pjb>
Most languages are not intrinsically bad (thinking of C here). But people using them may be bad (or ignorant). Trying to convince them using a better programming language won't necessarily make them better, just bring bad programmers to the good language…
<johnnymacs>
or schem
<beach>
johnnymacs: That just isn't true.
<johnnymacs>
either one
<johnnymacs>
beach: which?
<beach>
johnnymacs: That people are rational and will listen to argument.
<jackdaniel>
"brainfuck is objectively worse than CL" – I throw at you argument: if someone is amused with using brainfuck (for fun), and tired with writing CL, then given "fun" criteria CL is *worse* than brainfuck for that particular person
<johnnymacs>
There is a probability as to how rational a person can be for how long.
saki has quit [Quit: saki]
<beach>
johnnymacs: Have you read my essay on the psychology of learning?
<johnnymacs>
beach: you can send it to me but I do not have time to read it right now
<johnnymacs>
could you state what you think is a true reaction to my statement
<johnnymacs>
If not I can try to demonstrate how the human mind is capable of reason.
<beach>
I have already said what I think. There are strong psychological forces that will make it very hard for you.
<johnnymacs>
I also try to spread lispy ideas covertly
<beach>
johnnymacs: That's a much better idea.
<jackdaniel>
well, it might be the attitude. I really believe that "your language is inferior to my because"
<johnnymacs>
I often tout langauges which fall more closely to the paradigms fo lisp: javascript, c#
<jackdaniel>
is not the best strategy ;)
<jackdaniel>
s/my/mine/
<beach>
johnnymacs: I consider myself fairly knowledgeable in these domains, but I gave up trying to argue with people a long time ago.
<johnnymacs>
Here is how I see it. My goal in life is to improve computers as much as possible before I die. I see every line in languages such as python or php for example to be wasted because there is a near guarantee that there are such flaws in the designs of these langauges that they have no choice but to retire their respective compiler projects at some point.
<johnnymacs>
Thus humanity's man hours are wasted and makes us more vulnerable agaisnt alien attack because our computers advance more slowly
JuanDaugherty has joined #lisp
<johnnymacs>
This is the same reason why I promote bsd/gpl etc
<beach>
johnnymacs: The only strategy that I have found that works is to do good work in the language that you prefer, and hope that people can see that it is better than theirs.
<JuanDaugherty>
given the generational turnover/attrition rate it's especially pointless, dumb
<JuanDaugherty>
wait the boogers out
<johnnymacs>
I find it easier these days to move people to languages closer and closer to lisp. I go online and post as random people and say lisp ideas.
<johnnymacs>
My most touting goes towards javascript.
caltelt has quit [Ping timeout: 256 seconds]
<johnnymacs>
I also tell people alfonzo church beat alan turing to the punch.
<beach>
You might want to check his first name.
<jackdaniel>
you can never predict which language will be a stepping stone for progress. Let's imagine C and UNIX were never invented, and that PC idea never took off. That'd lead to less tinkerers and programmers; also that'd lead to no SBCL ;)
<johnnymacs>
noted
<pjb>
Alonzo Church says wikipedia.
<jackdaniel>
of course that's one of possible scenarios
<johnnymacs>
The other thing is that yes we are writing in all these langauges that will be thrown away. And the objectively best languages, schem and lisp, are both langauges for writing languages inside of.
hhdave has joined #lisp
<johnnymacs>
And so we dont need to be wasting any of our code like that
<johnnymacs>
I can't allow humanity to waste all of our smart people
<puchacz>
beach: sorry, is realtime gc possible ;)? not trolling, just curious - despite 2 decades of java in the mainstream, and major companies backing it, it did not happen....
<JuanDaugherty>
in effect it's a moot point
<JuanDaugherty>
people with little experience charge off on tangents without bothering to find shit out because they heard this or that
<JuanDaugherty>
try actually observing how much time a well behaved sbcl system using the ordinary generational gc spends in gc
fikka has quit [Ping timeout: 256 seconds]
hhdave has joined #lisp
<JuanDaugherty>
and nobody is proposing or shouldn't be, writing device drivers in common lisp
<jackdaniel>
JuanDaugherty: RT is about deadline guarantees, not about throughput; as of drivers, I don't see a reason why they couldn't be written in CL (or other high level language)
<JuanDaugherty>
OK
fikka has joined #lisp
hhdave has quit [Client Quit]
<JuanDaugherty>
the burroughs machines did use algol for everything including device drivers but that's a special case
<shka1>
JuanDaugherty: that was few decades back i think :-)
<JuanDaugherty>
not sure what lisp machines did but imagine they used some machine lang some lisp
<jmercouris>
+1 on what jackdaniel it is possible to write a driver in Lisp, it would just probably be a bit harder, from my understanding, most drivers are copy/pasta'd forks of old drivers with modifications depending on how the device has changed
<jmercouris>
so in Lisp you wouldn't have the advantage of all the previous code you could copy/pasta
<jmercouris>
s/pasta/paste
Josh_2 has joined #lisp
Cthulhux has quit [Changing host]
Cthulhux has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<jmercouris>
beach: I've noticed its been several months since any progress on climacs, is that because you are focusing on SICL's GC?
fikka has joined #lisp
smurfrobot has joined #lisp
<jmercouris>
beach: McClim does work on OSX, indeed using X
<jmercouris>
what is the motivation for trying to do a 'native' port?
<jmercouris>
is it for reasons of performance?
milanj has joined #lisp
rumbler31 has joined #lisp
smurfrobot has quit [Ping timeout: 268 seconds]
<jackdaniel>
ftr, it is McCLIM; as of writing drivers, it is more about support from the underlying operating system
rumbler31 has quit [Ping timeout: 276 seconds]
<jackdaniel>
I was writing Linux drivers and it's far from copy-paste, it is mostly about using: a) exisitng abstractions; b) datasheets; c) other documentation
<jackdaniel>
to part a) is crucial wrt writing drivers in Lisp. I think all Mezzano drivers are written in Common Lisp
<jmercouris>
beach: jackdaniel: would there be any interest in updated graphics for McCLIM?
<jackdaniel>
define "updated graphics"
<jackdaniel>
I'm working on a set of gadgets following material design guidelines if that's what you talk about
<jackdaniel>
if you are interested in helping then I'm all ears ;-)
<jackdaniel>
rendered in CLIM, not gimp or anything
<jmercouris>
I'm not interested in material design
<jmercouris>
if you are interested in making a set of graphics that look good, I'm willing to help
<jackdaniel>
graphics for what?
<jmercouris>
unfortunately the intersection of graphics that look good, and material design have no overlap
<jmercouris>
well, I don't know what your terminology is, but I refer to things as widgets
<jackdaniel>
graphics are merely a tiny bit of design, so I'm not sure what you are after
<jmercouris>
so for example a button
<jmercouris>
how does a standard McCLIM button look like, what does a pane look like
<jmercouris>
these are things I would be interested in working on
<jackdaniel>
portable gadget set will follow what I've said above for a good reason: there is specification for it - not opinionated "I think that looks better" metodology
<jmercouris>
the material design specification is not the only design specification in the world
<jmercouris>
it also happens to be one of the worst ones in the world
<jackdaniel>
but nothing prevents you from adding your own gadget set; I'll do my best to guide you with techinicalities in McCLIM
<jmercouris>
"google makes great looking products" - no one ever
<jackdaniel>
if it is good and complete I see no problem with including it, I have other interesting projects too, so I don't feel a great urge to force my idea here
<Josh_2>
idk Google products look pretty nice imo
<jmercouris>
ok, where can I begin reading
<jackdaniel>
*but* if you are only willing to complain, that what I'm working on doesn't look good to you, then it is a different story
<Josh_2>
Like Google Docs, Android, Gmail, they all look nice
<jmercouris>
jackdaniel: I am only willing to complain? I've released a large amount of software and patches on the internet, complaining is just one of the things I do
<jmercouris>
and if you take a criticism as a complaint, then as you wish
<random-nick>
jmercouris: "gadgets" in McCLIM are things like buttons, sliders, text input fields and such
<jmercouris>
It is objective that material design is terrible
fikka has quit [Ping timeout: 268 seconds]
<jackdaniel>
I've just provided a disclaimer, that I'm not interested in debunking your own convictions, but if you are willing to create a portable set of gadgets for McCLIM I can help
dddddd has joined #lisp
<jmercouris>
jackdaniel: Sure, I can provide all of the assets and specifications
<jackdaniel>
and I really thing, that anyone who claims that something is *objectively* best/terrible/whatever when taken in terms of aesthetics, or a preference, is not very competent or honest
<jackdaniel>
I'm not interested in assets and specifications, I'm interested in code which works
<jmercouris>
jackdaniel: Computer Science is one thing, design is another
<jmercouris>
Anyways, sounds like you want to someone implement the actual gadgets, which means there does not exist a current way to theme McCLIM
<jmercouris>
which also leads me to believe that the current gadgets are implemented in code, and not really composed of bitmaps or anything that can be modified
<jackdaniel>
I've linked you a few starting points, then there is #clim channel. the gist of it is to inherit from existing gadget and define handle-repaint method
quazimodo has quit [Ping timeout: 260 seconds]
fluke` has quit [Read error: Connection reset by peer]
<jmercouris>
Ok, I will investigate
<jmercouris>
I appreciate the vote of "incompetence"
fluke` has joined #lisp
<jackdaniel>
sure
quazimodo has joined #lisp
<jmercouris>
That was sarcastic
<jmercouris>
Just to be clear, I don't appreciate it at all
<jackdaniel>
ah :(
Smokitch has joined #lisp
<jackdaniel>
Josh_2: imo they look good too, and take many important aspects into account
<jmercouris>
Most certainly, that's why designers the world over are using google products, and hailing them for their fantastic interfaces
<jmercouris>
Again, I'm being sarcastic, but what do I know
<jmercouris>
I'm done ranting
<Josh_2>
being able to have customizable graphics is a good idea
<random-nick>
jmercouris: well, the idea is to have the backends provide gadgets from the platform's native widget toolkit
<random-nick>
and then to have fallback portable gadgets implemented in lisp using clim functions
<jmercouris>
random-nick: so that's the idea behind having different backends?
<jackdaniel>
there are three layers of it. portable toolkit should be possible to use on any backend and adaptive toolkit (optional) is backend specific
<jackdaniel>
there are three layers of it. portable toolkit should be possible to use on any backend and adaptive toolkit (optional) is backend specific
<jackdaniel>
ops, sorry
<jackdaniel>
backends are for different platforms (display servers): Xserver, Wayland, GTK, Cocoa, WinAPI etc
pierpal has joined #lisp
<jmercouris>
so any backend can, or cannot be used with any toolkit?
cage__ has joined #lisp
<jmercouris>
I assume a portable toolkit can be used with any backend
<jackdaniel>
any backend can be used with portable toolkit
<jackdaniel>
but adaptive toolkit is backend-specific
<jmercouris>
but a specific toolkit eg. cocoa might only be usable on OSX backend
cage_ has quit [Read error: Connection reset by peer]
<jackdaniel>
i.e you use native GTK buttons - you can't use them on raw WinAPI
<jmercouris>
I see, and how do you deal with differences in the specifications of those widgets?
<jackdaniel>
yes
<jackdaniel>
gadgets have strictly functional specification
<jackdaniel>
how they look and are used is not defined in a standard
<jackdaniel>
portable toolkit provides some example implementation of abstract idea
<jmercouris>
Okay, but for example, let's say a specific type of callback exists in one implementation, but not another
<jmercouris>
what do you do then?
fikka has joined #lisp
<jmercouris>
for a special type of button press
<jmercouris>
as an example
<jackdaniel>
abstract gadgets in CLIM specification have limited protocol of things which happen
<jmercouris>
and that protocol is limited enough that it encompasses all GUI toolkits without gaps?
<jackdaniel>
which should work on all platforms. you have all abstract gadgets listed in the specification I've linked about
<jmercouris>
or at least the ones you wish to target?
<jackdaniel>
it presents "common" gadgets with their usual functionality
<jackdaniel>
it is possible that some existing toolkit doesn't support some of it, or that it supports more of it
<jackdaniel>
of course nothing prevents the programmer from defining his own gadget
<jackdaniel>
if adaptive toolkit can't produce it, then portable implementation is used
<pjb>
puchacz: real time java garbage collection happened several times. Here is the one by IBM, but other company propose other RTGC implementations for the JVM.
<jeosol>
syntax question: do you guys use '/' in variable (slot) names for example, I have a numeric quantity that a ratio of current value over initial value, then the variable name will be current/initial. Good/bad/doesn't matter
<jackdaniel>
looks OK to me
<jeosol>
thanks jackdaniel
Ven`` has joined #lisp
<jeosol>
current-inital-ratio seems a bit long, but current/initial seems shorter. not sure if others code this way.
<jeosol>
I'll go with the / variant
<pjb>
puchacz: it's rather lame to affirm things without using google first.
<pjb>
jeosol: yes, you can have fun. (let ((1/2mv2 (* 1/2 m v v))) …)
Baggers has quit [Remote host closed the connection]
<pjb>
jeosol: you can also use unicode, all current CL implementations support it. (let ((½mv² (* 1/2 m v v))) … ½mv² …)
<pjb>
jeosol: for lexical scopes, it doesn't matter much.
smurfrobot has joined #lisp
<jeosol>
pjb: Thanks for the info especially with unicode. The code reads more natural that way. My variable names are numeric quantities in equations.
<jeosol>
reads more natural this way and spot mistakes. Merci
runix_1 has joined #lisp
<pjb>
jeosol: if your code has a lot of formula, you could implement a reader macro to let you format your code like in HAL/S.
<pjb>
An alternative would be to use a reader macro just as a marker for emacs, so that it can read the expression, format it with LaTeX, and compose it over the source.
<pjb>
Something similar can be done for more complex expressions.
jmercouris has quit [Remote host closed the connection]
<pjb>
This means that you would still type or edit sexps, but you would see the nice formated and rendered expression in the emacs buffer.
Bike has joined #lisp
<jeosol>
Wow, that would have been very useful. I had to write code to compute volume of arbitrary grid, it was a bit messy due to the many equations.
<jeosol>
s/grid/grid-cell
Moosef has joined #lisp
<beach>
puchacz: Yes, it is possible, but there would be more overhead. Just as if you wanted a real-time malloc()/free() which would be even harder.
<beach>
minion: memo for jmercouris: Yes, I have been busy with SICL specification stuff.
<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
<pjb>
jeosol: in the worst case, what you can do is to write a CL macro that will scan the formula in your math book, run OCR on it, and translate it to a lisp sexp. The whole at compilation time.
flazh has quit [Ping timeout: 240 seconds]
gabiruh has joined #lisp
light2yellow has joined #lisp
flazh has joined #lisp
graphene has quit [Remote host closed the connection]
svillemot has quit [Ping timeout: 268 seconds]
graphene has joined #lisp
nsrahmad has joined #lisp
pagnol has quit [Ping timeout: 244 seconds]
pjb has quit [Ping timeout: 276 seconds]
quazimodo has quit [Ping timeout: 268 seconds]
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
svillemot has joined #lisp
graphene has quit [Remote host closed the connection]
gabiruh has quit [Ping timeout: 268 seconds]
graphene has joined #lisp
pjb has joined #lisp
gravicappa has joined #lisp
Ven`` has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
BitPuffin has joined #lisp
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
rozenglass has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
Kundry_Wag has joined #lisp
sendai_ has joined #lisp
buoyantair has quit [Ping timeout: 276 seconds]
makomo has quit [Ping timeout: 264 seconds]
makomo has joined #lisp
azimut has quit [Ping timeout: 240 seconds]
EvW has quit [Ping timeout: 265 seconds]
smurfrobot has quit [Remote host closed the connection]
drduck has joined #lisp
EvW1 has joined #lisp
nsrahmad has quit [Quit: Leaving]
smurfrobot has joined #lisp
Kaisyu has joined #lisp
elfmacs has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
asarch has joined #lisp
anewuser has joined #lisp
smurfrobot has quit [Remote host closed the connection]
charh has quit [Remote host closed the connection]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
Moosef has quit [Quit: Connection closed for inactivity]
EvW1 has quit [Ping timeout: 245 seconds]
nsrahmad has joined #lisp
Baggers has joined #lisp
Moosef has joined #lisp
cage___ has joined #lisp
milanj has joined #lisp
cage__ has quit [Ping timeout: 260 seconds]
cage___ has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
cage_ has joined #lisp
pagnol has joined #lisp
orivej has quit [Ping timeout: 264 seconds]
orivej has joined #lisp
<beach>
flip214: Around?
<beach>
flip214: For root pointers, I just made a rule that if any invocation has a pointer to a rack (to the beginning of it, or to any element of it), then it must also have a pointer to the header. That other pointer is then subject to register allocation just like everything else. I just have to make sure it is not eliminated even though it is "dead". It would very likely migrate to the stack of course.
orivej has quit [Ping timeout: 276 seconds]
Lauven has joined #lisp
<flip214>
beach: yes.
<flip214>
for a few minutes, at least.
rumbler31 has joined #lisp
jibanes has quit [Ping timeout: 244 seconds]
<flip214>
what's the question?
jibanes has joined #lisp
<beach>
You suggested I store header pointers in the thread object. I am suggesting an alternative.
<flip214>
what "invocation" would that be? a GC run?
<beach>
No, anything that creates a stack frame.
<flip214>
ah, okay.
<beach>
Any function, basically.
nanoz has joined #lisp
<flip214>
well, the important thing is that there's a defined space for per-thread root pointers; and as registers are likely to contain arbitrary integer values, they might become false positives.
<flip214>
so storing on the stack looks okay.
<beach>
No, they can't.
<beach>
The compiler emits information that says whether a register or stack location contains a Common Lisp object or not.
<flip214>
although that means that you might need additional stack space, which might become a problem for deep recursive calls.
<flip214>
oh, so you go that way. Fine too -- sounded just like more work to me, but what do I know?
rumbler31 has quit [Ping timeout: 276 seconds]
<beach>
That will be a problem anyway, because I would need space in the thread object for arbitrarily many pointers.
<beach>
Might as well store them on the stack.
<beach>
The stack is cheaper too.
<beach>
More work? How?
<flip214>
beach: no, at most one per register.
<beach>
I don't see that.
<flip214>
"more work" as in "the compiler needs to tell the GC which register store pointers at which point in time"
<beach>
Oh, that's just implementation work. No more work at run time.
<beach>
Suppose for a moment that every register is a caller-saves.
<beach>
Now, you have a function that accesses the rack of some object o1.
<beach>
But it no longer needs the pointer to the header.
sabrac has quit [Quit: Konversation terminated!]
<beach>
So you store the pointer to the rack on the stack and then you call another function.
<beach>
That function needs a pointer to the rack of some object o2.
<beach>
So you store that pointer on the stack and then call a third function.
<beach>
etc, etc. etc.
<beach>
You now have rack pointers in 3 stack frames, but no header pointers.
<beach>
If I were to store those header pointers in the thread object, I would need one such location per stack frame, so not a bounded number.
karlosz has joined #lisp
pagnol has quit [Ping timeout: 264 seconds]
subroot has joined #lisp
<flip214>
But if o1, o2 etc. are no longer needed, what do you need the rack pointers for? To speed up GC because it knows which racks are in use?
Ven`` has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
OK, suppose I do (+ (aref x (f a)) (aref x (g b)))
EvW has joined #lisp
SaganMan has joined #lisp
<beach>
To access the elements, I no longer need the reference to the header. Just a pointer to the rack. So when (b b) is called, there would normally be no reference to the header.
<flip214>
oh, I'm sorry. I think I got the terminology wrong - the "rack" is the "object" in SICL, right?
<beach>
No the header is *the* object.
<beach>
But it doesn't contain any information other than the class.
pagnol has joined #lisp
<beach>
So if there is no pointer to the header, the object will be reclaimed by the GC.
<beach>
Sorry, the header contains the class and a pointer to the rack.
<beach>
I need to go fix dinner. I'll talk about this some other time.
<flip214>
beach: me too.
<flip214>
If your paper is in (kind of) shape, I'd like to read it again.
<beach>
OK, great.
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
rippa has joined #lisp
graphene has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
graphene has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<puchacz>
beach: tks. I did not realise malloc/free is harder for RT than GC. anyway :)
<puchacz>
purely academic curiosity, I don't need RT
<beach>
Many people don't.
<beach>
.. realize that.
<beach>
But if you study Paul Wilson's allocator survey, you will see why.
<beach>
Most modern GCs can do an allocation by bumping a pointer (and maybe a test).
smurfrobot has joined #lisp
<beach>
... whereas malloc() needs to find an appropriate block, and maybe split it up, link it into a list, etc, etc. Lots of memory accesses there.
fikka has joined #lisp
EvW has quit [Remote host closed the connection]
<beach>
People who argue in favor of manual memory management usually don't know how malloc() and free() are implemented.
EvW1 has joined #lisp
<puchacz>
I don't understand why most software like OSes, window managers, browsers, office packs etc. are written with manual memory management, usually in C++
Kundry_Wag has quit [Ping timeout: 264 seconds]
<beach>
puchacz: The usual ignorance.
<beach>
Ignorance is very powerful.
<puchacz>
rly :) ?
<puchacz>
I guess lack of skills may be the reason many desktop Java apps feel slow
<beach>
Plus, if they are using C++, they sometimes think that delete is has O(1) complexity, but it can be arbitrary if the structure is big.
<puchacz>
i.e. slow to respond to user inputs, and they feel like they eat a lot of memory
<beach>
I totally agree.
<puchacz>
so is it JVM problem or lack of skills?
<puchacz>
of app programmers?
<beach>
I suspect the JVM is very good. So bad programmers would be my guess.
fluke` has quit [Read error: Connection reset by peer]
<puchacz>
there is also Java itself atop of JVM.
fluke` has joined #lisp
<beach>
The Java compiler has been pretty optimized as well. I really don't know what the problem might be.
<beach>
puchacz: I wonder whether it has to do with programmer skills. Isn't it the case that C++ programmers in general come from a better trained crowd, so that they know more about algorithms and data structures. I have the impression that Java programmers are often hired immediately out of a short training program, and they reuse existing libraries without knowing the complexity of operations. Not universally true of course. But perhaps
<beach>
statistically.
Kundry_Wag has joined #lisp
charh has quit [Changing host]
charh has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
dtornabene has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
<jeosol>
regex experts here: I current using the following for capture a float "([-+]?\\d*\\.?\\d+[eE]?[-+]?[0-9]+?)" in some string using cl-ppre. How do I convert this so this is optional. To provide context, I am trying to parse a string like
<jeosol>
"jeosol 9.456 " in one case and sometimes "jeosol 9.456 8.563", i.e., in one case, I have one number other times two,
<Bike>
{1,2}?
<jeosol>
I have the part to capture the string name, it's the number side
<jeosol>
what is what the full string looks like, the large spaces before the : after a number may contain a number for different problem instance. This is output from a black-box exe
<jeosol>
s/what/that
varjag has joined #lisp
brendyn has quit [Ping timeout: 260 seconds]
JuanDaugherty has joined #lisp
<jeosol>
ok, beach, thx
<jeosol>
solution is a bit nasty, adding that floating regex ...{0,1}? seems to work, at least I get out the first numeric value.
<jeosol>
Thanks lord beach. that works.
EvW1 has quit [Ping timeout: 265 seconds]
nsrahmad has quit [Quit: Leaving]
slyrus1 has quit [Ping timeout: 268 seconds]
slyrus_ has quit [Ping timeout: 256 seconds]
Demosthenex has joined #lisp
jibanes has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
<Demosthenex>
i'm using dexador to query a web api with a rate limiter i hit sometime. I'm trying to make a restart-case which will just retry the call after a delay. i'm completely new to conditions and restarts, and most of the tutorials are more confusing than helpful. any pointers?
<Xach>
Demosthenex: i enjoyed the explanation in practical common lisp.
jibanes has joined #lisp
<Demosthenex>
Xach: that book is dead sexy. i read thru that chapter several times, but don't feel like i quite got it.
<Xach>
Demosthenex: what have you written so far?
fluke` has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 248 seconds]
<klltkr>
Hello all
<Demosthenex>
i think what i'm most confused about is the "keywords" which are part of the language, and items that are written in by the tutorial authors. i've been reading about these for over a half hour on teh web and still don't get it.
<Demosthenex>
i mean, is tehre really a handler called "just-continue"?
fluke` has joined #lisp
<Xach>
Demosthenex: not a standard one.
Moosef has quit [Quit: Connection closed for inactivity]
<Xach>
Demosthenex: so you have done some reading but no coding yet?
<Demosthenex>
i have working dexador calls, just trying to understand how to wrap it in restart-case
<Demosthenex>
i was able to make one that just retries infinitely, but i'm trying to handle a specific error and delay then try again...
<Demosthenex>
i think i'm looking for a clearer tutorial, or some really short examples. not a copy/paste session ;]
<Xach>
Ok. Good luck with it.
<Xach>
I don't know of anything in particular.
megalography has quit [Ping timeout: 276 seconds]
<Demosthenex>
yep, i'm continuing reading for now. but i'll take any pointers to docs. obviously i've already seen pcl
<Xach>
I know how it works and can give specific advice on specific code but don't know of tutorials that will fit how you want to learn.
slyrus_ has joined #lisp
<SaganMan>
Hello peeps
newbie32 has joined #lisp
<klltkr>
Yo SaganMan
<SaganMan>
hello
fluke` has quit [Read error: Connection reset by peer]
cgay_ has quit [Remote host closed the connection]
fluke` has joined #lisp
nanoz has quit [Read error: Connection reset by peer]
smurfrobot has quit [Remote host closed the connection]
cgay_ has joined #lisp
fikka has joined #lisp
megalography has joined #lisp
nullniverse has joined #lisp
xantoz has quit [Quit: WeeChat 2.0.1]
nanoz has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
varjag has quit [Ping timeout: 260 seconds]
lnostdal has joined #lisp
<jeosol>
hello SaganMan
xantoz has joined #lisp
fluke` has quit [Ping timeout: 276 seconds]
Kundry_Wag has quit [Remote host closed the connection]
<puchacz>
beach: agree (about C++ being more hardcore programmers Java programmers)
fikka has joined #lisp
fluke` has joined #lisp
pagnol has joined #lisp
marusich has joined #lisp
FreeBird_ has quit [Remote host closed the connection]
<trittweiler>
Demosthenex, Have a look at this snippet: https://pastebin.com/EEJSKUWZ -- that's perhaps along the lines of what you want. But perhaps that's as far as you got, and you're stuck at not retrying after, say, 3 attempts?
<Demosthenex>
Xach: so my example, i call to fetch data from a restful api. https://bpaste.net/show/a47a6a39bf78 my goal is to only respond to the specific DEXADOR condition by causing a sleep for 10 seconds and then retrying my http call.
ckonstanski has joined #lisp
<Demosthenex>
trittweiler: is (go :again) a dolist syntax sugar?
<trittweiler>
dolist expands to an implicit tagbody
<Demosthenex>
because i had the impression restart-case had a way to just reexecute the same code it was wrapping
<Demosthenex>
and part of my problem has been divining what's part of the language, and what's a name made up by the tutorial author
<trittweiler>
if you didn't do that GO, the execution after the restart-case clause would continue after the (restart-case ...) <--, i.e. at the end of the loop, and the next step would be the next dolist iteration (i.e. you would have implemented a "skip url on error-503")
<Demosthenex>
so while i get most of your example, i'm tripped up over your dolist combined with restat-case
<Demosthenex>
so you're using the dolist tag to jump execution back before the restart statement, i get that... but i'm trying to wrap a single function call
<Demosthenex>
isn't there a builtin that just says repeat? i mean, the debugger lets me do that
<Bike>
those repeats are from loops as well.
<trittweiler>
You mean the RETRY restart in Slime? That's actually a restart-case somewhere in the common lisp backend of slime.
<jeosol>
CLOS question: what is a clean way to construct a CLOS object from a list of the form (:initarg-1 value-1 :initarg-2 value-2 ...). This list is a bit long. Passing that with constructor having &rest args gives error.
<Bike>
jeosol: applying make-instance to that should be fine
<Demosthenex>
trittweiler: i think that's where i'm tripped up. there look there there are a list of always available restarts, and some that are created, but i haven't yet seen a list of what's built in.
<Bike>
none of them are built in
<jeosol>
beach: I get a keyword agument not a symbol error: ... my list form above
<Bike>
every single one of those corresonds to a restart-case or restart-bind
<Bike>
jeosol: it's "bike". and what exactly are you doing? something like (apply #'make-instance class initargs) is what i'd expect.
koenig1 has joined #lisp
pierpal has quit [Quit: Poof]
<beach>
jeosol: I know nothing about regular expressions, so I was not the one helping you.
<jeosol>
I am sorry Bike
pierpal has joined #lisp
<jeosol>
Brain freeze, need some sleep
koenig has quit [Ping timeout: 240 seconds]
<trittweiler>
Demosthenex, Do you understand dynamic-variables?
mathrick has quit [Ping timeout: 260 seconds]
<beach>
jeosol: By the way, the term "CLOS object" does not exist in the Common Lisp HyperSpec. If it had any reasonable definition at all, it would be "any Common Lisp datum".
<jeosol>
haha. thanks for the correct. I meant to say instance of a class.
<beach>
Yes, every Common Lisp object is an instance of some class.
Kaisyu has quit [Quit: Connection closed for inactivity]
<beach>
jeosol: Try (class-of 234) for instance.
cage_ has quit [Remote host closed the connection]
cage_ has joined #lisp
<beach>
jeosol: What most people mean when they say "CLOS object" is probably "standard object".
<jeosol>
So I had a defclass defined and I get a list as above,and I want to create a corresponding class object from the list. And do this many times.
<Demosthenex>
trittweiler: as in dynamic vs lexical scope?
pioneer42 has joined #lisp
<Bike>
yeah, you should apply make-instance for that.
<jeosol>
beach: I see. But in my case above, I should I have instance of a user-defined class, I guess.
<beach>
jeosol: It is called a "standard class" and its instances are called "standard objects".
smurfrobot has joined #lisp
<trittweiler>
Demosthenex, Look at CRAWL-2 in https://pastebin.com/wCtccKXL - that will show you what CRAWL essentially expands to. I think that might help you understand RESTART-CASE better and to see what all those magic names are about
mathrick has joined #lisp
Fare has joined #lisp
<beach>
jeosol: Did you manage to get it to work?
vtomole has joined #lisp
<Demosthenex>
trittweiler: so, how can you get restart-case to repeat (push (http-get url) web-pages) without using the (go :again) call that leverages your do loop? my use case is a single function call, and if it fails with a specific condition i just want to call it again...
<Bike>
you can use tagbody to get explicitly what dolist has implicitly
<Demosthenex>
trittweiler: i do understand how the handler has to be "above" the restart-case, and call back into the restart.
<Demosthenex>
and the PCL example just gives an example of using a restart to return a nil value (ie: skip).
<jeosol>
Beach: Yes, I got it to work.
<Demosthenex>
so perhaps i can just make my function call there isntead of nil, but that's where the state confusion comes in, the rollback of the stack, etc. can i depend on my variables being the same at that point? that's why i thought there was a simple "repeat" buried in a keyword
<jeosol>
my error was initially from mismatched initarg names, I was constructing that list by a different function and then splicing the values, definitely not clean.
<jeosol>
So I missed a few names
Lauven_ has joined #lisp
krwq has joined #lisp
ckonstanski has quit [Quit: bye]
Lauven has quit [Ping timeout: 276 seconds]
megalography has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
random-nick has quit [Read error: Connection reset by peer]
<trittweiler>
Demosthenex, That is why it uses handler-bind and not handler-case. When you use handler-bind, the handler is actually executed at the place of the invocation of SIGNAL (or ERROR).
<trittweiler>
Demosthenex, The handler-bind does not actually have to be above the restart-case. :)
<trittweiler>
Demosthenex, It just makes more sense, otherwise you'd set-up a new handler in each iteration. So you want it outside of the loop
Josh_2 has joined #lisp
Lauven has joined #lisp
<Demosthenex>
trittweiler: i think i have it. i'm using a simple handler-case with a sleep and just re-executing the function call. the only downside is that it can only happen once, it can't sleep repeatedly
<trittweiler>
Demosthenex, If you want to repeat (foobar x y z) on error THE-ERROR, just do (loop until (handler-case (progn (foo x y z) t) (the-error () nil))
<Demosthenex>
trittweiler: i guess that's part of my misunderstanding. i'd have thought a restart had a way to repeat that function :P
Lauven_ has quit [Ping timeout: 276 seconds]
<Demosthenex>
and it's quite gross atm the way i have the entire long function call repeated in my handler, it's definitely not lispy
lnostdal has quit [Ping timeout: 240 seconds]
<Demosthenex>
maybe i should just loop it. i've avoided loop though
nanoz has quit [Read error: Connection reset by peer]
<Bike>
i wouldn't repeat the call in the handler or anything if i could avoid it
<jackdaniel>
(tagbody repeat (handler-case (my-function-call) (error () (go repeat))) ; would be more like it
vultyre has quit [Quit: Leaving]
<jackdaniel>
but either way, that's not a wise thing of handling errors :)
<jackdaniel>
s/thing/way/
asarch has quit [Ping timeout: 256 seconds]
vultyre has joined #lisp
<Demosthenex>
jackdaniel: well, i was looking at restarts. just confused as heck ;]
<jackdaniel>
restarts are meant for interactive use in the debugger in my understanding
<Bike>
you can invoke them programmatically too.
<jackdaniel>
if you want to handle errors, then handler-case and handler-bind are the way to do it
<jackdaniel>
Bike: I'm aware of that – hence "are meant" and "in my understanding"
koenig1 is now known as koenig
<Demosthenex>
jackdaniel: i'm querying a web api and hitting a rate limiter sometimes. i'm trying to catch the condition/error raised by dexador that matches the rate limiter, sleep, and then retry
<Demosthenex>
to that effect, trittweiler has made a nice pastebin example, but it's using do to repeat the code. that's narrowing down my question though, can i repeat it via restarts, or just use loop and do
<Demosthenex>
i thought there would be a way to repeat it via restart, not using traditional control macros
<Bike>
there really is not. you are asking for a loop, and to do a loop you do a loop
<jackdaniel>
or loop a do (jk)
<Demosthenex>
Bike: had i written the code, i may have done a loop. but dexador throws a condition, so i went to conditions
<Demosthenex>
and it seemed likely i could have it repeat via restart
<Bike>
you can
<Bike>
but the restart will loop
<Bike>
like in the crawl-2 example you were given
<Demosthenex>
in crawl/crawl2 the dolist construct and a goto are doing the looping
<Bike>
yeah, the goto
<Bike>
so you can just do the tagbody
<Bike>
there is no combined restart and loop construct. if you want to do both, you do both.
<Demosthenex>
but isn't that the point of restart? if the call failed, rollback and try again with potential fixes?
Fare has joined #lisp
<Bike>
That is one thing you can use a restart for, but not the only one.
<Bike>
You could also have a restart that returns some kind of "request failed" token, for instance
<trittweiler>
Demosthenex, nope, that's orthogonal to each other. That's the beauty of Common Lisp, many well-designed, orthogonal concepts
JuanDaugherty has quit [Quit: Exeunt]
lemonpepper24 has joined #lisp
<trittweiler>
Demosthenex, restarts are really just dynamically scoped functions in their own namespace
<jackdaniel>
so you can foot yourself on the foot in n-dimensional space :-)
<jackdaniel>
shoot* drat
vultyre has quit [Quit: Leaving]
lnostdal has joined #lisp
jack_rabbit has joined #lisp
<Bike>
so if you want to execute a call until it succeeds, i'd do something like (loop (restart-case (return (call-goes-here)) (retry ())) i think
<Demosthenex>
yeah. its not as "meta" as i thought then ;]
<Bike>
if the call alters any state, you'll have to repair it yourself
fikka has quit [Ping timeout: 240 seconds]
<Demosthenex>
i try to stay functional, i often encapsulate local vars and state in let's that are very local.... i can't recall the last time i used setf outside the repl... and loop doesn't return the last call like other things
rumbler31 has joined #lisp
<Bike>
that's what the return is for
<Demosthenex>
using (loop until with ='s and return is so not lisp. that's C all over :PP
smurfrobot has quit [Remote host closed the connection]
<Bike>
as you like.
<Demosthenex>
time for more recursion!
random-nick has joined #lisp
<trittweiler>
you have not read a lot of Common Lisp code if you think that recursion is used more frequently than loop :)
<Demosthenex>
trittweiler: i am a noob.
<Josh_2>
Use do/dotimes/dolist if you don't like loop
<Josh_2>
I like do a whole bunch
rumbler31 has quit [Ping timeout: 276 seconds]
Oladon has joined #lisp
<trittweiler>
Common Lisp has lots of looping constructs which are usually favored over recursion. Also be aware that tail-call optimization is not mandatory by the standard, and implementations may only do it at certain compilation settings
<Demosthenex>
i use mapcar and friends constantly. never used do, loop, or dolist, etc :P
Jesin has quit [Quit: Leaving]
<Demosthenex>
but i don't often do hugely complex code, or interact with users. it's all backend
<Josh_2>
difference strokes for different folks
<Demosthenex>
sure. i learned tons of other languages before getting to lisp, and i like functional constructs.
<Demosthenex>
thus the idea of using a restart natively to allow me to continue linearly passing data between layers appealed, instead of throwing a loop in the middle
Jesin has joined #lisp
<aeth>
loop is only necessary for collect. It's not really necessary for anything else, although it may be more or less efficient than direct alternatives because it's usually implemented very differently.
<aeth>
by necessary I mean something like (loop for i from 1 to 100 collect i)
<aeth>
You're not going to get something equally concise and simple (and it only gets worse when you have two different collects) without a library.
DonVlad has quit [Remote host closed the connection]
smurfrobot has joined #lisp
<runix_1>
Are there CL standard compiler declarations/directives such as e.g. #+nil, and where can I find documentation for these? (can't find anything with google)
<pjb>
Intention behid #+nil is to read the following form on in the New Implementation of Lisp, the NIL.
<jackdaniel>
(works under certain, most probably met conditions)
lemonpepper24 has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 260 seconds]
DonVlad has joined #lisp
dtornabene has quit [Read error: Connection reset by peer]
dtornabene has joined #lisp
Lauven has quit [Ping timeout: 244 seconds]
Lauven has joined #lisp
<housel>
Though I did use Lisp on Vaxen in the 80s, I never got a chance to use NIL (only Franz Lisp on BSD 4.2).
<Demosthenex>
_death: yeah, that's a goto again, similar to the other. but thanks for the example! =]
gravicappa has quit [Ping timeout: 264 seconds]
<jackdaniel>
housel: I think that pjb was referencing a joke (I think made by Steel) that CL will work all fine until the New Implementation of Lisp is created
<_death>
user code doesn't need to know it's goto :)
<jackdaniel>
because given how feature conditions are used to distinguish implementations #+sbcl #+ecl etc this implementation will have #+nil for that
<jackdaniel>
and all code which was commented improperly with #+nil will be suddenly enabled :)
<housel>
IIRC I think NIL did use #+NIL as its feature test
Lauven has quit [Quit: leaving]
robotoad has joined #lisp
<Demosthenex>
trittweiler: i was reading something about saving the point in the stack, and rewinding or preserving that data. that's why i thought it worked that way
<Bike>
stack unwinding is a bit different
<Bike>
if you signal an error, and a handler bind catches it, and the handler bind does invoke-restart, with the way most implementations work no stack is actually unwound
<Bike>
restarts are, as trittweiler puts it, just functions
Kundry_Wag has quit [Remote host closed the connection]
<pjb>
But invoking the restart may unwind the stack.
fikka has joined #lisp
<Bike>
i wouldn't think so
dtornabene_ has joined #lisp
edgar-rft has quit [Ping timeout: 276 seconds]
dtornabene has quit [Ping timeout: 240 seconds]
megalography has quit [Ping timeout: 260 seconds]
<pjb>
Obviously.
<pjb>
What happens if you select the ABORT restart?
fikka has quit [Ping timeout: 264 seconds]
<Bike>
well, the restart itself might unwind, sure
<Bike>
i meant the act of invoking
<pjb>
Yeah, just what I wrote: But invoking the restart may unwind the stack.
dtornabene__ has joined #lisp
dtornabene_ has quit [Read error: Connection reset by peer]
<Demosthenex>
and yet, this is why i thought there was a builtin retry function
<Bike>
well... you thought wrong. dunno what else to tell you
<Bike>
stack unwinding and rewinding is separate from control flow anyway, if closely related
<_death>
erm, I mean non-lexical, non-local exit :)
<Bike>
am i supposed to be able to read this
<_death>
yeah it's weird.. I don't remember reformatting it when I downloaded it years ago
edgar-rft has joined #lisp
megalography has joined #lisp
<pjb>
Well, invoke-restart just calls the restart, and indeed, the restart may perform the non-local exit explicitely, or just return.
<_death>
view source.. I think it's just the wrong content-type
<pjb>
so Bike is right.
EvW has quit [Ping timeout: 260 seconds]
<trittweiler>
absolutely, that's the whole point of invoke-restart-interactively
fikka has joined #lisp
pioneer42 has left #lisp [#lisp]
Anthaas has quit [Ping timeout: 256 seconds]
EvW1 has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
svillemot has quit [Quit: leaving]
JuanDaugherty has joined #lisp
megalography has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
dtornabene__ has quit [Quit: Leaving]
Oladon has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
vlatkoB has quit [Remote host closed the connection]
eSVGDelux has joined #lisp
lemonpepper24 has joined #lisp
eSVG has quit [Ping timeout: 260 seconds]
angavrilov has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 276 seconds]
svillemot has joined #lisp
megalography has joined #lisp
svillemot has quit [Quit: ZNC 1.6.5+deb1+deb9u1 - http://znc.in]
svillemot has joined #lisp
DonVlad has quit []
zmt01 has quit [Quit: Gone.]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Read error: Connection reset by peer]
anewuser has quit [Ping timeout: 256 seconds]
rumbler31 has joined #lisp
jmercouris has joined #lisp
fikka has joined #lisp
rumbler31 has quit [Ping timeout: 248 seconds]
rumbler31 has joined #lisp
<phoe>
If I allocate a STATIC-VECTOR and then save the Lisp image, will the vector still be there when I load the image again?
<phoe>
That's likely a rhetoric question but I need to be sure on that one.
anewuser has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
JuanDaugherty has quit [Quit: Exeunt]
<pjb>
phoe: depends.
<pjb>
phoe: notice that there are no static anything in Common Lisp, so it's already implementation dependant.
rumbler31 has quit [Ping timeout: 265 seconds]
<pjb>
phoe: then of course, whether any kind of object is preserved thru an image saving will depend on whether there is a live reference to that object or not.
<pjb>
phoe: which of course depends also on whether such a reference can exist. For example, foreign pointers are no such references (they're just integers).
<pjb>
So you see, the right answer ss really: depends.
<PuercoPop>
pjb: they are referring to the library static-vectors I think
pierpa has joined #lisp
<pjb>
Well, this package uses CFFI, so it would depend strongly on the third depend, I would say.
<pjb>
So the ultimate answer is probably, no.
rozenglass has quit [Ping timeout: 268 seconds]
jack_rabbit is now known as knusbaum
dilated_dinosaur has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
lemonpepper24 has quit [Ping timeout: 276 seconds]
fikka has quit [Ping timeout: 276 seconds]
<jeosol>
anyone encounted this error in emacs+slime: error in process filter: Reply to canceled synchronous eval request tag=slime-result-1869-33542 sexp=(swank:simple-completions "cl-ppcre::g"
dilated_dinosaur has joined #lisp
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
d4ryus has joined #lisp
Demosthenex has quit [Ping timeout: 276 seconds]
megalography has quit [Ping timeout: 244 seconds]
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
Demosthenex has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
fikka has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
Smokitch has quit []
Fare has quit [Ping timeout: 276 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
rumbler31 has joined #lisp
megalography has joined #lisp
rumbler31 has quit [Ping timeout: 248 seconds]
NotSpooky has joined #lisp
smurfrobot has joined #lisp
sabrac has joined #lisp
<sabrac>
Hello everyone
NotSpooky has quit [Ping timeout: 264 seconds]
subroot has quit [Read error: Connection reset by peer]
wigust has joined #lisp
<Demosthenex>
indeed!
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
<jeosol>
Hi Sabrac
patlv has joined #lisp
jfrancis has quit [Ping timeout: 255 seconds]
jfranc___ has quit [Ping timeout: 240 seconds]
runix_1 has quit [Quit: leaving]
jfrancis has joined #lisp
jfrancis_ has joined #lisp
jfrancis has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
random-nick has quit [Ping timeout: 240 seconds]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
Baggers has quit [Remote host closed the connection]
EvW1 has quit [Ping timeout: 256 seconds]
jmercouris has quit [Remote host closed the connection]
BitPuffin has quit [Remote host closed the connection]
patlv has quit [Ping timeout: 244 seconds]
patlv has joined #lisp
NotSpooky has joined #lisp
anewuser has quit [Ping timeout: 240 seconds]
patlv has quit [Ping timeout: 276 seconds]
patlv has joined #lisp
caltelt has joined #lisp
MoziM has joined #lisp
pierpal has quit [Ping timeout: 240 seconds]
anewuser has joined #lisp
graphene has quit [Remote host closed the connection]
graphene has joined #lisp
lemonpepper24 has joined #lisp
jasom has quit [Ping timeout: 265 seconds]
smurfrobot has quit [Remote host closed the connection]
nullniverse has quit [Quit: Undertaking stack overflow prevention]
Kundry_Wag has quit [Ping timeout: 240 seconds]
acolarh has quit [Ping timeout: 276 seconds]
acolarh has joined #lisp
smurfrobot has quit [Remote host closed the connection]
patlv has quit [Ping timeout: 248 seconds]
patlv has joined #lisp
mange has joined #lisp
edgar-rft has quit [Quit: edgar-rft]
<Demosthenex>
ok, so dexador defines a :status slot in it's condition it raises, how can i acces that in my handle-case? kind of hard to get interactive debugging there ;]
anewuser has quit [Ping timeout: 260 seconds]
<PuercoPop>
Demosthenex: The condition's slot should have a :reader so you could do something like (status c) or (slot-value 'status c)
<PuercoPop>
Also you don't need to do an actual http request when testing, you could raise the condition directly while testing your code
Kundry_Wag has joined #lisp
SaganMan has joined #lisp
<PuercoPop>
it apperas the reader is resposne-status
<Demosthenex>
PuercoPop: not a bad idea! i'm thinking that at this time i need to make a more detailed get function to incorporate rate limits and other details without throwing conditions =]
rumbler31 has quit [Ping timeout: 240 seconds]
<sabrac>
PuercoPop: Thank you. Noted.
<Demosthenex>
and for future reference it should be noted that dexador has helpful handler-case examples and handler-bind for build in restarts on their site :P