<beach>
bollu: It is preferable to define "strongly typed language" as "a language where no object of one type could be accessed as if it were an object of a different type", and then Common Lisp is a "strongly typed language". The preferable terminology for the difference you are looking for is "statically typed language" vs "dynamically typed language".
z4kz has joined #commonlisp
Inline has joined #commonlisp
Inline has quit [Client Quit]
Inline has joined #commonlisp
Inline__ has joined #commonlisp
Inline has quit [Ping timeout: 240 seconds]
Inline__ is now known as Inline
dre has quit [Ping timeout: 260 seconds]
tyson2 has quit [Remote host closed the connection]
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
Inline has quit [Ping timeout: 272 seconds]
dre has joined #commonlisp
Inline has joined #commonlisp
z4kz has quit [Quit: Client closed]
semz_ has joined #commonlisp
semz has quit [Ping timeout: 260 seconds]
semz_ is now known as semz
Bike has joined #commonlisp
akoana has quit [Quit: leaving]
Sankalp has quit [Ping timeout: 250 seconds]
<aeth>
Arguablly, statically typed and dynamically typed languages aren't mutually exclusive. Common Lisp is always dynamically typed (runtime type information), but is arguably also statically typed... normally T, but DECLARE (and THE and a few other things) can provide more specific static type information. Heck, even the class information in method lambda lists.
<aeth>
Of course, the compiler doesn't have to do anything with that.
Sankalp has joined #commonlisp
<aeth>
And it's perfectly within the spirit of Common Lisp to basically let you do whatever you want in whatever style you want (* as long as you're OK with garbage collection)
<semz>
even GC can be avoided to some extent, unlike in other GC'd languages. rather awkward though
d4ryus has quit [Ping timeout: 240 seconds]
attila_lendvai has joined #commonlisp
notzmv has joined #commonlisp
attila_lendvai has quit [Ping timeout: 256 seconds]
attila_lendvai has joined #commonlisp
<beach>
aeth: Of course. My point is that we are dealing with a "war of terminology". Imagine someone who doesn't know Common Lisp and hears about it from someone else. Is that someone more or less likely to give it a try if the word "weak" is associated with it, or if the word "dynamic" is associated with it?
d4ryus has joined #commonlisp
attila_lendvai has quit [Ping timeout: 246 seconds]
<beach>
aeth: I can assure you that a vast majority of my former students (who are not knowledgeable enough to understand about programming language design or implementation) would take the easy way out if "weak" were associated with a new (to them) language.
ttree_ has joined #commonlisp
tychoish has quit [Ping timeout: 246 seconds]
<beach>
I don't know whether the choice of terminology in the statically typed crowd is deliberate so that the word "strong" is associated with their choice, but I wouldn't be surprised.
etimmons has quit [Ping timeout: 256 seconds]
tychoish has joined #commonlisp
<beach>
Similarly, Scheme's choice of "hygienic macros" could very well be such a choice. Do you think my students would prefer a language with "hygienic" macros or "dirty" macros?
etimmons has joined #commonlisp
<beach>
We should come up with an alternative terminology choice for those types of macro systems.
ttree has quit [Ping timeout: 240 seconds]
<beach>
Like for instance "complete" vs "limited".
attila_lendvai has joined #commonlisp
P1RATEZ has joined #commonlisp
attila_lendvai has quit [Ping timeout: 260 seconds]
slowButPresent has quit [Quit: leaving]
Bike has quit [Quit: sleep]
attila_lendvai has joined #commonlisp
z4kz has joined #commonlisp
attila_lendvai has quit [Ping timeout: 272 seconds]
z4kz has quit [Quit: Client closed]
igemnace has quit [Remote host closed the connection]
rotateq has quit [Ping timeout: 260 seconds]
igemnace has joined #commonlisp
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #commonlisp
igemnace has quit [Client Quit]
igemnace has joined #commonlisp
attila_lendvai has joined #commonlisp
dre has quit [Ping timeout: 240 seconds]
Cymew has joined #commonlisp
d4ryus has quit [Ping timeout: 276 seconds]
attila_lendvai has quit [Ping timeout: 272 seconds]
attila_lendvai has joined #commonlisp
d4ryus has joined #commonlisp
P1RATEZ has quit [Remote host closed the connection]
attila_lendvai has quit [Read error: Connection reset by peer]
frgo has quit [Ping timeout: 256 seconds]
ttree_ has quit [Quit: Leaving]
ttree has joined #commonlisp
rotateq has joined #commonlisp
jmes has quit [Remote host closed the connection]
attila_lendvai has joined #commonlisp
aartaka has joined #commonlisp
attila_lendvai has quit [Ping timeout: 276 seconds]
dre has joined #commonlisp
ttree has quit [Read error: Connection reset by peer]
attila_lendvai has joined #commonlisp
yauhsien has joined #commonlisp
ick has quit [Ping timeout: 276 seconds]
igemnace has quit [Remote host closed the connection]
MajorBiscuit has joined #commonlisp
pranavats has left #commonlisp [Error from remote client]
pranavats has joined #commonlisp
igemnace has joined #commonlisp
shka has joined #commonlisp
paul0 has quit [Remote host closed the connection]
paul0 has joined #commonlisp
aeth has quit [Ping timeout: 272 seconds]
aeth has joined #commonlisp
rgherdt has joined #commonlisp
aartaka has quit [Ping timeout: 246 seconds]
aartaka has joined #commonlisp
rgherdt_ has quit [Ping timeout: 276 seconds]
rgherdt_ has joined #commonlisp
rgherdt has quit [Ping timeout: 250 seconds]
aartaka has quit [Ping timeout: 272 seconds]
aartaka has joined #commonlisp
leeb has joined #commonlisp
ick has joined #commonlisp
ahammer has joined #commonlisp
dre has quit [Ping timeout: 240 seconds]
ahammer has quit [Ping timeout: 246 seconds]
ahammer has joined #commonlisp
ahammer has quit [Read error: Connection reset by peer]
treflip has joined #commonlisp
igemnace has quit [Remote host closed the connection]
vats has quit [Read error: Connection reset by peer]
ahammer has joined #commonlisp
ahammer has quit [Ping timeout: 256 seconds]
semz has quit [Quit: Leaving]
semz has joined #commonlisp
aartaka has quit [Ping timeout: 248 seconds]
aartaka has joined #commonlisp
frgo has joined #commonlisp
igemnace has joined #commonlisp
Brucio-61 has quit [Ping timeout: 240 seconds]
scymtym has quit [Ping timeout: 272 seconds]
cage has joined #commonlisp
MajorBiscuit has quit [Quit: WeeChat 3.4]
Brucio-61 has joined #commonlisp
scymtym has joined #commonlisp
random-nick has joined #commonlisp
lisp123 has joined #commonlisp
<lisp123>
Well I learnt recently (maybe I am incorrect) that hygienic macros only exist because Scheme has a terrible namespace issue
xaotuk has joined #commonlisp
<jackdaniel>
beach: I believe that I've mentioned it, but 'organic' vs 'sterile' has a nice ring to it
<jackdaniel>
and a person who've heard about "hygienic" macros would immedietely understand the new terminology ,)
MajorBiscuit has joined #commonlisp
notzmv has quit [Ping timeout: 240 seconds]
<rotateq>
jackdaniel: Steril doesn't sound so natural again, like doing all with statical typing.
<rotateq>
Powerful organic creatures knew it long before how to do flexible programming. :)
<jackdaniel>
yes, if we were to behave neutral, then scheme macros should be called probably a pattern matching, an cl macro should be called compilation-time functions
<jackdaniel>
s/an/and/
admich has joined #commonlisp
<jackdaniel>
I believe that there was some bad blood between scheme and cl programmers in the past
<jackdaniel>
(perhaps due to some childish reasons, like "my language is better" and sticking out the tongue)
<rotateq>
I tried re-reading the Baker paper about metacircular semantics, it gives me still a very tough time. And this one footnote confuses me "so Common Lisp cannot have continuations as Scheme".
<rotateq>
jackdaniel: Can they say too "Reality can now be whatever I want" in this depth? :)
pfd has quit [Quit: Client closed]
<jackdaniel>
beats me, continuations are clearly a concept that has not been absorbed by common lisp though
pranavats has left #commonlisp [Error from remote client]
<rotateq>
jackdaniel: Yes not absorbed, but can be written.
<mfiano>
With limitations
<rotateq>
mfiano: I can imagine, but cannot say where those begin. The chapter 20 in 'On Lisp' is nice, I learned a bit about continuations before and then saw how they can be really implemented.
<mfiano>
rotateq: You can check out the cl-cont library for reasons why it is so limited.
<rotateq>
I cannot say I really understand the full concept of them by now.
<rotateq>
Oh okay.
<mfiano>
Although some of those are implementation incompleteness
pranavats has joined #commonlisp
<mfiano>
I admit I don't fully grasp continuations. I never studied Scheme in depth where they are used often.
<rotateq>
In a Haskell context I once read "The mother of all Monads".
<jackdaniel>
I think that the consensus among scheme programmers is that full continuations are not very useful, but delimited ones are very important
<rotateq>
jackdaniel: Maybe similar to a limited TAGBODY/GO scope versus an unlimited one?
<jackdaniel>
perhaps
lisp123 has quit [Remote host closed the connection]
<mfiano>
Is there a concise single-pass way to do (loop :for (nil foo) :in list ...) and error what it comes across a value of foo that was previous seen?
<mfiano>
previously*
<mfiano>
Not happy with a few alterations
<random-nick>
you could use a hash table I guess
<mfiano>
A little overkill I think, but it crossed my mind
<jackdaniel>
well, it is not an overkill if you look for duplicates
<jackdaniel>
in fact that's one of more sane ways to implement remove-duplicates
<jackdaniel>
finding duplicates is one of these easy problems that happen to surprise with non-obvious implementations (For some small values of "non-obvious")
<random-nick>
rotateq: full continuations are similar to C's setjmp/longjmp if you're familiar with them
<random-nick>
the problem with multithreading mentioned is I guess referring to the fact that it's problematic to invoke a continuation from another thread
<rotateq>
random-nick: No with C I'm not experienced at all, but thanks. :)
<random-nick>
also, an important difference between CL and scheme with regards to continuations is that CL's unwind-protect only takes cleanup forms for unwinding, while scheme's dynamic-wind takes code both for unwinding and for rewinding
<mfiano>
jackdaniel: I suppose I could just do check the length against (remove-duplicates list :key #'cadr) and move on.
<jackdaniel>
sure, but this passes the list twice ,)
<mfiano>
Yeah and it also doesn't tell me the faulting value
<mfiano>
So hmm
<random-nick>
it makes sense that unwind-protect doesn't take forms for rewinding since you can't rewind in CL, but it also means that you can't add a language extension which involves rewinding and use existing code that uses unwind-protect
<rotateq>
Anyway, I believe in CL enough to think it will be good in the future to build also time machines or such. ^^
z4kz has joined #commonlisp
<jackdaniel>
there is a preliminary code on my blog about "tixel viewer"
<jackdaniel>
(for time machines that is)
notzmv has joined #commonlisp
MajorBiscuit has quit [Ping timeout: 248 seconds]
MajorBiscuit has joined #commonlisp
lisp123 has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
<lisp123>
Page 270 of On Lisp describe a bit about where CL continuations fall short
<lisp123>
That and the next couple of chapters are some fine writing
ick has quit [Ping timeout: 272 seconds]
MajorBiscuit has quit [Ping timeout: 250 seconds]
<lisp123>
I went away from continuations though for some of my old code, I wasn't smart enough to keep all the logic in my head
MajorBiscuit has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 276 seconds]
Lord_of_Life has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
<jackdaniel>
delimited continuations (something I have stashed for quite some time in my ecl repository) are a handy feature
<jackdaniel>
you may implement on top of them green threads, generators and other similar constructs in a performant way
lisp123 has quit [Remote host closed the connection]
<CodeBitCookie[m]>
jackdaniel: Ooh, I like that solution, although, are you sure it works on Windows and Mac too?
<jackdaniel>
I don't really care, but if I had to guess - it doesn't
<CodeBitCookie[m]>
rotateq: I think you misunderstood my question, I wasn't asking for browsers made in common lisp, I wanted a way to get the system default browser.
<CodeBitCookie[m]>
jackdaniel: Ok.
MajorBiscuit has joined #commonlisp
lisp123 has joined #commonlisp
<Xach>
CodeBitCookie[m]: trivial-open-browser may help
zacque has quit [Quit: Goodbye :D]
lisp123 has quit [Ping timeout: 276 seconds]
ick has quit [Ping timeout: 276 seconds]
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
ick has joined #commonlisp
lisp123 has joined #commonlisp
<CodeBitCookie[m]>
So... Any other solutions which are multi-platform?
<mfiano>
An implementation isn't even totally cross platform, and you didn't specify which platforms.
<jackdaniel>
all of them
yauhsien has quit [Remote host closed the connection]
<jackdaniel>
from x8* to *rm64
<mfiano>
Then you better start porting some compiler backends
yauhsien has joined #commonlisp
<lisp123>
jackdaniel: They are. I guess it depends on the problem set, where it is "natural" to think of continuations, then they work - when its not, then they get confusing
<lisp123>
CodeBitCookie[m]: Nyxt is probably the best
<CodeBitCookie[m]>
<CodeBitCookie[m]> "Ooh, I like that solution..." <- I told it in this message ^
<CodeBitCookie[m]>
Shinmera: Omg, Thanks so much. That is so cool!
* mfiano
thinks there is more to "platform" than OS.
cage has quit [Remote host closed the connection]
lisp123 has quit [Quit: Leaving...]
cage has joined #commonlisp
yauhsien has quit [Ping timeout: 256 seconds]
<mfiano>
CodeBitCookie[m]: You'll likely need trivial-features for that approach.
<CodeBitCookie[m]>
mfiano: Why?
<mfiano>
*FEATURES* are not portable.
<jackdaniel>
well, a "default web browser" seems to be a concept dependent on the platform
<mfiano>
and indeed, Trial uses trivial-features.
<jackdaniel>
s/dependent on the platform/dependent on the operating system/
<mfiano>
jackdaniel: It's important to have good communication skills when asking for help. "platform" is pretty ambiguous, even if we all got the gist of what they meant.
<jackdaniel>
sure, that's why I've asked the first two questions
<mfiano>
Also Android runs Linux...
<jackdaniel>
well, that's where GNU/Linux (or Systemd/Linux, or Android/Linux) distinction makes perfect sense
<jackdaniel>
but then there is gnome, kde and DE
<mfiano>
and do you mean explicitly Mac or BSD?
<mfiano>
etc etc
<jackdaniel>
sure, but getting overly technical with communication sometimes obscures the topic
* mfiano
will refrain from nitpicking any further.
<Repsil>
that's just one example. i've seen many other coders do the same
<Repsil>
i thought it was the standard. and that i was missing the tool that does that
<Repsil>
you don't format your code that way?
<Xach>
Repsil: perhaps you can ask wzrdsappr what they do
<Xach>
I don't format my code like that. I don't have an automatic formatter and I dislike reformatting things. I also usually have more options than will fit horizontally, so I prefer vertical layout.
<Bike>
i mean, the link is fine. your code didn't work, i'm sure. handlers don't carry across threads.
<CodeBitCookie[m]>
Bike: exactly. The error was still going off.
<Bike>
when you start a new thread, it gets a new dynamic environment, and you can't rely on anything from the make-thread caller being carried over.
<CodeBitCookie[m]>
So,
<CodeBitCookie[m]>
I want to get the `(error ...)` part of the thing to run outside the thread.
<CodeBitCookie[m]>
or maybe there is another solution?
<Bike>
sometimes there's an in-main-thread kind of operator you can use to make stuff happen in the original thread. failing that, you could translate the thing into a return value from the thread.
<Bike>
and join it. i don't know if that makes sense for your use case.
<CodeBitCookie[m]>
Hmmmmm....
<CodeBitCookie[m]>
Isn't there like a:
<Bike>
on the simplest level, something like your thread function being (handler-case (progn (uiop:run-program) t) (error () nil))
<Bike>
and then joining it. that kind of loses you any advantage to using threads, though, so maybe not
<CodeBitCookie[m]>
Isn't there something like: Try A, if A succeeds, do X, else do Y
<CodeBitCookie[m]>
Bike: Notice how I seperate A and X while handler joins it together.
<Bike>
well, the no-error clause kind of separates them, if i understand what you mean correctly
<CodeBitCookie[m]>
Oh, I see.
<CodeBitCookie[m]>
Can you kindly tell me how to use the :no-error part? I would really appreciate it.
<CodeBitCookie[m]>
(like with my example)
<Bike>
do you need the return values from the run-program?
<CodeBitCookie[m]>
No.
Oladon has joined #commonlisp
<CodeBitCookie[m]>
but would be appreciated
<Bike>
hmm. well, i might be thinking about this wrong. is your basic intent that you want to start a thread to run this program while your original thread goes off and does something else? but then if you get an error from the run-program, that thread can end and you get the dialog?
<CodeBitCookie[m]>
Also, I just found about about the "hash" program on Linux. It just errors if a program doesn't exist, otherwise just doesn't do anything for example "hash vim" will do nothing if you have vim and will error if you don't have the program.
karlosz has joined #commonlisp
<CodeBitCookie[m]>
Bike: Almost, everything before the first question mark is correct
<CodeBitCookie[m]>
Actually nvm, you are right.
tyson2 has joined #commonlisp
<CodeBitCookie[m]>
Everything you said in that message is correct.
<CodeBitCookie[m]>
CodeBitCookie[m]: Also, any use of this ^ Bike?
<Bike>
ok, so it needs to be asynchronous. in that case, maybe the right thing is... gtk-threads-add-idle to get the dialogue in the main thread?
<Bike>
i haven't used gtk3, though
<Bike>
just flipping through the manual for thread stuff
<CodeBitCookie[m]>
Thanks.
triffid has quit [Remote host closed the connection]
kpoeck has joined #commonlisp
triffid has joined #commonlisp
<CodeBitCookie[m]>
Also, How do I `RETURN-FROM` a lambda expression?
<Bike>
Do you mean that you want to return an anonymous function, or that you want to return from an anonymous function?
<rotateq>
CodeBitCookie[m]: RETURN-FROM always comes with BLOCK.
<CodeBitCookie[m]>
so I wrap the function contents inside BLOCK?
<Bike>
pretty much.
<rotateq>
So you can do something like (lambda (...) (block name ... (return-from name ...))).
<rotateq>
The one coexists with the other afaik.
<Bike>
sidenote: you also can't return-from one thread to a block in another thread
<Bike>
oh, i see, you quickly check whether the program exists first, and only then run it in the new thread. makes sense.
<CodeBitCookie[m]>
Is it too hacky? Or is it a good solution?
<Bike>
i don't know if hash is the right thing to use, but the concept seems fine to me
<CodeBitCookie[m]>
Bike: Why so?
<Bike>
i just mean i am unfamiliar with the details of how hash works.
<CodeBitCookie[m]>
People use hash to check if a program is installed in all bash scripts.
<CodeBitCookie[m]>
so it must be right, right?
<Bike>
seems so.
<CodeBitCookie[m]>
Yay!
karlosz has quit [Ping timeout: 272 seconds]
<CodeBitCookie[m]>
Bike: I could also use "WHICH" for Linux and "WHERE" for Windows.
orestarod has joined #commonlisp
<jackdaniel>
I sincerely hope that mezzano will have "poof" function for that ,)
MajorBiscuit has quit [Quit: WeeChat 3.4]
aeth has quit [Ping timeout: 246 seconds]
<guest74>
CodeBitCookie[m] if you plan on using WHICH on linux you'll want to check if uiop:run-program looks up where the binary lives, because if it doesn't it wont work.
Inline has quit [Quit: Leaving]
aeth has joined #commonlisp
attila_lendvai has quit [Ping timeout: 246 seconds]
<jackdaniel>
posix specifies to use -v or something afair
Inline has joined #commonlisp
Oladon has quit [Quit: Leaving.]
genpaku has quit [Ping timeout: 276 seconds]
makomo has quit [Quit: WeeChat 3.4]
<Nilby>
does any else run multiple lisp images, say 10-100?
<rotateq>
at the same time?
<Nilby>
yes
<rotateq>
I'm happy when I can tame one.
<Nilby>
gotta tame'em all
<lagash>
Which edition(s) of Object-Oriented Design by Grady Booch have at least CLOS for examples? It appears, for instance, that Object-Oriented Analysis and Design With Applications, 2nd ed. (Booch) uses C++..
yauhsien has joined #commonlisp
<rotateq>
lagash: I could recommend you some good book for learning CLOS if that is what you search for.
genpaku has joined #commonlisp
<White_Flame>
Nilby: well, when SLIMEing into remote programs, or executing standalone binaries I guess
<rotateq>
lagash: C++? What is that?
<White_Flame>
however, I don't really like image-based development
<White_Flame>
in terms of re-saving images long-term
<White_Flame>
you risk getting disconnected from your source code
yauhsien has quit [Ping timeout: 276 seconds]
<rotateq>
Nilby: Some people collect postage stamps, others collect CL implementations.
<Nilby>
White_Flame: The images could be mostly identical, I'm mostly concerned about memory usage.
<White_Flame>
uh, I'd think many running images woudl take way more memory than one combo image
<White_Flame>
since they'd all be duplicating the lisp runtime stuff
<White_Flame>
or time to get into RDBMS, distributed programming, etc, to not hit RAM limits
<Nilby>
Yes. That's what happens. :( But also putting every application in risks losing everything when it inevitably has a problem.
<White_Flame>
that's literally what files are for?
<White_Flame>
in terms of saving your data
<White_Flame>
can you be more specific about the situation?
<Nilby>
imagine everything on your desktop is lisp
<White_Flame>
(which lisp has done in the past)
<White_Flame>
also, whatever workflow you've ever had for virtual machines is a very similar situation
<Nilby>
and it's free software, so i can't use lispworks/allegro, which both can do this just fine
<White_Flame>
or multi-booting OSes
<White_Flame>
(well, the latter doesn't actually snapshot running things like the VMs do)
<lagash>
rotateq: no, I already have a list, I'm just obsessed with creating themed bibliographies..
<rotateq>
oki :)
<rotateq>
I still have to re-read some sections in the excellent book by Keene.
<CodeBitCookie[m]>
<Guest74> "CodeBitCookie if you plan on..." <- Guest74: Yeah, I was just comparing the WHERE to indirectly tell you it does the same thing as WHICH instead of HASH
<rotateq>
And then AMOP .. *sigh*
<lagash>
Oh wow, Grady Booch was the inventor of UML... no wonder the name looked familiar, lol
<rotateq>
Oh hm UML. Is that still a hot thing?
<Nilby>
i know not having everything in the cloud is very contrary
<White_Flame>
Nilby: what's the problem/situation you're facing?
<lagash>
rotateq: Booch works at IBM, if that tells you anything :-P
<rotateq>
Mandelbrot did too all of his career after his PhD. :)
<Nilby>
"game over" whenever sbcl runs out it's dynamic space (or stack space even)
<White_Flame>
right
<White_Flame>
and that generally means you need to start spilling to disk, spilling to other machines, buy more RAM, or use virtual memory
<White_Flame>
(and yeah, I'm not a fan of fixed heap limits as well)
<Nilby>
but if you give 100 processes all of memory, it's not so good either
<White_Flame>
this is not a lisp-specific problem
<Nilby>
I totally have enough memory for everything, it's just either not being used, or being used for preening garbgage
<White_Flame>
it's just a general design issue against physical limitations
<rotateq>
I had the thought if one writes terminal tools then better bundle all together in one image that runs in the background so some tool can be called threaded. But sure, if something breaks everything needs to be restarted.
<White_Flame>
busybox, systemd, etc :-P
<Nilby>
I've done it both ways, bundled and separate but it's still troublesome
<White_Flame>
it sounds like your general, nonspecific "troublesome"ness boils down to non automation
<treflip>
both bysybox and systemd can be just horrible sometimes
<rotateq>
Nilby: Calling a whole lisp image every time doing an 'ls' might give people the intention it's slow. ^^
<White_Flame>
eg, your state should be immediately reinstantiated from a single call, and you should have data & config saved to files instead of just being mutated live
<White_Flame>
and really, they should be independent of each other, and not care if peers are running in the same image at all (except dependencies of course)
<lagash>
rotateq: OK so it appears the third edition has examples in CLOS as well as Ada, Pascal, etc..
karlosz has joined #commonlisp
<rotateq>
Ah nice.
karrq has quit [Quit: Konversation terminated!]
<Nilby>
i don't know of any other program besides sbcl which runs out of memory when i have tons left, and takes up tons of resident pages, way more than say a web browser, when i give it lots of room
<Nilby>
even old emacs eventually tamed it's memory usage
tyson2 has quit [Remote host closed the connection]
Lycurgus has joined #commonlisp
<_death>
unfortunately it's still at the stage where humans have to improve it
karlosz has quit [Ping timeout: 276 seconds]
<Lycurgus>
Nilby, sbcl built with your desired sized heap?
<Nilby>
Lycurgus: yes, but it doesn't really matter if it's built with it or you given it on the command line
<Lycurgus>
that's false sfaik, but not sure;why would there be a compile option for it if it could be done at the command line?
<Nilby>
Lycurgus: it's slightly quicker if it's compiled in, but my problem isn't start up time, which is great actually
<Lycurgus>
well they're same named so gotta assume they are the same
<Lycurgus>
i don't consider sbcl a first rate implementation anyway
<Lycurgus>
just one with a huge fanbase that includes people like me that adopted it after using cmucl
<Lycurgus>
everything in time
<Lycurgus>
ultimately its character in performance relative to ACL, CCL and LW became clear
<Nilby>
Lycurgus: from a free software programmer persepctive it's great until the you hit the memory limits and then it's game over
* Lycurgus
likes to color within the lines after recognizing them
<Nilby>
if it was non-free software i would just use a non-free lisp and not worry further
<Lycurgus>
sbcl works well enough it's just not all that
<Nilby>
allegro can run with 256TB heap
<Lycurgus>
also all of the non free mentioned are only non free for use that could be 'business' or 'enterprise' whether for profit or no
<Lycurgus>
with various cripplings that don't kill developing and are generally completely removed when the entirerly reasonable fees are paid
treflip has quit [Quit: Quit]
akoana has joined #commonlisp
<White_Flame>
Nilby: do any of the other lisps have a non-static heap size configuration?
<Lycurgus>
cl is still cl which ultimately gives the developer the upper hand but it's a power that's only useful if you're reasonable about it;sbcl is just cranky/crunky
<lagash>
rotateq: ooooh, and a French translation, too! Conception orientée objets et applications (Booch, trans. Reese & Reese)
<Nilby>
White_Flame: yes, basically every other one, although ccl just pre-commits 64G or something
<lagash>
Although not sure if that edition has the CLOS examples.. :/
<Nilby>
I think it should be reasonable to make a desktop or command line app that doesn't run out of or hog lots of memory. sadly many other gc'd langauges can
<Nilby>
and the other implemations
<Nilby>
but sbcl is soooo fast and otherwise nice
<Nilby>
i guess i could start writing a new gc now, and in 5-10 years i'd have a buggy slow gc
<White_Flame>
the problem is that afaik SBCL's GC is still written in C
<Nilby>
White_Flame: exactly, and very intimately with the rest of the compiler
<White_Flame>
well a GC needs to be intimate there
<Nilby>
i've written a gc in C, scheme, and lisp, but the one(s) in sbcl still make my head swim
Repsil has quit [Remote host closed the connection]
Repsil has joined #commonlisp
<guest74>
The only time I've run into problems with sbcl is with recursive stuff. Most recently when implementing L systems.
<White_Flame>
same here, last I looked you couldn't change the stack size per thread
<dlowe>
there was once a dynamic heap size patch for sbcl. Wonder what happened to it
Oddity has joined #commonlisp
<rotateq>
lagash: So now I can finally learn French. ^^
trannus_aran has joined #commonlisp
<trannus_aran>
Anyone here use parenscript to build react apps? I'm trying to learn
pve has quit [Quit: leaving]
<Nilby>
dlowe: i have huge respect for the sbcl devs, but my totally unfounded conspiracy theory is that someone is running an sbcl with such a patch right now
<yitzi>
There are some comments various IRC logs about forward porting in about 2011. Not sure what happened since then.
karlosz has quit [Quit: karlosz]
jeosol has joined #commonlisp
tyson2 has joined #commonlisp
karlosz has joined #commonlisp
karlosz has quit [Quit: karlosz]
random-jellyfish has joined #commonlisp
<random-jellyfish>
how do I surround the entire line with parens in portacle? what kb shortcut do I use?
<random-jellyfish>
e.g. if I write "car l" I want to turn it into "(car l)"
Brucio-61 has quit [Ping timeout: 260 seconds]
scymtym has quit [Ping timeout: 248 seconds]
<dlowe>
M-2 ( should do it
<dlowe>
where "2" is the number of elements you want to consume
<dlowe>
I think also you can make a region with C-spc and then hit ( and it will enclose the region
<random-jellyfish>
nice, both work like a charm
<Nilby>
yitzi: thanks for finding that
<random-jellyfish>
and how do I remove parens? like everything between the enclosing parens at coursor?
<rotateq>
random-jellyfish: I had to get used to that myself in portacle. Or typing Ctrl+Enter to evaluate an expression while the cursor is inside.
jmdaemon has joined #commonlisp
<rotateq>
When in doubt you can always turn off paredit-mode.
<dlowe>
random-nick: M-r will "raise" the element on point out of the parens (and delete everything else)
<dlowe>
You can use M-2 M-r to keep two things
<dlowe>
not sure how you'd keep everything. It's not a common operation
morganw has joined #commonlisp
aartaka has quit [Ping timeout: 272 seconds]
aartaka has joined #commonlisp
aartaka has quit [Ping timeout: 276 seconds]
kpoeck has quit [Quit: Client closed]
scymtym has joined #commonlisp
ick has quit [Ping timeout: 240 seconds]
Brucio-61 has joined #commonlisp
Xach_ has quit [Ping timeout: 260 seconds]
rtoy has quit [Quit: rtoy]
<White_Flame>
Nilby: honestly, while I've used SBCL for a long time, I'm waiting for SICL to dive into the low level improvements I've wanted. I just can't go back into C :-P
<random-jellyfish>
M-r is not working in paredit mode
<random-jellyfish>
it turns on Previous element matching (regexp)
<Nilby>
White_Flame: I agree, but observing the timescale of other Lisp development, I'd better not hold my breath. I note when people go to C from Lisp, they tend to have a very macro heavy style, like clisp or even a little in emacs. So maybe one can't write "normal" C ever again.
ec has quit [Quit: ec]
<White_Flame>
it's either asm or high level for me. Middling languages aren't worth it
retropikzel has joined #commonlisp
guest74 has quit [Quit: Ping timeout (120 seconds)]
<aeth>
eh
<aeth>
C++ has its use
<aeth>
I hate to say it, but graphics are easier in C++ than in CL by at least an order of magnitude... because of libraries
<rotateq>
Hm, I asked it recently, what is C++?
<aeth>
C with classes :-p
<rotateq>
ohh
random-jellyfish has quit [Ping timeout: 252 seconds]
<aeth>
or at least that's what it started as
<aeth>
it's one of those languages that's notorious for adding everything (even more so than CL)
<rotateq>
and then changing much every 3 years now
triffid has quit [Ping timeout: 240 seconds]
igemnace has quit [Ping timeout: 250 seconds]
guest74 has joined #commonlisp
triffid has joined #commonlisp
triffid has quit [Ping timeout: 240 seconds]
triffid has joined #commonlisp
Xach has joined #commonlisp
cosimone has quit [Quit: ERC 5.4 (IRC client for GNU Emacs 28.1)]
X-Scale has quit [Ping timeout: 272 seconds]
shka has quit [Ping timeout: 246 seconds]
Repsil has quit [Remote host closed the connection]
X-Scale has joined #commonlisp
X-Scale` has joined #commonlisp
X-Scale has quit [Ping timeout: 246 seconds]
X-Scale` is now known as X-Scale
<guest74>
@ae
<guest74>
nice
Repsil has joined #commonlisp
patrix has quit [Changing host]
patrix has joined #commonlisp
<guest74>
aeth: Maybe you're thinking of a specific type of graphics? I'm finding 2d graphics way easier in lisp.
ccregor has joined #commonlisp
<guest74>
totally offtopic, anybody think LOTRO is worth picking up the free giveaway?
<lagash>
Guest74: What giveaway now?
<guest74>
seems they're giving away all DLC's except the last for anybody that makes it to level 2 before May(i think)
morganw has quit [Remote host closed the connection]
guest74 has quit [Quit: Connection closed]
pjb has quit [Ping timeout: 260 seconds]
Xach has quit [Remote host closed the connection]
Repsil has quit [Remote host closed the connection]
ahammer has joined #commonlisp
yauhsien has joined #commonlisp
<aeth>
accelerated graphics. matrix transforms on vectors. that kind of thing. entirely down to the libraries
<aeth>
(you think of it as 3D, but it works on 2D, too)