<black_13_>
or what argument should be given to (ffi:load-foreign-library on a windows machine
Lord_of_Life has quit [Ping timeout: 265 seconds]
Kevslinger has quit [Ping timeout: 265 seconds]
nickenchuggets has quit [Ping timeout: 265 seconds]
Kevslinger_ is now known as Kevslinger
gingerale has quit [Ping timeout: 265 seconds]
pchrist has quit [Ping timeout: 265 seconds]
|3b| has quit [Ping timeout: 265 seconds]
jhei has quit [Ping timeout: 265 seconds]
galdor has quit [Ping timeout: 265 seconds]
jhei_ is now known as jhei
smurfrobot has quit [Ping timeout: 248 seconds]
Arcaelyx has quit [Ping timeout: 265 seconds]
abbe has quit [Ping timeout: 265 seconds]
tazjin has quit [Ping timeout: 265 seconds]
spacedbat has quit [Ping timeout: 265 seconds]
tazjin_ is now known as tazjin
Kundry_Wag has quit [Ping timeout: 256 seconds]
abbe_ has quit [Quit: “Everytime that we are together, it's always estatically palpitating!”]
slyrus1 has quit [Ping timeout: 268 seconds]
Amany has quit [Remote host closed the connection]
Amany has joined #lisp
PuercoPop has joined #lisp
fikka has joined #lisp
pchrist has joined #lisp
gingerale has joined #lisp
Bike has joined #lisp
spacedbat has joined #lisp
billstclair has joined #lisp
danlentz has joined #lisp
Lord_of_Life has joined #lisp
octobanana has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
milanj has joined #lisp
milanj has quit [Read error: Connection reset by peer]
myrkraverk has quit [Ping timeout: 265 seconds]
myrkraverk_ has joined #lisp
bjorkintosh has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
eli_oat has joined #lisp
GNUPONUT[m] has quit [Ping timeout: 245 seconds]
RichardPaulBck[m has quit [Ping timeout: 240 seconds]
remix2000[m] has quit [Ping timeout: 240 seconds]
LdBeth has quit [Ping timeout: 256 seconds]
thorondor[m] has quit [Ping timeout: 260 seconds]
wetha has quit [Ping timeout: 240 seconds]
katco[m] has quit [Ping timeout: 245 seconds]
mhitchman[m] has quit [Ping timeout: 260 seconds]
lyosha[m] has quit [Ping timeout: 255 seconds]
dirb has quit [Ping timeout: 255 seconds]
hiq[m] has quit [Ping timeout: 255 seconds]
spectrumgomas[m] has quit [Ping timeout: 255 seconds]
manila[m] has quit [Ping timeout: 255 seconds]
z3r0d5y[m] has quit [Ping timeout: 255 seconds]
Guest31910 has quit [Ping timeout: 255 seconds]
plll[m] has quit [Ping timeout: 255 seconds]
CharlieBrown has quit [Ping timeout: 255 seconds]
hdurer[m] has quit [Ping timeout: 269 seconds]
equalunique[m] has quit [Ping timeout: 269 seconds]
eatonphil has quit [Ping timeout: 269 seconds]
jach[m] has quit [Ping timeout: 269 seconds]
drunk_foxx[m] has quit [Ping timeout: 256 seconds]
ArthurAGleckler[ has quit [Ping timeout: 256 seconds]
can3p[m] has quit [Ping timeout: 260 seconds]
Jach[m]1 has quit [Ping timeout: 277 seconds]
kumori[m] has quit [Ping timeout: 277 seconds]
theemacsshibe[m] has quit [Ping timeout: 260 seconds]
blep-on-external has quit [Ping timeout: 256 seconds]
kammd[m] has quit [Ping timeout: 255 seconds]
harlequin78[m] has quit [Ping timeout: 276 seconds]
fisxoj has joined #lisp
billstclair is now known as Guest71127
Bike is now known as Guest93038
sveit has joined #lisp
Arcaelyx has joined #lisp
sbryant has quit [Ping timeout: 240 seconds]
reu has joined #lisp
ZombieChicken has joined #lisp
sellout- has quit [Ping timeout: 256 seconds]
bjorkintosh has quit [Quit: Leaving]
sbryant has joined #lisp
sellout- has joined #lisp
mooog has joined #lisp
Guest93038 is now known as Bike
abbe has joined #lisp
surya has joined #lisp
Cthulhux has quit [Ping timeout: 240 seconds]
comborico1611 has quit [Quit: Konversation terminated!]
milanj has quit [Quit: This computer has gone to sleep]
Cthulhux has joined #lisp
megalography has quit [Ping timeout: 248 seconds]
warweasle has quit [Quit: Leaving]
Oladon has joined #lisp
smurfrobot has joined #lisp
LdBeth has joined #lisp
smurfrobot has quit [Ping timeout: 265 seconds]
karlosz has quit [Remote host closed the connection]
igemnace has joined #lisp
Kundry_Wag has joined #lisp
Fare has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
dddddd has quit [Remote host closed the connection]
kammd[m] has joined #lisp
wetha has joined #lisp
spectrumgomas[m] has joined #lisp
GNUPONUT[m] has joined #lisp
remix2000[m] has joined #lisp
theemacsshibe[m] has joined #lisp
katco[m] has joined #lisp
thorondor[m] has joined #lisp
manila[m] has joined #lisp
eatonphil has joined #lisp
jach[m] has joined #lisp
kumori[m] has joined #lisp
hdurer[m] has joined #lisp
hiq[m] has joined #lisp
equalunique[m] has joined #lisp
CharlieBrown has joined #lisp
RichardPaulBck[m has joined #lisp
mhitchman[m] has joined #lisp
plll[m] has joined #lisp
SAL9000 has joined #lisp
lyosha[m] has joined #lisp
harlequin78[m] has joined #lisp
blep-on-external has joined #lisp
z3r0d5y[m] has joined #lisp
Jach[m]1 has joined #lisp
drunk_foxx[m] has joined #lisp
can3p[m] has joined #lisp
ArthurAGleckler[ has joined #lisp
dirb has joined #lisp
jameser has joined #lisp
SAL9000 is now known as Guest10229
sveit has quit [Ping timeout: 265 seconds]
surya has quit [Ping timeout: 265 seconds]
jameser has quit [Max SendQ exceeded]
Prof_Birch has joined #lisp
<Prof_Birch>
Is lisp good for rapid prototyping an application before you are sure of exactly how you want to approach the problem?
<akkad>
Prof_Birch: sure.
d4ryus1 has joined #lisp
<Prof_Birch>
I am hearing it's good for prototyping in a DSL kind of way, but I wasn't sure if it is actually good for prototyping in a general use of the word
black_13_ has quit [Ping timeout: 260 seconds]
sveit has joined #lisp
markong has quit [Ping timeout: 240 seconds]
jameser has joined #lisp
<akkad>
yeah, prototyping in a flexible language, then rewriting in a limited one.
<Prof_Birch>
Yeah that was my plan
<Prof_Birch>
I have ADHD, so it can be a bit hard for me to lay out exactly what I intend to do before hand, even if I have a general or somewhat planned idea
<Prof_Birch>
I *think* lisp could be a good choice for me to lay my ideas out, and play with them to express what I mean before I code it in something like Java
<akkad>
bottom up programming
<Prof_Birch>
Yeah
Cymew has joined #lisp
d4ryus has quit [Ping timeout: 264 seconds]
aindilis` has quit [Remote host closed the connection]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
aindilis has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
sellout- has quit [Ping timeout: 256 seconds]
sellout- has joined #lisp
tomsen has joined #lisp
nickenchuggets has joined #lisp
eli_oat has quit [Quit: Leaving.]
gousuto has quit [Ping timeout: 240 seconds]
robotoad_ has quit [Quit: robotoad_]
moei has quit [Ping timeout: 248 seconds]
sellout- has quit [Ping timeout: 256 seconds]
eli_oat has joined #lisp
moei has joined #lisp
sellout- has joined #lisp
<pierpa>
why do you think you have to recode your prototype in some other language?
<pierpa>
unless there's a customer paying you to deliver something in some other language, I mean.
inoperable has joined #lisp
beginner_supreme has joined #lisp
<Prof_Birch>
I don't think I need to. I've just read its kind of the norm
<pierpa>
hmmm
<Prof_Birch>
I guess I could outright package program
<Prof_Birch>
Hey, I'm here to ask questions and break stereotypes I read online. So feel free to enlighten me
<pierpa>
ok. You don't have to rewrite your lisp program :)
<Prof_Birch>
I assume the answer will be yes, since I'm on the lisp channel, but is it really all that? I hear whispers online, but nobody I know uses it
<pierpa>
nobody you know uses it because it's a niche language
jibanes has quit [Ping timeout: 240 seconds]
<Prof_Birch>
Any particular reason?
<akkad>
this is true for CL
<pierpa>
nobody knows the reasons, unfortunately
<Prof_Birch>
I'm reading a book on CL now. I figured I'd learn Elisp later
<pierpa>
which book?
<Prof_Birch>
Is it really all that magical of a language? Seems kind of mythical
<Prof_Birch>
Practical Common Lisp
<pierpa>
you shouldn't believe *all* the hype
<clintm>
just most of it.
<pierpa>
believe at most 80% of it
<clintm>
lawl
jibanes has joined #lisp
<Prof_Birch>
lol
<akkad>
yeah, it's a language. if you put the features into context of when they were made. it's magial
<clintm>
If you compare it to Rust, it's still magical.
<Prof_Birch>
Well yeah. It's been around for a minute
<akkad>
otherwise, it's a consistent technology
<akkad>
Rust is just good at making me cry to make the compiler happy
<akkad>
seems like a nice target for a compiler backend, but.
<Prof_Birch>
What do you think its lisps best use case is
<akkad>
fun
<akkad>
if you mean as a family of languages. CL might be seen as a little more strictly limited wrt innovation.
<Prof_Birch>
I don't know enough about Lisp to pick a flavor, and elisp didn't seem suited for general programming
<Prof_Birch>
I figured learning the basic syntax would be the place to start, and CL was the dominant one as far as I could tell
<akkad>
don't feel like you need to limit yourself. once you get a lisp down, the rest are much easier to grok typically.
light2yellow has quit [Quit: light2yellow]
<Prof_Birch>
People seem to be pretty die hard about the language though
<beginner_supreme>
I sort of like to look at (and validate my desire to study CL) as being a very very fast python with the freedom to extend it as I want/need.
fikka has quit [Ping timeout: 260 seconds]
<Prof_Birch>
I'm just searching for a language that can help me build programs that are just on the edge of my mind, I can't seem to pin it down but I'll know what it is when I see it
<Prof_Birch>
Although I know that's kind of abstract
<beginner_supreme>
You could do that with any language you are comfortable with
<akkad>
and many lisps can do that.
<Prof_Birch>
It's a bitch in Java
<akkad>
"help me pick a religion" is easier to answer :P
<Prof_Birch>
which is my most comfortable language
<beginner_supreme>
I too dislike java.
tomsen has quit [Ping timeout: 256 seconds]
<aeth>
Prof_Birch: SBCL is gradually typed, if you don't mind relying on the not-entirely-portable behavior of type declarations.
<akkad>
do you get paid for what you dislike?
<Prof_Birch>
I'm not worried about portable. and I barely get paid at all. I'm a bit of a hobby programmer
<akkad>
"Minimum of 15 years of hating java required"
<aeth>
You can prototype in dynamically typed CL and then just add types later.
<akkad>
^^
<akkad>
CL is pretty userfriendly. depending if you know emacs or not
<Prof_Birch>
That's kind of what I've heard in the "prototype in Lisp, rewerite in X" vein
<Prof_Birch>
I know emacs OK, enough to use it as my preferred OS
<beginner_supreme>
Someone in the #clnoobs room showed me how type declarations are not even necessary most of the time. Compilers like SBCL have great type inference.
<beginner_supreme>
It's really amazing when you think about it
<aeth>
beginner_supreme: There are two places where the lack of type inference will hurt your performance: numbers and sequences. This is because there's a kind of generic function (but not defgeneric generic) for numbers and sequences, like + and map
<aeth>
Otherwise the compiler can usually assume that the variable is foo or type error
<beginner_supreme>
Right, but for things like using (elt) instead of (aref) - these are inconsequential as far as I'm aware. elt would just be expanded to an aref if the type is inferred to be an array
al-damiri has quit [Quit: Connection closed for inactivity]
<aeth>
But it probably won't infer the type is an array if you use sequence operations on it and the array is passed in as a variable instead of created within the same function
<beginner_supreme>
Oh I see
<aeth>
Arrays have the added overhead of bounds checking when the dimensions are unknown, but the dimensions can be encoded within the type.
<beginner_supreme>
Thus requiring a type specifier right?
robotoad has joined #lisp
<aeth>
Only if you need performance.
<beginner_supreme>
I'll keep it in mind the day I need the performance. ;]
<Prof_Birch>
someone is telling me to look into haskell instead
<aeth>
It depends on what you want.
<beginner_supreme>
I had that internal debate before too, but decided to stick to CL. It's just easier to work with in my opinion
<Prof_Birch>
I want to take whats on my brain, and put it on my computer
<beginner_supreme>
But everyone has their own style/preferences
<beginner_supreme>
No one knows what's in your brain though
<beginner_supreme>
Only you do
<Prof_Birch>
I'm use to the vim/emacs, perl/python, kde/gnome, wars
<Prof_Birch>
not haskell/lisp
<aeth>
The problem with Haskell is that you have to be inventive to keep purity. CL doesn't care about mutability so you can take your mutable algorithms and data structures with you into CL.
<Prof_Birch>
I know, the problem is I don't always know what I am thinking clearly (Hence ADHD)
<Prof_Birch>
So I need a language equal parts art and function
<beginner_supreme>
Haskell requires placing all your mutability and imperative style into constructs called Monads, which are a bit difficult for most to grok
<beginner_supreme>
But obviosly not impossible
<Prof_Birch>
that I can put down what I am thinking, and tinker. Java and python didn't do that so well. It always ended up with me rewriting my program and making no progress
<Prof_Birch>
I like the idea of perl, but I would also like to go back and read what I wrote at some point
<Prof_Birch>
so I'm keeping that away for now
<beginner_supreme>
In CL, when you are writing something in a spaghetti or repetitive way, you might realize "Oh this... I can write a macro for this... to keep the code size down... and focused on what I want to write."
<pierpa>
you should learn a bit of CL and a bit of haskell, then you decide
nickenchuggets has quit [Ping timeout: 276 seconds]
<aeth>
Perl is for text processing, it doesn't really compete with CL directly.
<Prof_Birch>
I know. I was comparing perl to python
<beginner_supreme>
The unit testing chapter in Practical Common Lisp is an excellent example
<Prof_Birch>
I am working on a Natural language context
<beginner_supreme>
Prolog is also quite good in that context then
eli_oat has quit [Quit: Leaving.]
<beginner_supreme>
Anyways, I need to go. Thanks for the conversation! Till next time.
schoppenhauer has quit [Ping timeout: 256 seconds]
pierpal has quit [Client Quit]
pierpal has joined #lisp
igemnace has joined #lisp
schoppenhauer has joined #lisp
igemnace has quit [Client Quit]
igemnace has joined #lisp
megalography has joined #lisp
Naergon has quit [Ping timeout: 245 seconds]
jfrancis has joined #lisp
jfrancis_ has quit [Ping timeout: 260 seconds]
z3t0 has left #lisp ["Using Circe, the loveliest of all IRC clients"]
pierpal has quit [Read error: Connection reset by peer]
epony has quit [Read error: Connection reset by peer]
Pixel_Outlaw has quit [Quit: Leaving]
Bike has quit [Quit: Lost terminal]
Prof_Birch has quit [Remote host closed the connection]
epony has joined #lisp
karlosz has joined #lisp
aindilis has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<beach>
Good morning everyone!
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
aindilis has joined #lisp
Kundry_Wag has quit [Ping timeout: 248 seconds]
<jeosol>
Morning beach.
<jeosol>
beach in the house
<jeosol>
I take it you are in Europe (further east?). We on the side are packing it up
<beach>
Right.
aindilis has quit [Remote host closed the connection]
aindilis has joined #lisp
alphor has quit [Ping timeout: 256 seconds]
epony has quit [Ping timeout: 268 seconds]
<jeosol>
Nice.
alphor has joined #lisp
manualcrank has quit [Quit: WeeChat 2.1]
<beach>
jeosol: I strongly encourage you to come to ELS next year.
<beach>
Genoa, April 1 and 2.
<beach>
Some people have already booked hotel room it seems.
epony has joined #lisp
pierpal has joined #lisp
shka_ has joined #lisp
froggey has quit [Ping timeout: 245 seconds]
<beach>
jeosol: It is not reserved for Europeans. We have many participants from all over the world. US in particular, but also Japan and some other places.
<jeosol>
I definitely would.
<jeosol>
You mean people have book rooms for that.
<jeosol>
I have finished my challenge code so I am fully in invested in CL for now. I am planning to start presenting my work soon.
<beach>
Usually, you can wait until much later, but this time ELS is held jointly with the <programming> conference, so there will be many people who need rooms.
<jeosol>
I would never have been able to do it without CL. For example, the macro facility was exception and of CLOS which my codes uses a lot.
<beach>
Oh, it's held in a hotel. I should book a room in that hotel.
<jeosol>
also look forward to get jobs where I can hack CL. I almost got one with some US defense guys, but security clearance issues.
<jeosol>
thanks for the link. I will look it up and start making plans. These things go by quickly.
<beach>
I suggest you go work for Ravenpack in Marbella.
<beach>
They are hiring, and Marbella is a great place anyway.
<jeosol>
But then, I will need EU work visa right? I will be in Barcelona for the Challenge conference, so I may try to see if I can visit them.
<beach>
Plus, it's in the EU, so life is much better than in the US.
<beach>
There is no problem getting a work visa for the EU.
<beach>
Yes, go visit them. That's a good idea.
<jeosol>
Really, no problem for work visas for foreigners?
<beach>
Not if you have a job offer. In fact, most companies will do the paper work for you.
fikka has quit [Ping timeout: 260 seconds]
<jeosol>
That's actually very nice
<rme>
I understand that Spain can be rather troublesome, but why not talk to RavenPack anyway?
<beach>
jeosol: I know of at least 5 US-of-Asians who, once installed in the EU never looked back.
<beach>
rme: Troublesome how?
terpri has joined #lisp
<rme>
In the visa and immigration area, I mean.
<beach>
jeosol: Actually, many more than that, now that I think about it.
<beach>
rme: Oh? That would be very surprising. Sure, if you are an unskilled person from Africa, I can imagine a few obstacles, but if you have an offer of a skilled job, I don't see the problem. But maybe you know better than I do.
<jeosol>
This is why I was suprised. Over here it's a nightmare.
<beach>
jeosol: Well, I suggest you follow rme's advice and go talk to them.
<jeosol>
If I get there for the conference, I will definitely visit them.
<jeosol>
thanks beach, rme
<beach>
Anytime.
<beach>
rme: Speaking of which, did you ever make a final decision?
<rme>
Their recruiter is @MMonteroZ on Twitter if you want an initial point of contact.
<jeosol>
I normally joke that "blessed is S/he who hacks lisp for a living ...". There are a few companies there have adverstise and look for CL as part of their stack, but then they want other languages too JS, Java,...
<jeosol>
that's good actually. I will start developing some contact. Conference is in September
<aeth>
jeosol: If you have European ancestors you might actually be able to get European citizenship. Depends on the country. Italy is the easiest.
<jeosol>
How far back are we talking, time of Adam and Eve, lol
<rme>
beach: I can't quite make a move to Bordeaux (or anywhere in France) work out just on my own. I'm talking to some potential employers, though.
<beach>
rme: What about the job offer that would make you stay? Did it happen?
<beach>
jeosol: The great advantage of going to ELS is that you will be able to put a face on many of the #lisp participants.
<aeth>
Personally, I think I could get Italian (1/4) or Hungarian (1/16??) citizenship if I tried. For the latter I would have to learn Hungarian, though.
<beach>
jeosol: There are usually nearly 100 people coming to ELS every year.
fikka has joined #lisp
<rme>
beach: No, she didn't pursue the full-time faculty position after all.
<beach>
rme: Great! (so to speak)
<rme>
:-)
fiddlerwoaroof has joined #lisp
<fiddlerwoaroof>
Is anyone else having issues with slime on emacs 26?
<jeosol>
beach: yes, good point. Nothing like meeting people and discussing in person and finding common grounds and collaborative projects.
<beach>
jeosol: Exactly!
<jeosol>
I did plan to come this here, write my paper on building a very large project/application with CL.
fikka has quit [Ping timeout: 256 seconds]
<jeosol>
when I started, my code was barely running stable, issues, but after questions here and comp.lang.lisp, it is running smoothly, and runs for days and weeks without issues now.
<jeosol>
beach: on the conference bit, I think the collaboration is something that would be useful. For example, I have talked about picking up CLML for machine learning/AI but waiting to sort out the licence issues and get a go-ahead
eudoxia has joined #lisp
<aeth>
jeosol: what kind of large application?
<aeth>
And how many LoC?
fikka has joined #lisp
<beach>
jeosol: Sure, you can give a few lightning talks and see if someone is interested.
<jeosol>
Last time I check, around january, 210k
<aeth>
wow
<aeth>
I cannot easily break 10k. Every time it looks like I might get close, a new macro pops up.
<jeosol>
There are a few reasons for the productivity, lisp being one of them. I type fast, and because I can reach any file and function from within emacs, all those things help. Also, my code is essentially a document because I use long
<jeosol>
variable names which my be hard for many. The variable names and function names convey meanings. So with the code reading like a document, it was much easier to write along.
<jeosol>
I won't recommend writing it the way I did, I was also writing to code as a hobby (April 2016), then a challenge came up Feb 2017, so I decided to make the code be able to solve that challenge. Deadling was a month ago.
<jeosol>
But I must say, I have enjoyed working on the project and can't imagine if I can get to code CL and get paid for it. hmmm
<jeosol>
There are some defence projects here with the companies using CL
<jeosol>
but one thing I would say is that, my code quality gets better with time. When I learnt the basic things I needed, I just started writing and replacing code as I go forward and using better idioms, or techniques to improve efficiency. But my focus was
<jeosol>
on the application side mostly.
<aeth>
What is the application?
<jeosol>
aeth: very good question.
<jeosol>
I would say it is a platform because the code base contains optimization engine, statistics, proxies. So application area is for optimization problems where scare resource have to be allocated to maximize some objective function.
makomo has joined #lisp
Tristam has quit [Ping timeout: 256 seconds]
<jeosol>
A presentation may be able to help explain things better. Hence beach suggestion to come to ELS
edgar-rft has quit [Quit: edgar-rft]
<jeosol>
beach: jmercoursis here did say he is interested in the machine learning work.
<jeosol>
I was hoping to reproduce some examples using CLML library and make changes to the code if necessary. I am trying to resolve with the library owners to avoid any issues.
karlosz has quit [Quit: karlosz]
shachaf has joined #lisp
<shachaf>
Is there something in Lisp which is like progn, but where each statement can be a sort of macro that acts on the rest of the block?
<aeth>
what are you trying to do?
<makomo>
morning
<makomo>
shachaf: something to avoid nesting?
<shachaf>
I'm thinking about a language feature for a different language. But I thought maybe Lisp people would've thought about something like this.
<makomo>
what does it mean "but where each statement ... acts on the rest of the block" though
<shachaf>
Yes, roughly. This is kind of like continuation-passing style, I suppose.
<shachaf>
And I suppose also to continuation-passing style, or first-class continuations in languages that have them.
<makomo>
shachaf: you might want to look at the implementation of contiuations in On Lisp. i don't know how complete it is, but it could come in handy as an example
<makomo>
continuations*
<makomo>
shachaf: these monad macros are interesting, cool
golden_ratio has quit [Quit: Leaving]
eudoxia has quit [Ping timeout: 248 seconds]
<shachaf>
But continuations are opaque functions and I'm curious about applications that do more syntactical macro-style things.
fikka has quit [Ping timeout: 248 seconds]
Autolycus has joined #lisp
smurfrobot has joined #lisp
fikka has joined #lisp
<aeth>
You could try looking at various utility libraries to see if any do something similar to what you're talking about
<shachaf>
(And also I'm thinking about this in the context of some sort of low-level language that doesn't have closures.)
Cymew has joined #lisp
vlatkoB has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
flamebeard has joined #lisp
nickenchuggets has quit [Read error: Connection reset by peer]
Kevslinger has quit [Quit: Connection closed for inactivity]
<fiddlerwoaroof>
shachaf: you might look at f-exprs in the kernel language, among other places
<fiddlerwoaroof>
I'm not sure if they are directly relevant :)
smurfrobot has quit [Remote host closed the connection]
<fiddlerwoaroof>
Anyways, has anyone used SLIME with emacs 26?
damke has joined #lisp
priyadarshan has joined #lisp
damke_ has quit [Ping timeout: 244 seconds]
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Poorbean has joined #lisp
Poorbean has left #lisp [#lisp]
<jlarocco>
no, but that reminds me that I was going to upgrade emacs today
<xificurC>
I'm reading LOL and gained a yet again little bit better understanding of lexical and dynamic bindings and closures. However I'm failing to understand one example the author gives: he says this doesn't create a new lexical closure: (let ((temp-special 'whatever)) (lambda () temp-special)). Note that temp-special was defvar'd before, i.e. made speci
<xificurC>
al
xaotuk has joined #lisp
daniel-s has joined #lisp
<xificurC>
so if it doesn't create a lexical closure I would expect this to clobber the variable: (defvar *x* 1) (loop for i from 1 to 10000 do (sb-thread:make-thread (lambda () (let ((*x* 10)) (incf *x*)))))
<White_Flame>
the standard says that dynamic bindings are scoped to a function and everything it calls, which is necessarily thread-local on all implementations I've seen
<beach>
jmercouris: LET does not shadow a special variable. It binds it.
<White_Flame>
erm, scoped to a lexical scope and everything it calls
<jmercouris>
beach: whoops :D
<xificurC>
LOL says a let that captures a special variable doesn't create a lexical closure
<beach>
xificurC: It doesn't clobber the global value of the variable, because you bind it before incrementing it.
<White_Flame>
LET can do either
<xificurC>
doesn't say what does it create though, or I didn't get it from what is written
<beach>
xificurC: ff will print 1, proving that the binding of *x* is not specific to gg.
<White_Flame>
a common machine code implementation is that when looking up the value of a special variable, first it checks the threadlocal table. If there's no binding there, it checks the global symbol-value of the symbol
EvW1 has quit [Ping timeout: 268 seconds]
Firedancer has joined #lisp
<White_Flame>
and again, that choice is compile-time, depending on whether or not the referred variable is/was declared special or not
<xificurC>
ok, so in (defparameter *x* 0) (let ((*x* 100)) CODE-HERE) everyone using *x* at runtime will see the leted value, which is what dynamic binding is all about. The threading version works because specials can also be in a thread-local storage
<beach>
xificurC: No, not everyone. Only the functions that are called by CODE-HERE.
<beach>
xificurC: Not functions running in a different thread.
<xificurC>
beach: that's what I meant to write
AetherWind has joined #lisp
<xificurC>
I still don't understand the sentence "the standard says that dynamic bindings are scoped to a function and everything it calls" though
<White_Flame>
(progn (let ((*x* 100)) ...*x* is seen as 100 here and in called functions...) ...*x* is back to normal)
<White_Flame>
I corrected myself
<White_Flame>
they're scoped to the lexical scope of the binding, and anything it calls
<White_Flame>
(let ((*print-circle* nil)) (format t ...)) will cause FORMAT to see a new value of *print-circle*, for instance, but any other thread won't, nor will anything in the current thread outside the LET
<White_Flame>
specifically, outside the dynamic extend of LET, ie when it's active on the call stack and hasn't exited yet
<xificurC>
White_Flame: so the standard requires specials to be thread safe this way
<White_Flame>
it doesn't mention threads
<White_Flame>
but the implication pretty much requires thread locality
<xificurC>
White_Flame: ah so I can imagine "if it's not on your call stack you can't see it"?
<White_Flame>
a binding is basically entered & exited
<beach>
xificurC: Yes, you can say that.
<White_Flame>
if a special binding has entered, then everything in the thread will see that new binding (unless another inner binding overrode it)
<White_Flame>
once it exits, it's gone
<xificurC>
that makes me click
<xificurC>
thanks beach and White_Flame
<beach>
Anytime.
<White_Flame>
np
<xificurC>
so I can expect e.g. ABCL to supply the same guarantees on the JVM
<White_Flame>
I'm trying to find the CLHS page that describes dynamic bindings
Kundry_Wag has joined #lisp
<beach>
xificurC: I know of no Common Lisp implementation that does it differently with respect to threads. Without threads, it is standardized behavior.
<shka>
honestly, what else reasonable man can do?
<xificurC>
beach: what other implications are there from this requirement? You're saying threads aren't mentioned but I don't see what else benefits from this behavior
<beach>
xificurC: As White_Flame pointed out, you can alter the behavior of things like FORMAT without passing an argument to them.
<shka>
standard output has dynamic binding
<xificurC>
beach: yes but if the binding wasn't thread-local it would still apply the same way
<shka>
same as trace binding
<beach>
xificurC: yes, but if the binding were a lexical binding, it would not behave that way.
<shka>
xificurC: thing is, new thread is a new stack
<shka>
and dynamic binding is connected to stack
<White_Flame>
" The effect of binding a dynamic variable is to create a new binding to which all references to that dynamic variable in any program refer for the duration of the evaluation of the form that creates the dynamic binding. "
<shka>
White_Flame: lol, very helpful
<White_Flame>
that sentence might imply trampling across threads, though
<White_Flame>
:)
<xificurC>
beach: yes that's the point of dynamic binding, I get that. I'm asking what other benefits are there from the fact that the binding is connected to the stack
<shka>
xificurC: it is very convinient when you want, for instance, redirect trace to file
<xificurC>
if it was altered in a global table that is shared across threads you would still have the same behavior with the FORMAT example
Kundry_Wag has quit [Ping timeout: 240 seconds]
<White_Flame>
xificurC: and in non-threaded implementations, that's exactly what happens
<shka>
so let's assume that you have this one function that you find interesting
<shka>
you can wrap call to it with let to establish new binding for trace output
damke has joined #lisp
<xificurC>
White_Flame: so the standard doesn't mention threads but the requirements it imposes necessitate thread locality. And I don't see what other benefits are there from those requirements, i.e. why aren't threads mentioned
<shka>
then you can call your top level function, but part of trace will land in your file
<shka>
and you don't have to pass extra arguments or anything
<White_Flame>
what do you mean by "benefits"?
<White_Flame>
and threads aren't mentioned because they basically weren't invented at the time that the tech they were consolidating was created.
<shka>
xificurC: because there are no threads in CL standard
<beach>
xificurC: You are right. There are no other benefits to special variables than the fact that they allow dynamic bindings and that this is a unique property of Common Lisp.
smurfrobot has quit [Remote host closed the connection]
damke_ has quit [Ping timeout: 244 seconds]
<xificurC>
White_Flame: thread locality
<beach>
xificurC: A few minutes ago, you did not understand the mechanism of dynamic binding, so it is natural that we try to check that you now do.
<White_Flame>
the main benefit of special variables is side-band context, either global or scoped
orivej has quit [Ping timeout: 240 seconds]
<xificurC>
beach: I imagined it to work *not* thread safe, e.g. with a shared global table. But my test in sbcl proved me wrong
aindilis has quit [Ping timeout: 256 seconds]
<xificurC>
and the book didn't explain where is the leted binding kept
igemnace has quit [Read error: Connection reset by peer]
<xificurC>
if the answer is "in a thread local table" then I understand
<White_Flame>
well, there are multiple implementation strategies
<beach>
xificurC: You also imagined something else, i.e. that (let ((*x* 1)) (incf x)) would alter the global value of *x*, which is not the case.
schjetne has quit [Remote host closed the connection]
<beach>
er, (incf *x*)
<xificurC>
beach: no, I knew that doesn't clobber
schjetne has joined #lisp
<beach>
Now you do, but before you said you didn't.
<beach>
So we are just making sure that you understand the benefits of special variables, even when there are no threads involved.
<xificurC>
I just imagined it to be something like (setf tmp *x*) (setf *x* 1) (incf *x*) (setf *x* tmp)
<beach>
But yes, those benefits are the only ones if there are no threads involved.
<xificurC>
pardon the stupid pseudo code :)
xrash has quit [Ping timeout: 276 seconds]
<White_Flame>
or (let ((old-x *x*)) (setf *x* 1) (incf *x*) (setf *x* old-x)) to be a little more idiomatic
<xificurC>
I think I still didn't make the last question clear
<shka>
xificurC: essentially, each new binding to special variable shadows old binding for everything that comes after it on stack
<White_Flame>
it's good style to only have variables exist for the scope where they're used
gravicappa has joined #lisp
<beach>
xificurC: Yes, and that won't work if there is an error and a non-local transfer between the save and restore.
<beach>
xificurC: Dynamic bindings are guaranteed to be undone in case of a non-local transfer of control out of the dynamic scope.
<xificurC>
I already understood and used the benefits of specials. I didn't understand why a let over it is thread safe.
<xificurC>
You guys said the standard requires it to behave in a way which is basically always implemented in a thread safe manner.
<beach>
Fine.
<White_Flame>
because "for the duration of the evaluation of the form that creates the dynamic binding" is interpreted that way
<xificurC>
I was asking if there are other benefits from those requirements
<beach>
No, none.
<xificurC>
just from those that are actually making it thread safe
<beach>
None whatsoever.
<xificurC>
:(
<xificurC>
was hoping for more :)
<White_Flame>
the benefit is side-band contextual data, either global or scoped
<shka>
xificurC: it is just the only reasonable way to do it
<beach>
I can tell, yes.
<White_Flame>
and scopes happen to be thread-local, by interpretation of that "during" description
<beach>
White_Flame: xificurC is looking for MORE benefits.
<beach>
There are none. Zip, nada.
<White_Flame>
right, and that wording puzzles me
<White_Flame>
it's a spec, it defines a particular tool
<xificurC>
CL has many benefits, give me MORE
<beach>
As usual, the Common Lisp HyperSpec falls short of people's expectations.
<White_Flame>
it has tools
<White_Flame>
tricks & techniques turn tools into benefits
<White_Flame>
that's what hacking is
<White_Flame>
and to a lesser extent, that's what engineering is
<xificurC>
ah, "for the duration" means it has to be true when exiting as well
<shka>
xificurC: simple concepts have often profound consequences
<xificurC>
more clicks
<beach>
xificurC: I thought you understood that already.
<xificurC>
beach: I did, just not the spec's wording
<xificurC>
I was thinking "if I were to implement CL and read that line would the thread-safetiness be clear to me from that sentence?"
<White_Flame>
I think it could be done either way and technically comply
<White_Flame>
but thread-local is more useful
<beach>
xificurC: It's the only sane way of doing it. Otherwise, a thread could not count on the value of its own variables.
<White_Flame>
because the actual "time during which ... a binding ... is defined" is technically global, but unpredictable outside a thread
<White_Flame>
(that's from the definition of "extent")
<beach>
xificurC: (let ((*x* 1)) <no guarantee what *x* is here>
<xificurC>
do you guys like LOL? Do you agree with it?
emacsomancer has quit [Ping timeout: 256 seconds]
<White_Flame>
Land of Lisp, or Let Over Lambda?
<xificurC>
let over lambda
<beach>
xificurC: (let ((*x* 1)) <no guarantee what *x* is here>) I mean.
<beach>
xificurC: That would be surprising, now wouldn't it?
<White_Flame>
I think LOL is an interesting exercise, but I don't like the data-hiding of the way it uses closures
<White_Flame>
it's certainly full of concepts you should learn & comprehend well
<xificurC>
beach: yes but you really have to think of threads to get a surprising effect from it when keeping it in a global table
Lord_of_Life has quit [Changing host]
Lord_of_Life has joined #lisp
Lord_of_Life has joined #lisp
<White_Flame>
a dynamic binding in a single threaded environment has well-defined boundaries. a global-trampling dynamic binding in a multithreaded environment loses those well-defined boundaries, while thread-local retains them
<xificurC>
White_Flame: isn't the way he uses closures the most important thing to him? :)
<White_Flame>
yes, but it also means you can't change them at runtime easily, which is very non-lispy
<White_Flame>
ie, if you create an object whose implementations are lambdas floating in hidden closure variables, then redefine the functions in the source code, the existing objects will nto be updated. If they were plain DEFUNs or DEFMETHODs, then the source code could change the behavior dynamically
<xificurC>
depends on the hooks you leave, right
<beach>
xificurC: In many respects, standard objects are strictly more general that closures, at least for SICP-style data hiding.
<jmercouris>
beach: SICP?
<beach>
xificurC: Since CLOS is so powerful, it is usually better to use standard objects than closures for data hiding.
<beach>
jmercouris: Structure and Interpretation of Computer Programs.
<beach>
A book.
<White_Flame>
it's usually better not to do data hiding, too :-P
<jmercouris>
I googled it, but I still don't understand what you mean
<jmercouris>
White_Flame: isn't data hiding the whole premise of OOP?
<White_Flame>
yes, and it's a bad one ;)
<beach>
jmercouris: They use closures to emulate object-oriented programming.
<shka>
nooooooooo
<shka>
jmercouris: OOP is about messaging
<jmercouris>
beach: that sounds like a terrible idea, but I haven't done it, so I can't be sure
<jmercouris>
shka: messaging for the purpose of...? encapsulation!
<beach>
shka: It is not. Only in single-dispatch languages.
<White_Flame>
bad for debugging & development, in particular. You should still use well-defined interfaces and not just directly trample data, but explicitly barring ALL access is counterproductive in an interactive environment
<beach>
White_Flame: I totally agree.
<White_Flame>
having to pollute all your objects with logging functions, for instance, is a massive ugly nuisance, as opposed to letting your logger peek in as deeply as it needs to
<jmercouris>
even in OOP languages that have private members, they usually allow introspection and reflection
<jmercouris>
so it not generally a problem what you are saying
<shka>
beach: so data hiding?
<xificurC>
but the world is a hostile place and the devs will try to kill your objects, you have to encapsulate!!! /s
<White_Flame>
if you're using C++, then language itself is trying to kill your objects!
<shka>
White_Flame: actually, not
* White_Flame
ROPs shka into saying what I want
<shka>
if you are using C++, language is trying to kill YOU
<shka>
by triggering heart attack
<jmercouris>
shka: what are you talking about?
<makomo>
it only blows your foot off :^)
<White_Flame>
death by template error report
<shka>
templates: not worth it(tm)
<xificurC>
I always imagine the CL mascot from land of lisp just watching the programmers, year after year, implementing half-assed versions of what already exists for 50 years, scratching its head thinking just wtf is going on in other people's minds
<White_Flame>
is the mascot now named Greenspun? ;)
<jmercouris>
xificurC: please, let us not take a stroll down eltisim lane
<makomo>
White_Flame: i see your point about LoL. how would you for example "solve" the following problem: i had an object that you could (un)register callbacks with, and it would call these functions when a particular thing happened. the callbacks were taken as function objects.
<xificurC>
jmercouris: can the mascot at least be elitist?
<White_Flame>
makomo: that's explicitly managed state, which is fine to store somewhere
<jmercouris>
xificurC: I think it already is, it is this alien eye guy, at least unofficially
<makomo>
White_Flame: now, when you pass in a function into this registration, such as #'SOMETHING, and later on redefine SOMETHING, you're still left with the old version of SOMETHING attached to your object
<shka>
lisp alien should have name, btw
uberman has joined #lisp
<White_Flame>
makomo: but I woudl probably define a struct or defvar to hold it (depending on scope) instead of just closuring it
<makomo>
White_Flame: since i wanted the benefit of interactivity/redefinition, i went with storing a symbol and then looking up it's symbol-function :D
<White_Flame>
makomo: right, because that's a _configured data object_, not just default class-style code
<makomo>
but i don't think that's pretty at all
<White_Flame>
and yeah, symbols are the right way to do it if you want global redefinition of all instances to be possible
<makomo>
White_Flame: hm right, so it's not really a problem then, because you explictily did it that way
<makomo>
White_Flame: ah ok then, i feel a bit better :D
<jmercouris>
is there a way for quicklisp to show non-lisp dependencies?
<xificurC>
White_Flame spreading sunshine
<jmercouris>
e.g. if a particular lib depends on gcc, is there a way to show that?
smurfrobot has joined #lisp
<jmercouris>
when I say lib, I mean system
<White_Flame>
xificurC: /me stamping out wrongness, more like ;)
<makomo>
but i think LoL is a great book. it's an awesome lesson in macrology and a good brain strecher :-)
z3t0 has joined #lisp
<makomo>
xificurC: did you read the whole book?
* White_Flame
goes afk
<xificurC>
I didn't know e.g. that lambda isn't a special form
<shka>
LOL is not good introduction to lisp
<xificurC>
makomo: I did a few years back but I didn't understand all of it. Reading it now (1/3 in maybe) and getting more from it
<xificurC>
shka: LOL is also *extremely* elitist :)
<makomo>
shka: well of course
<makomo>
xificurC: also true :-)
<makomo>
but it's fun to read hah
<shka>
that is it's flaw
<shka>
elitism is stupid
<xificurC>
the whole book reeks of it
<xificurC>
I don't enjoy that either, but I guess I can still learn something from it
uberman has quit [Quit: Leaving]
<jmercouris>
you can learn how not to be
ebrasca` is now known as ebrasca
<xificurC>
I remember when I was reading it the first time someone here complained that defmacro! isn't safe when called in a nested fashion
<makomo>
xificurC: yeah, it's not portable
igemnace has joined #lisp
<makomo>
since it does codewalking
<makomo>
which breaks on, for example, sbcl's backquote implementation
<xificurC>
codewalking isn't portable?
fikka has quit [Ping timeout: 256 seconds]
<makomo>
nope :^(
<xificurC>
example?
<makomo>
really sad imo, but there's a project called Agnostic Lizard by Michael Rasking
<shka>
xificurC: code walking is just something you should avoid
<makomo>
there's a talk and a gitlab repo
<makomo>
xificurC: for example, sbcl processes the comma inside a backquote as a STRUCT i think
<makomo>
it's a special STRUCT coming from the internals of SBCL
<makomo>
the expression the comma is evaluating in embedded into this struct
<makomo>
so codewalking the thing will give you a struct which is an atom (and also not a symbol)
<makomo>
instead of giving you something like a list of the form (COMMA ...expr...)
<makomo>
so the definition of defmacro! and defmacro!/g just skip over the atom
<makomo>
i.e. over the struct
<makomo>
and don't take into consideration the symbols within the comma struct
<makomo>
xificurC: Michael Raskin*
<jmercouris>
cffi not working on freebsd, I installed gcc via pkg, any suggestions?
aindilis has joined #lisp
<makomo>
the project aims towards a portable codewalker, but "portable" in the sense of using heuristics/specializing for different implementations, i think
<makomo>
shka: why though?
<makomo>
WITH-SLOTS also does codewalking
<shka>
makomo: it does not
<makomo>
i'm pretty sure it does
<shka>
well, you are wrong
<makomo>
aside from using a symbol-macrolet, it also changes every SETQ to a SETF
<shka>
setf expands to setq on it's own
<makomo>
no, i mean something like this
<makomo>
(with-slots (a b c) obj (setq a 12))
<makomo>
this will set the slot A of the object
<makomo>
but you used SETQ instead of SETF
siraben has joined #lisp
<makomo>
it needs to use a coderwalker to do this
<makomo>
codewalker*
<jmercouris>
anyone have experience with using fastcgi and caveman2?
<makomo>
xificurC: the stuff on anaphoric and pandoric macros was amazing as well
<makomo>
and also the sorting networks chapter, that was also beautiful :-)
<makomo>
are you sure os-cond is defined? can you M-. on it?
<jmercouris>
I'm not in emacs
TCZ has joined #lisp
<jmercouris>
maybe this is actually an asdf issue then
<makomo>
my idea was that the errors you got are because OS-COND wasn't defined as a macro or something
<makomo>
i.e. it's trynig to evaluate its arguments
<makomo>
or maybe the OS-COND expansion is wrong, but somehow i doubt that
<makomo>
trying*
<jmercouris>
right, I see
<jmercouris>
let me first finish the reinstall of GCC, just because
<jmercouris>
and then I'll investigate that
<jmercouris>
and then finally I'll give up and use Linux on the server..
<makomo>
haha
<TMA>
jmercouris: sbcl 1.2.7's asdf is probably too old
<jmercouris>
TMA: how does one upgrade asdf? can you quickload it?
AetherWind has quit [Quit: Leaving]
<jackdaniel>
first you load asdf, then you load quicklisp
<jackdaniel>
downlaod prefered asdf (if you use sources, make will produce asdf.lisp file), and call (load (compile-file "asdf.lisp")) before quicklisp/setup.lisp is called
<shka>
sbcl specific question
<shka>
let's say i want to ensure that instance of class has slots of the right types
<jackdaniel>
QL first checks, if ASDF is already loaded (if so, it does nothing), after that it calls (require 'asdf) (that gives you asdf bundled with implementation). if this yields nothing (errors that module is not found), it loads asdf 2.26 which is bundled with quicklisp as a fallback
<shka>
sbcl can check that if i set safety to 2 or 3
<shka>
is it sufficient to wrap defclass in optimize for safety 3 in order to ensure that i won't get the wrong type?
<jackdaniel>
did you try it? (it is sufficient for sbcl, yes)
jameser has joined #lisp
<White_Flame>
I would think it is highly dependent on when/where CLOS dispatch is recompiled, and if slot accessors are inlined somehow
<White_Flame>
but in practice, yeah
jameser has quit [Client Quit]
<shka>
ok, thanks guys
<shka>
one more question though
<shka>
i am doing it right now by (let () (declare...) (defclass...))
<shrdlu68>
His assertion is that it is not possible to handle heap exhaustion in Lisp, among other languages he mentions, and thus "it is impossible to write perfect software in these languages">
<jmercouris>
what does it mean to write "perfect software"? of course it is possible to prove lisp programs
LiamH has joined #lisp
<shrdlu68>
He's wrong, right? One can handle memory errors in Lisp?
<jackdaniel>
perfect software is the software which meets criteria subjectively chosen by the person who presents the topic ;)
<jmercouris>
He is wrong, yes
<jackdaniel>
shrdlu68: in principle yes, implementation may raise a condition (and they often do)
<jackdaniel>
it may be a serious-condition which you may handle in handler-case
<jmercouris>
don't waste your time watching this person's video
<jmercouris>
better usage of your time might be reading about how to prove programs, and the set of languages that exist for proving programs/algorithms
<jmercouris>
of course, they have not lived up to the hype, but they are still interesting ideas
matijja has quit [Read error: Connection reset by peer]
<shrdlu68>
His argument is, that function will always return the correct output for the correct input - there won't be malloc errors, etc.
<jmercouris>
that argument has absolutely no merit
<jmercouris>
just because a program has state or memory does not mean that it cannot be proven
<shrdlu68>
jmercouris: He hasn't mentioned formal verification thus far.
<shrdlu68>
jmercouris: I'm afraid I'm not quite presenting his arguments well.
<jackdaniel>
that reminds me a discussion whenever CL allows arbitrary big integers or the physical computer limitation counts here and CL can't have arbitrary big integers
sz0 has quit [Quit: Connection closed for inactivity]
<shrdlu68>
If one attempted to add two large bignums on a system that's running out of memory, what exception would a lisp implementation raise?
<jmercouris>
shrdlu68: you might find this very interesting: http://uppaal.org
<_death>
it's like saying 1+1=2 is false because some gamma ray flipped a bit.. different levels of reality
<shrdlu68>
_death: He does say cosmis rays and hardware errors are out of scope...
pierpal has quit [Ping timeout: 276 seconds]
Bike has joined #lisp
<jackdaniel>
shrdlu68: ECL will report ext:storage-exhausted
<jmercouris>
well, that settles it
<jmercouris>
ECL is perfect, let's pack up boys
<jmercouris>
:D
<jackdaniel>
which is a condition inheriting from storage-condition, which inherits from serious-condition
<_death>
what about wetware errors
<jackdaniel>
(which does not inherit from error btw)
<jackdaniel>
my point is that it is implementation-dependent
<jackdaniel>
but you will probably get a condition on such situation
<jmercouris>
ah, but since it is not in the CLHS, may we say that CL is "non-perfect"?
Arcaelyx has quit [Ping timeout: 260 seconds]
wheelsucker has joined #lisp
<jackdaniel>
jmercouris: you may say whatever you want – that doesn't mean people will understand you
_cosmonaut_ has joined #lisp
<jmercouris>
jackdaniel: I am asking, IF we can agree that this condition is not defined in the CLHS and it results in undefined behavior, based on that youtuber's definition, can we say that CL is "non-perfect"?
lumm has quit [Quit: lumm]
slyrus1 has joined #lisp
<jackdaniel>
even without that we may say that
<jackdaniel>
give me "perfection" criteria
<jmercouris>
jackdaniel: yeah, the perfection crtieria is that one guy's perfection criteria, not myo wn
<jmercouris>
s/myo wn/my own
<jmercouris>
I think my sentence is pretty clear, though I also understand the point your making, "what is perfection"
<jackdaniel>
if it is: doesn't have threads in the specification, CL is not perfect. if it is: doesn't have defined behavior for memory exhaustion in the spec, CL is not perfect. ;) fwiw he was talking about a perfect software, not a perfect language (judging from the screenshot)
hhdave has joined #lisp
pierpal has joined #lisp
<shka>
'allocation of slot' does not sound like value of slot-definition-type
<jackdaniel>
shka: ↑ here you don't have this typo
<p_l>
sometimes it's in the spec, but not practically implemented (C on Linux)
EvW has quit [Remote host closed the connection]
<jackdaniel>
having elaborate condition system certainly helps to get it "right"
EvW has joined #lisp
Arcaelyx has joined #lisp
lumm has joined #lisp
<p_l>
until it's pulled from under you externally, like typical case for C program on Linux, or the essentially equivalent case of people disabling GC on early LispMs
<shka>
jackdaniel: thanks, it got me confused
<jackdaniel>
p_l: I don't know about other implementations, but ECL has preallocated memory for reporting memory conditions
<jackdaniel>
so it does not allocate anything in order to signal them
<p_l>
jackdaniel: well, it's *ECL*, not "le random C/C++ crap written on and tested on only on Linux" ;)
warweasle has joined #lisp
__rumbler31 has joined #lisp
_cosmonaut_ has quit [Ping timeout: 260 seconds]
jmercouris has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
aindilis has quit [Remote host closed the connection]
gravicappa has quit [Ping timeout: 240 seconds]
aindilis has joined #lisp
kami has joined #lisp
<kami>
Hello #lisp
<skeuomorf>
hello kami
TCZ has quit [Quit: Leaving]
Guest10566 has quit [Remote host closed the connection]
mindCrime has quit [Ping timeout: 268 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
kajo has quit [Ping timeout: 260 seconds]
<Younder>
p_l: le random C++ crap ;)
matijja has joined #lisp
panji has joined #lisp
shrdlu68 has quit [Ping timeout: 248 seconds]
siraben has joined #lisp
shrdlu68 has joined #lisp
oleo has joined #lisp
oleo is now known as Guest65252
kajo has joined #lisp
vindarel has joined #lisp
Libre has joined #lisp
ebrasca has left #lisp ["ERC (IRC client for Emacs 25.2.1)"]
DataLinkDroid has quit [Ping timeout: 240 seconds]
jmercouris has joined #lisp
eudoxia has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
vtomole has joined #lisp
heisig has quit [Quit: Leaving]
Kundry_Wag has quit [Remote host closed the connection]
kmurphy4_ has joined #lisp
Kundry_Wag has joined #lisp
smurfrobot has joined #lisp
Tristam has quit [Ping timeout: 248 seconds]
<vindarel>
Hello (common) lispers, little question on capturing standard output. I know with-output-to-string, but this doesn't suit my need because I'd like to return the string immediately, to not break the printing of the application. I'd like something like a defadvice, but this doesn't exist in SBCL. Do you think of something ? thx
skeuomorf has quit [Ping timeout: 240 seconds]
<Bike>
do you mean that you want to print to standard output but also capture it in a string?
Kundry_Wag has quit [Read error: Connection reset by peer]
Guest65252 has quit [Changing host]
Guest65252 has joined #lisp
Kundry_Wag has joined #lisp
Guest65252 is now known as golden_rule
Sonny__ has left #lisp [#lisp]
<vindarel>
Actually I don't care to capture to a string, I'd like to change it before it is printed (to highlight stuff).
Sonny__ has joined #lisp
sjl has quit [Quit: WeeChat 2.1]
<Younder>
a read macro then
smurfrobot has quit [Ping timeout: 255 seconds]
Tristam has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<vindarel>
A reader macro ? I'd like to change output from third party code, that won't use the reader macro.
<dlowe>
vindarel: there's no simple mechanism for doing what you want to do.
<dlowe>
You could set *standard-output* to an echo-stream, then use a thread for reading from that echo-stream and writing your changed version to standard output.
<vindarel>
Well ok thanks, this is what I needed to know. I'll re-think my programmatic interface then.
<vindarel>
thanks for the pointers.
<dlowe>
You could also use the gray streams extension, which would allow you to make a different kind of stream
<dlowe>
one that highlights and passes through to a wrapped stream
<beach>
black_13: I strongly recommend you program in Common Lisp instead.
<black_13>
can common be embedded in a windows application
<Fare>
black_13, using ecl, yes
<Fare>
black_13, or mkcl
<black_13>
I've not here of mkcl
<jackdaniel>
you need to keep things straight – if you want to call C (or C++) from CL, then you use FFI (scenario when your application is written in CL and you want to use C library)
<black_13>
heard
<jackdaniel>
MKCL is ECL's fork (with unclear goals is you ask me)
<Fare>
Does ECL have clear goals?
<jackdaniel>
if you want to call Common Lisp (and use it) from C application, you probably need ECL (or MKCL)
<Fare>
Does an implementation need goals?
<Fare>
People have written Windows applications using CCL, Allegro, LispWorks, etc.
<Fare>
without C
<jackdaniel>
Fare: well, usually when I see someone forking software something tells me, that there ought be a reason
<jackdaniel>
but I've failed to learn one in this case
<Fare>
I believe Jean-Claude had ideas on how to handle interrupts and other low-level details in C++
<Fare>
and JuanJo didn't want to go that way.
<jackdaniel>
from my reading of the old mailing lists it is not the case, but I was not around to argue about that
<Fare>
These are bad memories of second-hand accounts of a dispute I didn't myself read.
<jackdaniel>
black_13: either way, if you want to call C/C++ from Common Lisp – use FFI, if you want to call Common Lisp from C/C++ use one of the mentioned implementations. If you simply want to write application, you may use Common Lisp all the way down
<Fare>
As far as porting ASDF goes, it looks like MKCL fixed some of the bundle issues that I had with ECL (I believe that ECL fixed them since, but I've lost track.)
FreeBirdLjj has quit [Remote host closed the connection]
lumm has joined #lisp
gector has quit [Read error: Connection reset by peer]
<Fare>
I admit I never tried to build either MKCL or ECL on Windows.
gector has joined #lisp
pierpal has joined #lisp
markong has joined #lisp
margeas has quit [Ping timeout: 256 seconds]
nika has joined #lisp
<black_13>
I want to call common lisp from c/c++ but that lisp will use exported c functions
damke has quit [Ping timeout: 244 seconds]
hhdave has quit [Ping timeout: 260 seconds]
<akkad>
Fare: hey
jmercouris has joined #lisp
<jmercouris>
quick update, my issues were most definitely related to the version of asdf that I had
<jmercouris>
it seems on freebsd it makes sense to build SBCL from source
tomsen has quit [Ping timeout: 248 seconds]
<jmercouris>
otherwise you'll have too old a version
<akkad>
ports entry old?
<jmercouris>
I didn't check the ports entry
<jmercouris>
I only had it installed via pkg
<jmercouris>
and then I went to the SBCL site
JuanDaugherty has joined #lisp
mflem has joined #lisp
shka_ has joined #lisp
adlai has joined #lisp
lumm has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 240 seconds]
lumm has joined #lisp
isBEKaml has joined #lisp
phenoble has joined #lisp
isBEKaml has quit [Read error: Connection reset by peer]
TCZ has quit [Quit: Leaving]
isBEKaml has joined #lisp
smurfrobot has joined #lisp
Khisanth has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
al-damiri has joined #lisp
<black_13>
Fare: have you used mkcl
smurfrobot has joined #lisp
skeuomorf has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
pjb has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
EvW has quit [Ping timeout: 260 seconds]
Sonny__ has quit []
beginner_supreme has joined #lisp
shrdlu68 has left #lisp [#lisp]
xaotuk has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
lumm has quit [Ping timeout: 256 seconds]
EvW1 has joined #lisp
scymtym has quit [Ping timeout: 245 seconds]
fikka has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
vindarel has quit [Quit: Page closed]
beginner_supreme is now known as grand-beginner-t
tomsen has joined #lisp
smurfrobot has joined #lisp
skeuomorf has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Ping timeout: 245 seconds]
Kundry_Wag has quit [Remote host closed the connection]
tomsen has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 268 seconds]
lumm has joined #lisp
Kundry_Wag has joined #lisp
pierpal has quit [Quit: Poof]
grand-beginner-t has quit []
pierpal has joined #lisp
Kundry_Wag has quit [Ping timeout: 240 seconds]
lumm has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
pierpal has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
lumm has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
pierpal has joined #lisp
sauvin has quit [Remote host closed the connection]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
xrash has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
milanj has quit [Quit: This computer has gone to sleep]
cage_ has quit [Quit: Leaving]
lumm_ has joined #lisp
lumm has quit [Ping timeout: 276 seconds]
lumm_ is now known as lumm
fikka has joined #lisp
pierpal has joined #lisp
Denommus has joined #lisp
Fare has quit [Ping timeout: 240 seconds]
EvW1 has quit [Ping timeout: 276 seconds]
loli1 has joined #lisp
blackwolf has joined #lisp
nowhere_man has joined #lisp
phenoble has quit [Ping timeout: 240 seconds]
karlosz_ has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz_ is now known as karlosz
pjb has quit [Remote host closed the connection]
phenoble has joined #lisp
pjb has joined #lisp
skeuomorf has joined #lisp
jmercouris has quit [Remote host closed the connection]
jmercouris has joined #lisp
warweasle has quit [Quit: later]
nowhere_man has quit [Ping timeout: 248 seconds]
CrazyEddy has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
nika has quit [Quit: Leaving...]
pierpal has quit [Read error: Connection reset by peer]
milanj has joined #lisp
vap1 has joined #lisp
vaporatorius has joined #lisp
pjb has quit [Remote host closed the connection]
Khisanth has joined #lisp
dented42 has joined #lisp
Younder has quit [Quit: Leaving]
Kundry_Wag has quit [Remote host closed the connection]
phenoble has quit [Ping timeout: 240 seconds]
Kundry_W_ has joined #lisp
phenoble has joined #lisp
pierpal has joined #lisp
TCZ has joined #lisp
nowhere_man has joined #lisp
Denommus` has joined #lisp
fikka has joined #lisp
TCZ has quit [Quit: Leaving]
pjb has joined #lisp
Denommus has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 256 seconds]
slyrus2 has joined #lisp
vap1 has quit [Quit: Leaving]
igemnace has quit [Read error: Connection reset by peer]
Denommus` is now known as Denommus
Cthulhux has quit [Changing host]
Cthulhux has joined #lisp
charh has joined #lisp
trittweiler_ has quit [Ping timeout: 256 seconds]
phenoble has quit [Quit: WeeChat 1.9.1]
jd has joined #lisp
jd has quit [Quit: jd]
Kundry_W_ has quit [Remote host closed the connection]
aindilis has quit [Ping timeout: 245 seconds]
octobanana has joined #lisp
Kundry_Wag has joined #lisp
fikka has joined #lisp
Fare has joined #lisp
Cthulhux has quit [Quit: ne praeteriverit priusquam obesa cantaverit]
<White_Flame>
to add to the discussion around https://imgur.com/a/ws1VDeU , his own thesis completely fails, because calling that function might cause a stack overflow in trying to push the return address & parameter. It's still a "hidden allocation"
Cthulhux has joined #lisp
octobanana has quit [Quit: WeeChat 2.1]
<__rumbler31>
...wat.
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
<pjb>
White_Flame: indeed. The C standard defines a not-turing complete programming language, since it's not guaranteed that you can call functions.
<pjb>
The problem is not the C programming language, it's the "C" programmers.
warweasle has joined #lisp
<pjb>
They don't know their language, and they don't know how to program.
arutai has joined #lisp
<jackdaniel>
I'm sure there is fairly large base of C programmers who do know how to program
<pjb>
I've not witnessed a large C code base to sustain this affirmation.
edgar-rft has joined #lisp
<jackdaniel>
(did you witness a large CL code base which did?)
<pjb>
All the C code you see is crap, be it free software, or commercial proprietary code.
<pjb>
Yes, CL code is better.
<p_l>
C code actively pursues certain level of brokennes due to hacks done in name of speed
<pjb>
There is newbie lisp code around, but there's also a lot of good CL code, and even very nice CL code.
<p_l>
recent brouhahaha with Mono developers finding out that XLc maps page 0 as read-only page full of zeroes is a nice example
<pjb>
:-)
<pjb>
Yeah, they don't know anything.
<White_Flame>
wow, this guy just basically reinvented java-style explicitly required exception handlers
Fare has quit [Ping timeout: 256 seconds]
energizer has joined #lisp
nickenchuggets has joined #lisp
arutai has left #lisp ["ERC (IRC client for Emacs 25.1.1)"]
rpg has joined #lisp
<rpg>
Is there some way to use conditional compilation (#+) to include code that is dependent on SBCL version?
<rpg>
allegro has #+allegro-version<, for example
<rpg>
ASDF relies on some internal code that has just changed in SBCL.
<TMA>
rpg: #+sbcl (pushnew (intern (lisp-implementation-version) :keyword) *features*) and then you can #+(and sbcl 1.3.18) for example
<White_Flame>
"Recursion is one of the enemies of perfect software" - zig guy
<aeth>
p_l: Well... there's always (declare (optimize (speed 3) (safety 0))) for when you want to pursue a level of brokenness due to hacks done in the name of speed.
<aeth>
(And, conversely, there are safe subsets of C.)
<p_l>
aeth: even then there's less UB
<rpg>
TMA: that *almost* works, but I need a comparison ("older than 1.4.7," for example). I can do this with version< but am running into nightmarish issues with when exactly bits of ASDF are read....
<p_l>
aeth: and any safe subset of C is pretty much a forked language, like the language used to write Linux kernel is a fork of C (it's neither standard nor GNU C)
<golden_rule>
hummmm
<p_l>
(optimize (speed 3) (safety 0)), even when it let me overwrite function object metadata by mistaken SETF, I think still gives safer code than C does under normal rules
fikka has quit [Ping timeout: 276 seconds]
MichaelRaskin has joined #lisp
warweasle has quit [Read error: Connection reset by peer]
warweasle has joined #lisp
<rpg>
TMA: the problem for me is that all of ASDF is read so I need to get something into the *features* at the start, before anything additional is read....
kmurphy4_ is now known as kmurphy4
pseudonymous_ has joined #lisp
fikka has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<Bike>
you can do #+#. stuff
<Bike>
it is Nasty though
<TMA>
rpg: older than can be expressed by listing all previous version numbers in an #+(and sbcl (or 1.0.0 1.0.1 ...)) ... it gets unwieldy rather quickly, but it can be done in principle
scymtym has joined #lisp
Fare has joined #lisp
vlatkoB_ has quit [Remote host closed the connection]
<rpg>
TMA: No, that really won't work adequately well
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<rpg>
This really doesn't seem like a big ask. Don't people have code that uses SBCL APIs that have changed? I'm boggled that this isn't supported.
<TMA>
rpg: you can intern not just 1.2.3 but 1.2 and 1 too ... that would cut the list down considerably
karlosz has quit [Quit: karlosz]
<Bike>
the one time i had to do that i did it specifically with the features
<Bike>
something like #+#.(find-symbol "SOME-INTERFACE" "SB-WHATEVER")
karlosz has joined #lisp
pseudonymous_ has quit [Ping timeout: 268 seconds]
<rpg>
Bike: My problem is that the COMPILER-ERROR-CONTEXT structure has changed in 1.4.7, which is causing extreme pain in ASDF's deferred warnings code.
<rpg>
TMA: That would work if I wasn't fixing ASDF -- until ASDF is successfully loaded, VERSION< isn't available. And... VERSION< has a big dependency tail throughout ASDF. So there's a chicken-and-egg problem there.
<TMA>
maybe you will need to implement trivial-version< for this in the very same eval-when, then
<nirved>
rpg: an easier check would be (cl:find-symbol "COMPILER-ERROR-CONTEXT-ORIGINAL-FORM" "SB-C")
<rpg>
TMA: I tried copying hunks of ASDF and UIOP into LABELS for that, but the hunks got very big, very fast (parsing the version string, splitting the version string, lexicographic sort...)
sz0 has joined #lisp
<rpg>
nirved: Yes, that's what I'm doing now, thanks.
varjag has quit [Ping timeout: 276 seconds]
TCZ has joined #lisp
<rpg>
Still, swiping Franz's :version< reader magic seems like it would be a Very Good Thing
bjorkintosh has joined #lisp
jfrancis_ has joined #lisp
<rpg>
Checking for a minimum SBCL version seems like it should not be so painful.
<rpg>
OTOH, I guess that's just the kind of pain that ASDF saves the user.
<pjb>
I use: #+(COM.INFORMATIMAGO.SBCL.VERSION:RT-VERSION< "1.5" (cl:lisp-implementation-version))
<rpg>
pjb: Right, but that relies on loading ASDF to load COM.INFORMATIONIMAGO which.... I can't do because I'm compiling ASDF!
jfrancis has quit [Ping timeout: 248 seconds]
<pjb>
Oops.
Naergon has quit [Ping timeout: 256 seconds]
<pjb>
You will have to copy-and-paste the source.
BillyZane has joined #lisp
* rpg
appreciates the irony: stassats broke the legacy ASDF on SBCL, and it's stassats who refuses to update the ASDF version in SBCL.
mindCrime has quit [Quit: Leaving]
<akkad>
but stas is such a easy person to work with :P
Kundry_Wag has quit [Remote host closed the connection]
devon has joined #lisp
xaotuk has quit [Ping timeout: 276 seconds]
LiamH has quit [Quit: Leaving.]
Bike has quit [Ping timeout: 260 seconds]
CrazyEddy has joined #lisp
atchoum has joined #lisp
tomsen has joined #lisp
<rpg>
I wish I knew if anyone *used* the deferred warnings in ASDF... It seems to be disabled by default. Maybe maintaining it is just a waste of my time...
Folkol has joined #lisp
Naergon has joined #lisp
<devon>
What's different about deferred warnings?
Kundry_Wag has joined #lisp
<MichaelRaskin>
Is it about :warnings-file ?
<rpg>
It slurps up warnings -- especially undefined function warnings -- over the course of an ASDF operation, and then squelches ones that aren't relevant. I suspect that this was introduced in the hopes of later parallelizing compilations and dispensing with the outer WITH-COMPILATION-UNIT.
Mutex7 has joined #lisp
tomsen has quit [Ping timeout: 244 seconds]
<aeth>
What's the barrier to parallelizing compilations?
Kundry_Wag has quit [Ping timeout: 268 seconds]
wigust has quit [Ping timeout: 260 seconds]
lnostdal has quit [Remote host closed the connection]
<rpg>
aeth: all ASDF operations are wrapped in a single WITH-COMPILATION-UNIT
vtomole has quit [Ping timeout: 260 seconds]
Quetzal2 has quit [Quit: ?? Bye!]
<rpg>
aeth: gotta go, sorry -- leave me a note (or post to asdf-devel) if you have more questions!
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
smurfrobot has joined #lisp
Kundry_Wag has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
sjl has quit [Quit: WeeChat 2.0.1]
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
tomsen has joined #lisp
lumm has quit [Quit: lumm]
wheelsucker has quit [Quit: Client Quit]
lumm has joined #lisp
lumm has quit [Client Quit]
<skeuomorf>
What I'd give for coleslaw to do what I want for once
sjl has joined #lisp
innovati has joined #lisp
<White_Flame>
aeth: compile-time side effects
TCZ has quit [Quit: Leaving]
<aeth>
White_Flame: compile-time side effects are great
<jmercouris>
nothing better!
makomo has quit [Ping timeout: 240 seconds]
<aeth>
(eval-when (:compile-toplevel)
<aeth>
oops
<jmercouris>
you dropped this ")"
<aeth>
(eval-when (:compile-toplevel) (zr:launch-example-window)) ; run compile time games!
karlosz has quit [Quit: karlosz]
__rumbler31 has quit [Ping timeout: 256 seconds]
warweasle has quit [Quit: Leaving]
isBEKaml has quit [Quit: Leaving.]
Bike has joined #lisp
<aeth>
The future of programming is source code that compiles one of two things depending on whether or not the human at the computer managed to win a game of chess at compile time.
<jmercouris>
(defun make-thread (bt:make-thread (lambda () (make-thread)))) (eval-when (:compile-toplevel) (make-thread)) ; do you want to play a game?
blackwolf has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
jmercouris has quit [Remote host closed the connection]
margeas has joined #lisp
markong has quit [Ping timeout: 248 seconds]
rpg has joined #lisp
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
willmichael has joined #lisp
robotoad has quit [Quit: robotoad]
willmichael has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 240 seconds]
* White_Flame
constant folds the universe
karlosz has joined #lisp
Oladon has quit [Quit: Leaving.]
tomsen has quit [Ping timeout: 244 seconds]
dented42 has quit [Read error: Connection reset by peer]
Kundry_Wag has quit [Remote host closed the connection]
dented42 has joined #lisp
lnostdal has joined #lisp
karlosz has quit [Quit: karlosz]
Kaisyu has joined #lisp
BillyZane has quit [Ping timeout: 256 seconds]
BillyZane has joined #lisp
BitPuffin has quit [Remote host closed the connection]