<mfiano>
I only bring it up because it particularly arises for some of the 2D functions that you may be using. It just hasn't been a priority for me because my uses of SDL2 is pretty unorthodox, and only for events and a GL context, no draw calls.
<_death>
phantomics: if you're talking about the latest version, it only uses a surface if "overlays" are used.. like I said, I use it for visualizing stuff mostly.. like simulated annealing or linear regression (using stochastic gradient descent), or collision detection algorithms, or abelian sandpiles, or... you get it
<_death>
phantomics: the code has a bunch of pixels-* demos
<_death>
phantomics: though it needs a patched cl-sdl2-gfx to run :)
<_death>
I'll add the patch
<phantomics>
_death: those pixels-* demos are the ones that use surface?
<_death>
phantomics: no.. I think I use overlays only in my logo stuff
<mfiano>
_death: See issue #127 to see if this relates to you
<mfiano>
I am not sure, but if anyone can patch that I'd be very appreciative
Volt_ has joined #lisp
drl has quit [Quit: Ex-Chat]
<mfiano>
Should be a fairly easy task for anyone looking to contribute to a widely used library.
<_death>
well, I updated with the 1-line "patch".. you'll need to re-generate the autowrap spec files.. the actual patch is 5M so..
<phantomics>
_death: looks like anything that uses (frame-loop) uses the surface since (frame-loop) expands to (call-with-frame-function)
<_death>
phantomics: well, it uses the default renderer.. I took it you meant a software surface.. which only the overlays use
<_death>
mfiano: ah, I don't use those operators
<phantomics>
_death: I see, I need to get deeper into cl-sdl to understand, I'm looking for the quickest way to push a bitmap to a window
suzukisama has joined #lisp
<mfiano>
If anyone is interested in the code for how to "run your repl in your own event loop", here is the code. Just call setup-repl once, and update-repl some human-acceptable period (every few iterations) of your loop. It is complicated-looking because it supports SLIME, Sly, or neither, and so has to generate the functions with #'compile
dilated_dinosaur has quit [Ping timeout: 240 seconds]
<_death>
oh, I also use simple-graphics for stupid games like minesweeper or breakout
<mfiano>
Seems sort of similar to sketch at first glance.
<mfiano>
Except that is broken too because it uses cl-sdl2-ttf :)
<_death>
yeah I used sketch too for a while
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
Rengan has quit [Remote host closed the connection]
<_death>
I also wrote opencv bindings, which include highgui which makes certain kinds of visualizations easy.. but not so good with input
<mfiano>
I haven't ever used OpenCV, but that's just because I don't like stepping outside of my nice little Lisp sandbox. I only use FFI where I must, which strictly means OS I/O (kb/mouse/gamepad/display/gpu (and eventually audio when I need it))
<mfiano>
Luckily all of that is encompassed in cl-sdl2 and cl-opengl
<mfiano>
If I needed such a thing, I'd just convolve the image myself on the Lisp side, or some DSL to have the GPU do the heavy lifting in a compute shader. Identifying features and tracking motion is not all that difficult
torbo has joined #lisp
Bourne has quit [Ping timeout: 260 seconds]
yitzi has joined #lisp
<Lycurgus>
convolve the image
<_death>
sure, if it suits your needs.. but opencv is a huge library with all kinds of crazy code that hundreds of people worked on for many years..
<_death>
my bindings are not complete, I mostly implemented stuff as I needed it.. though I also ported all the imgproc tutorials to lisp, for example..
<mfiano>
I am not disagreeing with anyone's choice to use it or other foreign libraries. I just prefer to write portable, conforming CL, as to maximize safety and minimize bitrot.
<_death>
sure, I would prefer that as well :)
iamFIREcracker has joined #lisp
EvW has quit [Ping timeout: 240 seconds]
<_death>
also had to write some C++ for those bindings.. and for my imgui bindings too.. but once you have these tools available to Lisp, it's pretty cool
<mfiano>
I guess another reason I like CL, is libraries are small and easy to extend or outright rewrite, due to the fact that everyone rewrites their own to begin with :) Enterprise software is a pain to dig through. I've had to study my share of Unreal Engine's source to implement or to better understand some things in my game engine, and it was not fun.
sillydude has joined #lisp
iamFIREcracker has quit [Ping timeout: 264 seconds]
<sillydude>
Hello?
<White_Flame>
mfiano: yeah, I've rewritten stuff that's existed in alexandria and other very common libs to taste, and it's nice having a reference & being able to substitute out easily
<White_Flame>
sillydude: it works
xrash has quit [Ping timeout: 240 seconds]
<mfiano>
Some things in alexandria definitely need to be rewritten. IIRC not too long ago I noticed some n^2 operations that could have been linear
<_death>
when the library is small, a complete port to lisp is great.. like squirl (not long ago I wrote a bunch of patches.. but doesn't seem to be actively maintained by anyone)
<sillydude>
Hey guys, would you mind if I ask a question? (Excuse my ignorance as I am VERY new with CL)
<White_Flame>
I wrote an erlang node library for CL and it really wasn't big either
<White_Flame>
sillydude: asking to ask isn't very useful
<mfiano>
sillydude: #clschool may better suite you, but shoot
<mfiano>
suit*
<_death>
mfiano: right.. compare (alexandria:shuffle (loop repeat 100000 collect (random 10))) to (coerce (alexandria:shuffle (coerce (loop repeat 100000 collect (random 10)) 'vector)) 'list) .. it's like they implemented the list variant for didactic purposes and not practical purposes..
<White_Flame>
but to answer your implied question, yeah #clschool will absorb anything :)
<mfiano>
_death: Yeah, I think shuffle was one of the handful I noticed that could have been improved. I think mappend is another, and there were quite a few actually.
Lord_of_Life has quit [Read error: Connection reset by peer]
bhartrihari has joined #lisp
Lord_of_Life has joined #lisp
xrash has joined #lisp
xrash has quit [Excess Flood]
suzukisama has quit [Quit: WeeChat 2.3]
<sillydude>
Well I have a little problem. I had started learning C earlier this year. I got a textbook, worked my way through it without a whole lot of issue and made some cool stuff. Now I wanted to try and do the same with CL so I started reading "Practical Common Lisp", but I just finished the 8th chapter and I hate to admit it but I'm still having a really
<sillydude>
hard time being able to understand most fundamental elements of the language. I can't tell whether Lisp is just more difficult to learn or whether I didn't pick the best book for a beginner. So in your opinion should I try out a different book and if so what would you recommend.
<sillydude>
Also, I have never talked in a Lisp chat nor ever used irc
mindCrime has quit [Excess Flood]
<mfiano>
It is more difficult to learn due to it being on a completely different planet than C and other Algol derivatives
mindCrime has joined #lisp
<mfiano>
But if it's your first language, it's actually easier in my opinion, once you learn the basics, which that book should cover. Just ensure you read it linearly, and perform all of the practicals.
<White_Flame>
I think the hardest things IMO to understand are symbols and their packages, and yeah it can take a while
<_death>
mfiano: with regards to that live support code, why not use feature expressions like #+swank ?
ldbeth has joined #lisp
<Bike>
you could try gentle introduction to symbolic computation
<sillydude>
Before C I had no prior programming experience
<Bike>
might depend on what aspects you're stuck on, though
<White_Flame>
simply because symbols sort of exist in other langauges, but only at compile time, so they go all weird in human recognition to be first class at runtime
<ldbeth>
good morning
<Bike>
(you could also just ask us or clschool about those aspects)
<Bike>
(sometimes interactivity is good for learning)
<White_Flame>
sillydude: any specific thing that's hard for you right now in your reading?
<mfiano>
_death: There was a good reason, and I'm having a bit of trouble remembering exactly why.
<mfiano>
I'll let you know when I think of it
<ldbeth>
I'd say programming itself is never easy
<sillydude>
It is kind of weird, there is nothing specific. Most of the code is incredibly hard to wrap my brain around and I hardly understand a word he is saying when he explains it
davepdotorg has joined #lisp
<Bike>
you might be overthinking it
<sillydude>
It's just that I never had this problem learning C (my first experience programming)
<White_Flame>
ldbeth: it's a creative pursuit, so getting used to conjuring something from nothing is daunting, but the craft is practiced & becomes at least more familiar
<Bike>
i mean the code is, what, like, a database for mp3s or something? it's not exactly a mathematics dissertation
<_death>
sillydude: I wouldn't recommend PCL to someone new to programming.. Gentle as mentioned by Bike, or ANSI Common Lisp (the first chapter is available at https://sep.yimg.com/ty/cdn/paulgraham/acl1.txt )
<Bike>
it's pretty much intended for someone who's never programmed before
<aeth>
someone should read that, understand that, and port it to CL!
<mfiano>
_death: It _might_ have been because of cached FASLs. I know a couple people requested a while ago that you couldn't switch out the backend without clearing them, so that might have en at least part of the reason.
<mfiano>
have been*
<_death>
mfiano: I see
<Bike>
"For you, let me stress the word _gentle_ in the title. I assume no prior mathematical background beyond arithmetic."
<sillydude>
Sorry I came here asking kind of stupid questions. I just felt desperate because conceptually Lisp seems really cool, but it is very discouraging trying to learn
rumbler3_ has quit [Remote host closed the connection]
<Bike>
asking questions is good. you don't need to apologize
<mfiano>
Yes, actually. You want the backend to differ during development and on a deployed binary on some non-Lisp users machine.
ldbeth has quit [Remote host closed the connection]
<mfiano>
But also just testing deployed binary with vanilla implementation REPL on same PC as development IDE, or even switching between SLIME and Sly
<Bike>
"there are no stupid questions" is a clichรฉ, but "could i get some more help" is not a stupid question
ldbeth has joined #lisp
_jrjsmrtn has joined #lisp
<_death>
mfiano: you could still avoid the compilation.. since it's mostly just special binding/calling a function..
<mfiano>
Gamedev is time consuming, and finding/deleting specific FASLs, or saying screw it and nukng them all, and waiting for a huge transitive dependency chain to compile every couple minutes is annoying
__jrjsmrtn__ has quit [Ping timeout: 244 seconds]
<mfiano>
We don't use any special variables in our game engine, if that is what you are implying. That is one hard rule we must follow
<_death>
mfiano: right, I mean the when-let with *emacs-connection* there.. you can use symbol-value and funcall
<mfiano>
That is true. I admit the SLIME part of it hasn't got much love, as I don't use it. Using code provided by someone else for that.
<sillydude>
@Bike Well I'm not having an issue with math. To me the book just feels *fast*. I had used Programming C: A Modern Approach and the pace felt great. It would introduce a small concept, quiz you and give you projects to do. Then introduce a new concept that and give you more examples and projects that just really engrained how it works in my head.
<sillydude>
With PCL he moves onto new concepts very quickly and in code examples, uses functions or things like ",@" that he has never introduced before as if I am supposed to have prior knowledge of them.
<_death>
mfiano: uiop even has a symbol-call operator that may be useful there
<mfiano>
I'll think how to make that better sometime, but more imptant matters in the meantime :)
<sillydude>
The only time I felt like I really understood was sections like Chapter 7 where he has individual sections just for things like do, do-list, cond, e.t.c.
<ldbeth>
sillydude: I see. Maybe you're looking for a book like land of lisp
<White_Flame>
land of lisp does use some things with a "don't worry about this part, I'll explain later" tone as well
<Bike>
sillydude: yeah, try gentle. has tons of examples and stuff.
<mfiano>
Might want to stay clear of the other LOL (Let Over Lambda) :)
<Bike>
plus it was actually used for classes and stuff
rumbler31 has quit [Ping timeout: 240 seconds]
<_death>
gentle and the PG book have exercises
<ldbeth>
indeed, but it is not easy for a book to present ideas in parallel
<White_Flame>
sillydude: also, try to code little stuff yourself. Since lisp is interactive, you can directly execute any little form to try to get a feel for how it works and see the result immediately without any edit/compile/run cycle
<Bike>
and don't be afraid to ask us questions if you still have questions, cos a book can only teach so much
<mfiano>
Someone new to Lisp recently mentioned to me they got more from Successful Lisp than PCL, so that is another option maybe, but I haven't read it personally.
<White_Flame>
mfiano: new to lisp, or new to programming entirely?
xrash has joined #lisp
<mfiano>
New to Lisp, coming from D
<xristos>
PAIP has a great intro to Lisp too
<ldbeth>
D: the succesor of C, I suppose
<mfiano>
More like C++, but yeah
<no-defun-allowed>
C++++?
<White_Flame>
no, that's intel's programming language
iamFIREcracker has joined #lisp
<no-defun-allowed>
If you arrange the plusses in a 2x2 square you get Cโฏ
<Bike>
c is called that because it's next after b in "BCPL", so logically it should be P
<mfiano>
A major problem with onboarding is the required tooling. Yes, we have things like Portacle, but tooling is pretty absent from most of these books. Once you know about Portacle, you still (probably) have to learn how to use something other than Notepad++ or vscode to get anything out of such an interactive language...
<sillydude>
Well thanks guys I guess I will look into whether I want to try Gentle or Land of Lisp. White_Flame I have tried that, but that gets boring really quickly considering I don't know enough of the standard functions/macros to do much more than loop some text printing or some simple math like Celsius to Fahrenheit conversion
<White_Flame>
ah, well that's a great start already :)
<White_Flame>
btw, do you have any specific project interest in learning programming? or just learning?
<_death>
sillydude: ANSI Common Lisp also contains a "reference" appendix, which is like a cheatsheet for someone new to Lisp.. the real reference document is the Common Lisp HyperSpec however.. http://www.lispworks.com/documentation/HyperSpec/Front/index.htm
<sillydude>
I guess just learning, originally atleast. I just really enjoy the feeling of getting in the zone working on a somewhat useful project
<mfiano>
sillydude: For me it took like a year or two to fully grok macros. Even though Lisp macros are extremely powerful and define the language, you can focus on other aspects of the language as to not get overwhelmed.
iamFIREcracker has quit [Ping timeout: 240 seconds]
<sillydude>
mfiano I meant standard macros. I wasn't sure how to describe them
<sillydude>
but macros like do-list and such
<sillydude>
because they aren't functions (as far as I know)
<mfiano>
I meant writing them, which is probably where you saw that ",@"
<Bike>
yeah, "standard macros" is a fine description for those
<mfiano>
PCL is pretty macro heavy
<sillydude>
oh ok
<ldbeth>
sillydude: may i ask how you got to fimiliar the standard library of C
<sillydude>
Just from the textbook I was using
<sillydude>
not any special section
<sillydude>
just reading linearly
<sillydude>
I actually stopped reading right before the "Standard Library" section lol
<ldbeth>
I suppose they all follow certain naming conventions?
dilated_dinosaur has joined #lisp
<Bike>
well, in lisp dotimes is a part of the standard library, whereas in c for is syntax
<Bike>
gets tricky
<sillydude>
I guess so
galex-713 has quit [Ping timeout: 244 seconds]
<White_Flame>
the difference is, in C you can't define your own "for" loop syntax (well, you could hack the preprocessor horribly), but in Lisp, defining someting like dolist in your own code is easily possible
<White_Flame>
that's definitely something for later, but shows the power that awaits you
<sillydude>
Also, I guess I have a different question. How do YOU (specifically) package your programs for distribution? .lisp files, .fasl's, ASFD stuff, images/cores?
<White_Flame>
it depends what you mean by "distribution"
<mfiano>
sillydude: All macros are functions, just evaluated differently (at a different time)
<White_Flame>
libraries, applications, etc are often just open source .lisp/.asd files
<sillydude>
lets say you email me "hey dude heres my lisp program. Run it!"
<White_Flame>
for closed source, executable images
<sillydude>
and can you run those from the command line like ./my-program.EXTENSION?
<White_Flame>
"here's a .zip file of .lisp", or "here's a link to my github"
<White_Flame>
pretty small things can fit in a single .lisp file
<White_Flame>
(although some large bootstrap stuff behind the scenes crams a lot into 1 file)
<mfiano>
sillydude: Typically you publish your code for others to compile (by loading it into their image). Binary compilation is not a part of the standard, and is done differently on each Lisp implementation.
<White_Flame>
but the same is true in C. Most programs aren't just one standalone .c file
<White_Flame>
_death: heh, clever
<sillydude>
Ok so pretty much all the time, for someone to run someones program they have to open a lisp image and (load) the files in, or use some kind of script or something else that accomplishes this?
<White_Flame>
you normally always have a lisp image running
<sillydude>
lol ok that makes sense
<White_Flame>
it's both your development and execution environment
<White_Flame>
and stuff you load in from 3rd parties are usually namespaced in packages so they don't interfere
<sillydude>
but lets say I have on image open with my own stuff and want to run someone else, would I not make a new image to sort of "reset" it first?
<White_Flame>
(except for one-liners/single functions like the above link)
<sillydude>
OOOh
<sillydude>
ok thank you very much
<sillydude>
Lol I guess I should have gone to #clschool
<White_Flame>
oh right, C doesn't have any namespacing, only C++?
<Bike>
yeah.
<mfiano>
sillydude: "packages" in other languages are "systems" in CL, and you would use the ASDF library to define such a system, and publish that. "package" in the CL sense is completely different and only pertains to namespacing symbols at the parser level, so don't let that confuse you.
<sillydude>
And using this ASDF is more or less standard?
<ldbeth>
ASDF is anology to `make' util
<sillydude>
hmm
<mfiano>
To be technical, a "system" is not part of CL either, and provided through a separate library (ASDF)
<mfiano>
It is defacto standard, but not part of ANSI
<sillydude>
I see
<ldbeth>
just like make it resolves dependency between lisp files and controls the complaition of them
<xristos>
you don't have to use ASDF, if all you have is a single .lisp file you don't need it, also you can distribute native executables (SBCL and CCL among others can produce them)
<xristos>
if you're just starting out with CL, worrying about ASDF, systems and packages is overkill
<sillydude>
So, would it be fair to say that lisp programs are usually only run by Lisp people?
<sillydude>
Because those are the ones to already have their Lisp image running?
<White_Flame>
if a Lisp program is hosted as a server, or distributed as an executable binary, it's no problem.
<ldbeth>
java programs are usually only run by JVM :P
zaquest has quit [Quit: Leaving]
<xristos>
sillydude: native executables look like any other native executable
<xristos>
your users need not know that they're implemented in Common Lisp
<sillydude>
really?
iAmDecim_ has quit [Ping timeout: 256 seconds]
<ldbeth>
be honest, just different in size
<sillydude>
but there is no program.lisp file that some guys would click on from within his file manager right?
<sillydude>
when you say "executable" I guess that's the only way I think of it
<Bike>
most implementations have some kind of facility to "dump" executable files
<_death>
sillydude: there would be a program.exe file
<Bike>
these executable files look like any other program you would run
<xristos>
when i say executable i mean a native executable for your target platform, PE exe on windows, ELF on Linux and so on
<sillydude>
_death what would be the unix-like analogue to that?
<White_Flame>
chmod a+x program
<sillydude>
no way...
<_death>
sillydude: executables on unix usually don't have a file extension.. so program
<White_Flame>
C isn't the only language that generates executables
<White_Flame>
it's just a bunch of bytes and a machine code entry point, could be generated by anything
<mfiano>
sillydude: On some implementations, you can just dump your whole iamge to disk and prepend an executable header to it so that it runs like any other executable. It just contains more than your code...the state of your entire image (unless care was taken by you or the implementation to unload other stuff). For this reason, a distributed program has full access to the parser and compiler, and your code
<mfiano>
can make use of this for runtime tricks.
<White_Flame>
right, your executable basically just resumes your image, and launches some toplevel function (analogous to C's main())
<White_Flame>
but you can tell it which function to call at executable startup
<_death>
sillydude: there are also Lisp implementations that generate C code, which in turn can be compiled to an executable..
<aeth>
Some languages implicitly look for main() or something like it. Others need you to say what main() is. CL is the latter, although (main) is still a good name for it.
iissaacc has joined #lisp
<sillydude>
Im just confused as to how I create this executable, I just chmod +x'ed my .lisp and .fasl; the former gives and error, the latter does nothing.
<aeth>
If you chmod +x your .lisp it can work, but you'd need to #!/usr/bin/sbcl or something along those lines. It depends on the implementation if that's supported as the first line. Unfortunately, it's not very robust if you're distributing it because your user's SBCL might not be at /usr/bin/sbcl if they even have it installed
<sillydude>
Ok, but if I was to give that executable to someone, they would have to have SBCL to properly execute it, correct?
<aeth>
no
<_death>
sillydude: the executable includes the whole of sbcl
<sillydude>
wtf
<sillydude>
lol thats so cool
<sillydude>
Lisp is really cool TBH
<aeth>
the executable is self-contained and bundles the whole runtime; launching a .lisp either directly (with e.g. chmod +x and #!/usr/bin/sbcl as the first line) or indirectly (e.g. a one-liner shell script that does sbcl --script foo.lisp if SBCL) requires it to be installed already
<aeth>
unfortunately, none of this is really portable (although some libraries exist to permit either style) which is why my examples are in SBCL
<_death>
sillydude: you can try it.. start sbcl and do (sb-ext:save-lisp-and-die "foo" :executable t :toplevel (lambda () (print 'hi) (sb-ext:exit)))
zaquest has joined #lisp
<aeth>
and no matter what you need to provide an entry point, probably (main), unless you do the --script route and have the entry file call (main) directly
<ldbeth>
if you're concered with not exposing the programming interface to the user some commercial implementations can strip out the unused part of runtime, but this is beyond the scope of disccussion.
<sillydude>
so then with this core image, I can sit in my home directory and run something like $ myprogram -a, aslong as the image exists in $PATH?
<mfiano>
Sure
<sillydude>
hm
<_death>
instead of (print 'hi) try (print sb-ext:*posix-argv*)
<mfiano>
You can also just run several applications inside your development environment, like a few web sites, games, etc, and develop them as they are live, since Lisp is an interactive language that can be compiled iteratively one form at a time.
<mfiano>
No executable dumping needed
justache has quit [Remote host closed the connection]
<sillydude>
You guys have been a big help, thank you very much
justache has joined #lisp
iamFIREcracker has joined #lisp
toorevitimirp has joined #lisp
<sillydude>
and very welcoming
<ldbeth>
:D
iamFIREcracker has quit [Ping timeout: 244 seconds]
<mfiano>
_death: What does the sb-ext:exit actually do? Doesn't the control automatically exit when your toplevel function terminates?
<_death>
mfiano: no, it goes to the repl
<mfiano>
Not for me
<mfiano>
"This function returning is equivalent to (sb-ext:exit :code 0) being called."
<_death>
hmmm.. right.. I misremembered. still, it's good to have exit because usually you want to return an exit status
<mfiano>
I suppose most applications aside a simple CLI tool would have an event loop anyway.
<mfiano>
While we're on the topic of s-l-a-d, the manual says this for purify: "If true (the default on cheneygc)...". How do I know which GC is being used, and can I control that, etc?
<no-defun-allowed>
You most likely are using gencgc on x86_64 and ARM64.
<_death>
you need to compile sbcl to change a gc
<no-defun-allowed>
cheneygc isn't generational, which would generally make it "slower", so you probably wouldn't want to control it anyway.
<_death>
they push different features
<mfiano>
Yeah I figured it was gencgc, infact I didn't know others existed when I read that a while ago.
<mfiano>
Which is what prompted the question for "how to switch"
<mfiano>
Thanks
<no-defun-allowed>
gencgc mostly does Cheney copying over several generations, collecting the youngest generations more quickly, so I think beyond a couple more hardware barriers, it's generally faster in every way than a single Cheney heap.
<mfiano>
All I can say is at least CL or its implementations isn't like Nim (language). They have 7 (and counting) GC's for different levels of soft and hard-real time. Excessive much?
<no-defun-allowed>
Not really, I've frequently been annoyed at gencgc pause times (which are noticeably long with large heaps). But try tuning a JVM collector...
<_death>
mfiano: the reason I thought it'd drop back to the repl is because that's what it does with sbcl --eval.. so then you have the --quit option
<mfiano>
Nim is just a toy, and this is but one example of a plethora of experiments being pushed into releases after little testing. The whole compiler is full of these "not sure what I want this project to be" things
akoana has quit [Quit: leaving]
davepdotorg has joined #lisp
<no-defun-allowed>
Looking at that, none of the collectors look any good, with just non-generational mark-sweep or refcounting. gencgc would be better in everything but pause times then.
<mfiano>
(spent 2 months porting some Lisp code to Nim until I gave up at the inconsistencies and stability issues). Also, it has to call out to libc for a bunch, with a high overhead even with GC disabled. Trigonometric functions were much slower than managed SBCL for example.
<mfiano>
no-defun-allowed: The new one, is not really refcounting according to the author.
<no-defun-allowed>
Which is the new one?
<mfiano>
Arc
<ldbeth>
any GC is between refcounting and mark sweep
<no-defun-allowed>
Is it going to be like the Go collector which is really from the 70s? Oh, well that's just refcounting again and you're being bullshitted.
xrash has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
"Plain reference counting with move semantic optimizations, offers a shared heap. It offers deterministic performance for hard realtime systems. Reference cycles cause memory leaks, beware." Citation needed on the deterministic part, but yeah the first three words contradict that.
sillydude has quit [Remote host closed the connection]
<no-defun-allowed>
ldbeth: I disagree, Cheney collection doesn't really mark or sweep, or count references. Mark-compact doesn't really sweep either.
davepdotorg has quit [Ping timeout: 244 seconds]
<_death>
copying collectors
<mfiano>
Yeah I know. The author is very strange when he talks about it on IRC, preferring not to compare it with reference counting. He is like that about a lot of these "innovative" tangents
<no-defun-allowed>
"Marking" in the former is done by shallow-copying the object from oldspace to newspace, then overwriting the object with a reference to the newspace copy (so that it won't be copied more than once).
jesse1010 has quit [Ping timeout: 244 seconds]
xrash has joined #lisp
<ldbeth>
correction: not mark sweep, it is tracing
<no-defun-allowed>
Yes, tracing is the name of the not-refcounting category.
<mfiano>
Do you have any good resources on the two methods, at a low enough level to gain something, but high enough for someone that never implemented either?
<no-defun-allowed>
I used the Garbage Collection Handbook to implement the incremental copying collector I wrote, but it is frequently hard to understand.
<mfiano>
About 6 months ago I tried implementing a refcounter for my game engine, but I stashed it due to callback hell problems
<ldbeth>
This article I'm reading gives some interesting insight on toploop/REPL
<ldbeth>
2.4 Toplevels considered harmful
iAmDecim_ has quit [Ping timeout: 264 seconds]
<ldbeth>
although the author shows a preference of UNIX C compiler tool chains, this sections provides some examples on how important could a clear isolation method in REPL enviornment be, also hints on how a first class environment been used to implement useful developing tools
space_otter has joined #lisp
orivej has joined #lisp
justache has quit [Remote host closed the connection]
<beach>
Good morning everyone!
justache has joined #lisp
Alfr_ has joined #lisp
davepdotorg has joined #lisp
Alfr has quit [Ping timeout: 244 seconds]
davepdotorg has quit [Ping timeout: 240 seconds]
iamFIREcracker has joined #lisp
ldbeth has quit [Ping timeout: 258 seconds]
Codaraxis__ has quit [Read error: Connection reset by peer]
iamFIREcracker has quit [Ping timeout: 258 seconds]
Bike has quit [Quit: leaving]
ldbeth has joined #lisp
<ldbeth>
hello beach
iAmDecim_ has joined #lisp
Stanley00 has joined #lisp
iAmDecim_ has quit [Ping timeout: 256 seconds]
ldbeth has quit [Ping timeout: 244 seconds]
davepdotorg has joined #lisp
mindCrime has quit [Ping timeout: 244 seconds]
karlosz has quit [Read error: No route to host]
ldbeth has joined #lisp
karlosz has joined #lisp
xrash has quit [Ping timeout: 256 seconds]
davepdotorg has quit [Ping timeout: 244 seconds]
froggey has quit [Ping timeout: 240 seconds]
iamFIREcracker has joined #lisp
ldbeth has quit [Ping timeout: 256 seconds]
edgar-rft has quit [Quit: Leaving]
froggey has joined #lisp
shifty has joined #lisp
iamFIREcracker has quit [Ping timeout: 240 seconds]
ldbeth has joined #lisp
ldbeth has quit [Ping timeout: 260 seconds]
justache has quit [Remote host closed the connection]
justache has joined #lisp
ldbeth has joined #lisp
torbo has quit [Remote host closed the connection]
ldbeth has quit [Ping timeout: 244 seconds]
johnjay has quit [Ping timeout: 240 seconds]
CommanderViral has quit [Quit: ZNC 1.7.1+deb1+bionic1 - https://znc.in]
johnjay has joined #lisp
dominic34 has quit [Ping timeout: 244 seconds]
ldbeth has joined #lisp
toorevitimirp has quit [Ping timeout: 244 seconds]
ldbeth has quit [Ping timeout: 258 seconds]
Oladon has quit [Quit: Leaving.]
iamFIREcracker has joined #lisp
ldbeth has joined #lisp
iamFIREcracker has quit [Ping timeout: 244 seconds]
justache has quit [Remote host closed the connection]
ldbeth has quit [Ping timeout: 240 seconds]
justache has joined #lisp
ldbeth has joined #lisp
ldbeth has quit [Ping timeout: 256 seconds]
ldbeth has joined #lisp
iAmDecim_ has joined #lisp
jibanes has quit [Ping timeout: 256 seconds]
jibanes has joined #lisp
ldbeth has quit [Ping timeout: 264 seconds]
ldbeth has joined #lisp
iamFIREcracker has joined #lisp
ldbeth has quit [Ping timeout: 240 seconds]
Oladon has joined #lisp
cosimone has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
cyraxjoe has quit [Quit: I'm out!]
iamFIREcracker has quit [Ping timeout: 265 seconds]
cyraxjoe has joined #lisp
ldbeth has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life has joined #lisp
gravicappa has joined #lisp
ldbeth has quit [Ping timeout: 240 seconds]
borei has quit [Ping timeout: 240 seconds]
iAmDecim_ has quit [Ping timeout: 240 seconds]
ldbeth has joined #lisp
narimiran has joined #lisp
ldbeth has quit [Ping timeout: 240 seconds]
leo_song has quit [Ping timeout: 264 seconds]
ggoes has quit [Ping timeout: 256 seconds]
ggoes has joined #lisp
leo_song has joined #lisp
jibanes has quit [Ping timeout: 240 seconds]
jibanes has joined #lisp
iamFIREcracker has joined #lisp
Necktwi has quit [Ping timeout: 244 seconds]
schweers has joined #lisp
iAmDecim_ has joined #lisp
aartaka has joined #lisp
bocaneri has joined #lisp
Oladon has quit [Quit: Leaving.]
aartaka has quit [Read error: Connection reset by peer]
gaqwas has joined #lisp
gaqwas has quit [Changing host]
gaqwas has joined #lisp
gravicappa has quit [Remote host closed the connection]
iAmDecim_ has quit [Ping timeout: 258 seconds]
aartaka has joined #lisp
Lycurgus has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
davepdotorg has joined #lisp
davepdotorg has quit [Ping timeout: 240 seconds]
iissaacc has quit [Ping timeout: 256 seconds]
ted_wroclaw has joined #lisp
jonatack has quit [Ping timeout: 240 seconds]
ggole has joined #lisp
edgar-rft has joined #lisp
Necktwi has joined #lisp
Lycurgus has quit [Quit: Exeunt]
random-nick has joined #lisp
pok has joined #lisp
scymtym has quit [Ping timeout: 256 seconds]
pve has joined #lisp
skapata has joined #lisp
orivej has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
scymtym has joined #lisp
jonatack has joined #lisp
aartaka has joined #lisp
karlosz has quit [Quit: karlosz]
ljavorsk has joined #lisp
bilegeek has quit [Quit: Leaving]
skapata has left #lisp ["ฤis"]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
davepdotorg has joined #lisp
shka_ has joined #lisp
ralt has joined #lisp
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
jibanes has quit [Ping timeout: 240 seconds]
jw4 has quit [Read error: Connection reset by peer]
jibanes has joined #lisp
jw4 has joined #lisp
supercoven has joined #lisp
supercoven has quit [Read error: Connection reset by peer]
davepdotorg has quit [Remote host closed the connection]
supercoven has joined #lisp
davepdotorg has joined #lisp
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzzโฆ]
rgherdt has joined #lisp
jonatack has quit [Ping timeout: 244 seconds]
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
lavaflow has quit [Ping timeout: 264 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
aartaka_d has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
ted_wroclaw has joined #lisp
Gerula has quit [Ping timeout: 256 seconds]
Gerula_ has joined #lisp
lavaflow has joined #lisp
ebrasca has joined #lisp
davepdot_ has joined #lisp
davepdotorg has quit [Ping timeout: 258 seconds]
Gerula_ is now known as Gerula
<contrapunctus>
So I made a PR updating the link to Temperance on awesome-cl. However, I've still not found a repository for cl-advice, not even on GitHub (well, there's a "trivial-advice", but I'm not sure that's the same)
davepdot_ has quit [Remote host closed the connection]
<phoe>
it's not in quicklisp
davepdotorg has joined #lisp
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
jesse1010 has joined #lisp
kaftejiman has joined #lisp
Inline has joined #lisp
orivej has joined #lisp
Nilby has joined #lisp
lavaflow has quit [Ping timeout: 256 seconds]
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
aartaka_d has quit [Remote host closed the connection]
edgar-rft has quit [Quit: Leaving]
aartaka has joined #lisp
lavaflow has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
<seokk>
I'm getting a file-perror trying to run portacle on a friend's windows
<seokk>
cannot find slime.9872 file in temp folder
<seokk>
we've looked in there and no slime file exists, so slime won't boot up
<dra>
seokk: I think that question will have more success in #slime.
karayan has joined #lisp
space_otter has quit [Remote host closed the connection]
<seokk>
ah thank you!
<dra>
seokk: Or #shirakumo.
<dra>
You're welcome!
seokk has quit [Remote host closed the connection]
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzzโฆ]
dra has quit [Remote host closed the connection]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
nckx has joined #lisp
davepdot_ has joined #lisp
davepdot_ has quit [Remote host closed the connection]
davepdotorg has quit [Ping timeout: 260 seconds]
davepdotorg has joined #lisp
luckless has joined #lisp
mindCrime has joined #lisp
luckless_ has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
rgherdt has quit [Ping timeout: 244 seconds]
karayan has quit [Remote host closed the connection]
karayan has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
davepdotorg has quit [Remote host closed the connection]
davepdotorg has joined #lisp
ljavorsk has quit [Ping timeout: 256 seconds]
davepdotorg has quit [Ping timeout: 260 seconds]
kaftejiman has quit [Remote host closed the connection]
mindCrime has quit [Ping timeout: 244 seconds]
Nilby has quit [Ping timeout: 258 seconds]
APic has quit [Quit: Fnord โ brb]
APic has joined #lisp
yitzi has quit [Quit: yitzi]
yitzi has joined #lisp
AeroNotix has joined #lisp
mindCrime has joined #lisp
Nilby has joined #lisp
Stanley00 has quit [Remote host closed the connection]
davepdotorg has joined #lisp
lambdanon has joined #lisp
<lambdanon>
Hey there, I'm trying to (use-package 'cl-ana.generic-math) in SLIME, but every time I launch the REPL I have to choose TAKE-NEW every time there's a name conflict. Is there a way to use the package while automatically overriding all functions?
<phoe>
lambdanon: which package are you in?
<phoe>
CL-USER?
<lambdanon>
Yeah that's right
<lambdanon>
phoe: I see, so I need to use (in-package) to override the function names?
<White_Flame>
what's a sampling of symbols are conflicting?
<lambdanon>
White_Flame: arithmetic operations like +, *, etc
<lambdanon>
phoe: I'll give that a try, cheers :)
<White_Flame>
yeah, this appears documented
davepdotorg has quit [Ping timeout: 244 seconds]
<lambdanon>
phoe: I need to specify a package for cl-ana.generic-math:use-gmath. Do I need to use something like #:CL-USER?
<phoe>
oh!
<phoe>
(use-gmath *package*)
<phoe>
should have been the default, really
<phoe>
or (use-gmath :my-package)
<lambdanon>
that seems to have worked when it comes to overriding the functionality, thanks
<phoe>
in particular, CL-USER has its own set of USEd packages that is implementation-defined
<phoe>
it uses CL for sure, and this includes CL:+, CL:-, CL:* and other symbols that are likely to collide with generic math symbols
<lambdanon>
although it's not quite what I was looking for in terms of functionality
<lambdanon>
Looking at the github (https://github.com/ghollisjr/cl-ana/wiki/Generic-Math): "Tensors have all available generic math functions defined for them automatically as long as the tensor sublibrary is loaded prior to defining the functions with defmath."
<lambdanon>
their code example for adding two lists is: (+ '((1 2) (3 4)) '(1 2 3)). But when I run this code after loading the package, I get an error
<lambdanon>
There is no applicable method for the generic function
<AeroNotix>
Why people insist on using symbols in the CL package never ceases to confuse me
<AeroNotix>
re-using*, in their own packages
<phoe>
what do you mean, using symbols in the CL package
<AeroNotix>
like redefining #:+
<AeroNotix>
CL:+
<jackdaniel>
because it is the most natural name for addition
<phoe>
because they can
<AeroNotix>
I get that but it just causes crap like this^
<phoe>
right, the problem would just solve itself if we enforced one-name-globally because everyone would write (cl-ana.generic-math.+ '((1 2) (3 4)) '(1 2 3))
jonatack has joined #lisp
<phoe>
the thing that also really irks me is that someone once implemented mathematical sets as (DEFCLASS MY-SET-LIBRARY:SET ...) which is an obvious naming conflict with the CL package as well
<phoe>
/s
specbot has quit [Remote host closed the connection]
minion has quit [Remote host closed the connection]
minion has joined #lisp
specbot has joined #lisp
davepdotorg has joined #lisp
<jackdaniel>
if I write the application, which manages delivery, I'd expect that there is a function find-package
<jackdaniel>
and I would be surprised if it had found an object of the type cl:package
<Alfr_>
You could call it find-parcel .
<lambdanon>
Turns out the code example they had was a mistake. Even when I explicitly used cl-ana.generic-math:+, the example failed. Using (+ '((1 0) (0 1)) '((-1 1) (3 5))) has worked, however
<lambdanon>
either that or I'm still being a dumbass. That's probably the case lmao
<Inline>
'((1 2) (3 4)) and '(1 2 3) are not isomorphic
<mseddon>
I was surprised to see a google style guide for CL, I thought google didn't use it.
rumbler31 has joined #lisp
dominic34 has joined #lisp
<beach>
They bought the company that used Common Lisp for airline trip planning. I forget the name.
<mseddon>
beach: I forgot it too, but I definitely remember it, big name in the early 2000's
<beach>
Oh, they suggest prefixing the slot accessor with the class name. That's not a great idea.
<beach>
ITA?
<jackdaniel>
yes, the flight company was called ita
<mseddon>
ah yeah! that was it.
<jackdaniel>
prefixing the slot accessor with the class name is probably a tactic to make classes /more/ interchangable with structures
<jackdaniel>
(i.e to use classes like you use structures - strictly as data containers)
<beach>
Oh, that sounds plausible, and it makes it even worse.
<mseddon>
beach: what would you suggest instead of prefixing the accessor? I have a lot of silly AST classes for this toy compiler, and e.g. for a lambda I have lambda-exp to access the body, and for a let0 I have let0-exp to access the expression for a simple assignment.
<beach>
mseddon: Not prefixing it.
rumbler31 has quit [Ping timeout: 246 seconds]
<mseddon>
and yes, I am in this habit because for years I used defstruct.
<mseddon>
oh, right, the accessor becomes generic. duh.
<beach>
Yep.
<mseddon>
how embarrassing. I'll do that then :)
<jackdaniel>
I suppose that it depends on the preferred programming style
<beach>
It looks really dumb when you have deep inheritance, like (SHEET-PARENT PANE) in CLIM.
<mseddon>
beach: I agree it gets irritatingly verbose pretty quickly.
<jackdaniel>
i.e having accessors with such prefixes gives you better context (as a reader)
<beach>
And why would you want the SHEET parent of a PANE, rather than the PANE parent of ot?
<beach>
of it?
<jackdaniel>
because here you treat the pane as a sheet (n.b had pane be a structure, then you'd be able to use pane-parent, so clearly defstruct designer tought about that)
<jackdaniel>
so the context for the reader is that this object is a sheet
<mseddon>
in the case of CLIM, I think it inherited a lot of names from FLAVORS on the lispms didn't it?
<jackdaniel>
I don't have clear opinion what is better, I is just not clearly wrong to me
<jackdaniel>
s/I is/it is/
<jackdaniel>
mseddon: mostly it inherited names from dynamic windows, if from anything
<mseddon>
right, yeah.
<mseddon>
which iirc flavors would generate accessors much like defstruct
<mseddon>
but it's... been a rather long time :)
<jackdaniel>
thoughtยฐ
ted_wroclaw has joined #lisp
rumbler31 has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
shifty has joined #lisp
easye` has quit [Quit: ERC (IRC client for Emacs 27.1)]
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzzโฆ]
Necktwi has quit [Ping timeout: 240 seconds]
chrpape` has joined #lisp
beach` has joined #lisp
sgithens_ has joined #lisp
ft has quit [Ping timeout: 244 seconds]
splittist_ has joined #lisp
jmercouris_ has joined #lisp
manicennui_ has joined #lisp
hydan_ has joined #lisp
asedeno_ has joined #lisp
XachX_ has joined #lisp
Balooga_ has joined #lisp
bytesighs_ has joined #lisp
conjunctive_ has joined #lisp
jerme__ has joined #lisp
avicenna_ has joined #lisp
billstclair_ has joined #lisp
beach has quit [Disconnected by services]
beach` is now known as beach
grfn` has joined #lisp
CEnnis91_ has joined #lisp
IPmonger_ has joined #lisp
Necktwi has joined #lisp
IPmonger has quit [Ping timeout: 244 seconds]
lacedaemon has joined #lisp
seisatsu_ has joined #lisp
Yardanico_ has joined #lisp
ft has joined #lisp
ioa_ has joined #lisp
cpt_nemo_ has joined #lisp
Patzy_ has joined #lisp
splittist has quit [Ping timeout: 272 seconds]
FennecCode has quit [Ping timeout: 272 seconds]
manicennui has quit [Ping timeout: 272 seconds]
hydan has quit [Ping timeout: 272 seconds]
lukego has quit [Ping timeout: 272 seconds]
jmercouris has quit [Ping timeout: 272 seconds]
splittist_ is now known as splittist
asedeno has quit [Ping timeout: 272 seconds]
conjunctive has quit [Ping timeout: 272 seconds]
CEnnis91 has quit [Ping timeout: 272 seconds]
jerme_ has quit [Ping timeout: 272 seconds]
avicenna has quit [Ping timeout: 272 seconds]
XachX has quit [Ping timeout: 272 seconds]
seisatsu has quit [Ping timeout: 272 seconds]
sgithens has quit [Ping timeout: 272 seconds]
ioa has quit [Ping timeout: 272 seconds]
SumoSud0- has quit [Ping timeout: 272 seconds]
Patzy has quit [Ping timeout: 272 seconds]
grfn has quit [Ping timeout: 272 seconds]
billstclair has quit [Ping timeout: 272 seconds]
Balooga has quit [Ping timeout: 272 seconds]
bytesighs has quit [Ping timeout: 272 seconds]
fe[nl]ix has quit [Ping timeout: 272 seconds]
|jonathan| has quit [Ping timeout: 272 seconds]
cpt_nemo has quit [Ping timeout: 272 seconds]
Yardanico has quit [Ping timeout: 272 seconds]
chrpape has quit [Ping timeout: 272 seconds]
Grauwolf has quit [Ping timeout: 272 seconds]
otwieracz has quit [Ping timeout: 272 seconds]
boeg has quit [Ping timeout: 272 seconds]
gingerale has quit [Ping timeout: 272 seconds]
manicennui_ is now known as manicennui
hydan_ is now known as hydan
asedeno_ is now known as asedeno
sgithens_ is now known as sgithens
XachX_ is now known as XachX
jmercouris_ is now known as jmercouris
avicenna_ is now known as avicenna
jerme__ is now known as jerme_
conjunctive_ is now known as conjunctive
bytesighs_ is now known as bytesighs
CEnnis91_ is now known as CEnnis91
Balooga_ is now known as Balooga
grfn` is now known as grfn
billstclair_ is now known as billstclair
boeg has joined #lisp
otwieracz has joined #lisp
SumoSud0 has joined #lisp
Inline has quit [Quit: Leaving]
Grauwolf has joined #lisp
skapata has left #lisp ["ฤis"]
Lycurgus has joined #lisp
lukego has joined #lisp
FennecCode has joined #lisp
gingerale has joined #lisp
jonathan| has joined #lisp
scymtym has quit [Ping timeout: 244 seconds]
jibanes has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 258 seconds]
Lycurgus has quit [Quit: Exeunt]
shifty has joined #lisp
jibanes has joined #lisp
Inline has joined #lisp
schweers has quit [Ping timeout: 244 seconds]
even4void has joined #lisp
borei has joined #lisp
shifty has quit [Ping timeout: 258 seconds]
shifty has joined #lisp
lucasb has joined #lisp
IPmonger_ has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
shinohai has quit [Quit: ZNC 1.8.x-git-190-d3011c6 - https://znc.in]
shinohai has joined #lisp
IPmonger has joined #lisp
clothespin_ has quit [Quit: Leaving]
sjl_ has joined #lisp
Josh_2 has joined #lisp
<Josh_2>
afternoon
enrio has joined #lisp
shinohai_ has joined #lisp
shinohai has quit [Read error: Connection reset by peer]
even4void has quit [Remote host closed the connection]
even4void has joined #lisp
even4void has quit [Remote host closed the connection]
sjl_ has quit [Quit: WeeChat 2.3-dev]
borei has quit [Ping timeout: 244 seconds]
galex-713 has quit [Ping timeout: 240 seconds]
EvW has joined #lisp
galex-713 has joined #lisp
even4void has joined #lisp
AmatureProgramme has joined #lisp
scymtym has joined #lisp
<beach>
Hello Josh_2.
even4void has quit [Remote host closed the connection]
narimiran has quit [Ping timeout: 260 seconds]
galex-713 has quit [Ping timeout: 272 seconds]
galex-713 has joined #lisp
karlosz has joined #lisp
sjl_ has joined #lisp
borei has joined #lisp
aartaka has joined #lisp
galex-713 has quit [Ping timeout: 240 seconds]
cantstanya has quit [Ping timeout: 240 seconds]
galex-713 has joined #lisp
shifty has quit [Ping timeout: 265 seconds]
cantstanya has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
galex-713 has quit [Ping timeout: 272 seconds]
galex-713_ has joined #lisp
drl has joined #lisp
davepdotorg has quit [Remote host closed the connection]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
secretmyth has joined #lisp
yitzi has quit [Quit: yitzi]
ramHero has joined #lisp
karlosz has quit [Quit: karlosz]
treflip has joined #lisp
enrio has quit [Ping timeout: 258 seconds]
payph0ne has joined #lisp
ramHero has quit [Read error: Connection reset by peer]
Bourne has joined #lisp
dominic34 has quit [Ping timeout: 240 seconds]
dominic34 has joined #lisp
kinope has quit [Quit: Idle for 30+ days]
enrio has joined #lisp
yitzi has joined #lisp
enrio has quit [Read error: Connection reset by peer]
secretmyth has quit [Quit: Leaving]
gko_ has quit [Ping timeout: 240 seconds]
EvW has quit [Ping timeout: 272 seconds]
<treflip>
Ooof, py4cl is a strange beast. On one machine it represents tree from nltk as a nested vector, on another machine it represents it as a python-object (0_o)
enrio has joined #lisp
mrcom has quit [Ping timeout: 265 seconds]
jibanes has quit [Ping timeout: 272 seconds]
jibanes has joined #lisp
karlosz has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
notzmv is now known as notzm
notzm is now known as notzmv
aeth has quit [Ping timeout: 244 seconds]
aeth has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
Bourne has quit [Ping timeout: 246 seconds]
zaquest has quit [Read error: Connection reset by peer]
zaquest has joined #lisp
<mseddon>
treflip: that sounds horribly b0rked.
<p_l>
treflip: check python versions as well as py4cl versions there?
<p_l>
also, check if you don't have differences in loaded libraries
<Josh_2>
treflip: did you try py4cl2?
<treflip>
Ok, will do. But I think I'll make my python program retrun str(result) and read it in lisp to make it more portable.
<treflip>
Josh_2: I wasn't aware of py4cl2 0_o
<Josh_2>
When I did some work communicating with CL and Py I used py4cl2 and it worked just fine
<treflip>
Ok, I have something a little bit more complex because I need to receive data from python process and process it in lisp.
<treflip>
mseddon: By the way, I gave up on writing a parser in CL and decided to use nltk for now >_<
karlosz has left #lisp [#lisp]
drl has quit [Quit: Ex-Chat]
karlosz has joined #lisp
Lord_of_Life_ has joined #lisp
<mseddon>
treflip: hehe, fair enough. So long as you can get the derivations, you can at least do what you want. Revisit that when you feel up to it.
<mseddon>
treflip: I hope, at least, that you are still generating your own grammar.
narimiran has joined #lisp
Lord_of_Life has quit [Ping timeout: 244 seconds]
Lord_of_Life_ is now known as Lord_of_Life
makomo has joined #lisp
makomo has quit [Client Quit]
<treflip>
mseddon: I'm writing my own mechanism for semantic interpretation. For now I want to concentrate on it. I'll replace all python code with CL when I have a working prototype, I promise :D
<Aurora_v_kosmose>
How would one generally make an executable with ecl and have it execute a given entrypoint? The only thing I can come-up with is to manually pass --eval '(my-entrypoint)' to the resulting executable and having it stop execution itself.
* Aurora_v_kosmose
has been spoiled by sbcl's niceties
<tychoish>
I'd just use asdf's :build-pathname + :entry-point
<Aurora_v_kosmose>
That would probably be the right (and easier) way to do it, but I was curious how I'd go about doing it manually.
leo_song has quit [Read error: Connection reset by peer]
<Bike>
you could look at what asdf is doing
<phoe>
Aurora_v_kosmose: I'd use Shinmera's deploy or uiop:dump
karlosz has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
drl has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
<Aurora_v_kosmose>
I'll do so. In any case, the idea I came up with seems to also work.
leo_song has joined #lisp
mindCrime has quit [Ping timeout: 240 seconds]
Misha_B has quit [Remote host closed the connection]
cosimone_ has joined #lisp
cosimone has quit [Read error: Connection reset by peer]
cosimone has joined #lisp
rippa has joined #lisp
enn has joined #lisp
cosimone_ has quit [Ping timeout: 256 seconds]
enn is now known as ennn
yitzi has quit [Read error: Connection reset by peer]
<mseddon>
ennn: or with a (quicklisp:quickload "clhs") you can then add (load "~/.quicklisp/clhs-use-local.el" 'noerror) to your ~/emacs/init.el, which is even nicer.
<mseddon>
that'll give you M-x hyperspec-lookup etc. and you can tie that into slime.
justache has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
justache has joined #lisp
kaftejiman has joined #lisp
bocaneri has quit [Read error: Connection reset by peer]
secretmyth has joined #lisp
ggole has quit [Quit: Leaving]
treflip has quit [Quit: WeeChat 2.6]
orivej has joined #lisp
yitzi has joined #lisp
Lycurgus has joined #lisp
gravicappa has quit [Ping timeout: 240 seconds]
gravicappa has joined #lisp
davepdotorg has joined #lisp
enrioog has joined #lisp
payph0ne has quit [Ping timeout: 245 seconds]
Bourne has joined #lisp
davepdotorg has quit [Ping timeout: 240 seconds]
enrio has quit [Ping timeout: 272 seconds]
edgar-rft has joined #lisp
jonatack has quit [Quit: jonatack]
dbotton has joined #lisp
yitzi has quit [Read error: Connection reset by peer]
jonatack has joined #lisp
yitzi has joined #lisp
justache has quit [Remote host closed the connection]
justache has joined #lisp
Inline has quit [Ping timeout: 272 seconds]
<dbotton>
I am considering learning and using lisp for a new project. Is there a good article or reference on concurrency programming with lisp?
Lycurgus has quit [Quit: Exeunt]
aartaka has quit [Read error: Connection reset by peer]
<phoe>
as for standard CL, you can't have that, CL is a memsafe language
<phoe>
you can try doing stuff with undefined behavior but that is no longer standard CL.
<AeroNotix>
phoe: yeah was wondering if there was a portable way to segv
<phoe>
AeroNotix: no
<edgar-rft>
isn't SEGV a C thing?
<AeroNotix>
no it's a computer thing
<AeroNotix>
all programs could theoretically do it
<froggey>
(rplaca (list nil) 42) ; implementations may implement GC write barriers using segfaults
<edgar-rft>
then please give a definition
<AeroNotix>
edgar-rft: invalid memory access
<phoe>
((lambda () (print (restart-bind ((x (lambda ()))) (compute-restarts))))) but only on SBCL
<phoe>
and this is UB anyway.
<AeroNotix>
phoe: nice
karayan has quit [Remote host closed the connection]
<phoe>
fun fact: typing (compute-restarts) in the REPL invokes undefined behavior
karayan has joined #lisp
<AeroNotix>
why?
<katco>
is there anything to reference for the size and efficiency of alists, plists, and hash-tables? i am interested in a general source, but if it helps i'm currently working on sbcl.
<phoe>
(compute-restarts) returns a list of restart objects
<phoe>
restart objects are dynamic extent
<AeroNotix>
aha!
<Bike>
but shouldn't any restarts returned be in the dynamic extent of the repl?
<AeroNotix>
btw when you deploy a Lisp image do you typically install a swank listener?
<phoe>
Bike: I can imagine a rare, but possible situation, where a restart is established around the EVAL step of the repl
mindCrime has joined #lisp
<phoe>
and that doesn't carry over to the PRINT step of the repl
<phoe>
weird and bizarre and no one really does that I think, but theoretically possible
<Bike>
hm, i guess. that would be pretty bizarre.
<phoe>
I also think this is more or less how ((lambda () (print (restart-bind ((x (lambda ()))) (compute-restarts))))) crashes SBCL, since it's fairly similar code
<Bike>
in that case the going out of extent is obvious.
<Bike>
well. "obvious". as obvious as that ever is
<phoe>
yes, correct
gaqwas has quit [Remote host closed the connection]
<Bike>
e.g. ignore dynamic-extent declarations at high safety
<phoe>
SBCL gave you a string output stream though, I think that's pretty nice
<phoe>
oh, you mean that
cosimone has quit [Remote host closed the connection]
remexre has joined #lisp
davsebamse has quit [Ping timeout: 256 seconds]
drl has quit [Ping timeout: 244 seconds]
davsebamse has joined #lisp
<Alfr_>
Just skimmed one of contrapunctus' liks above, and I am wondering whether it's valid to use #.*standard-output* if one intends to save and restore the image.
<Bike>
streams aren't externalizable unless the implementation defines them so as an extension
<Alfr_>
I don't know that, I just bound *s-o* to a var, save-lisp-and-die'd, and used that var.
<Alfr_>
It works on sbcl, which I was quite surprised that it worked. Assuming *s-o* goes to fd1, then that's definitely an other one after restarting the image.
<Bike>
oh, wait, no, i see
<Bike>
since it's only evaluated at compile time, that function isn't dumped at all, so streams don't need to be externalizable
rogersm has quit []
<Bike>
that's kind of a different question from save/load though. i dunno what's going on there.
<Bike>
the sbcl manual mentions that *standard-output* and kin have different values after loading for obvious reasons.
<Alfr_>
They seem to have papered it over. Because in my test *s-o* and the var I saved it to compared eq after restoration.
<Alfr_>
Bike, out of interest, would you explain why you initially thought that it wouldn't compile?
davepdotorg has joined #lisp
<scymtym>
in a vanilla SBCL the value of *STANDARD-OUTPUT* is a synonym stream
<Bike>
because streams aren't externalizable. you can't dump them in fasls.
<Bike>
using #. usually means the thing is externalized.
<Alfr_>
Bike, and how does that change w/ :compile-toplevel, as you've mentioned?
<Bike>
code in an eval-when isn't dumped in the fasl unless :load-toplevel is one of the situations.
<Bike>
if you compile that file, restart your lisp, and load the fasl, the function won't be defined.
<Alfr_>
Bike, ah ... I see. :D
<Bike>
actually you'll get an error, because it includes a call to that function and that call IS dumped
<Alfr_>
Hm ... but that code is possibly quite dead. In the "worst" case it lives in the compilation environment and then gets thrown away if the implementation chooses to. So, that function may simply be undefined and thus uninvokable afterwards?
<Bike>
what code, the call? the call isn't dead, it's right there in the file
<Alfr_>
I missed the call.
davepdotorg has quit [Ping timeout: 272 seconds]
<Bike>
me too, until i got the undefined function error
<Alfr_>
Many thanks for the clarification on this one. :)
<Bike>
mhm. eval-when and externalization are both very complicated parts of the spec that people don't think about much.
<Alfr_>
scymtym, so my envisioned problem happens a little bit further down and sbcl hides that form us by fixing the synonym stream on restore?
<scymtym>
Alfr_: there has been some recent change, but what i remember is that SB-SYS:*STDOUT*, the target of the synonym stream, is bound to a new stream after the restart. the synonym stream will then automatically use the new underlying stream
<Alfr_>
scymtym, good to know. But I still have no intention to abuse that.
<edgar-rft>
AeroNotix: Wikipedia defines "segmentation fault" as "A segmentation fault occurs when a program attempts to access a memory location that it is not allowed to access, or attempts to access a memory location in a way that is not allowed (for example, attempting to write to a read-only location, or to overwrite part of the operating system)."
sjl_ has quit [Ping timeout: 265 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
<edgar-rft>
According to that definition is trying to modify a symbol in the COMMON-LISP package a segmentation fault for example.
contrapunctus has joined #lisp
hiroaki has quit [Ping timeout: 240 seconds]
Oladon has quit [Quit: Leaving.]
iamFIREcracker has joined #lisp
Oladon has joined #lisp
iamFIREcracker has quit [Ping timeout: 264 seconds]
davepdotorg has joined #lisp
liberliver has quit [Remote host closed the connection]
liberliver has joined #lisp
davepdotorg has quit [Ping timeout: 272 seconds]
sjl has quit [Quit: WeeChat 2.2-dev]
iamFIREcracker has joined #lisp
terpri_ has joined #lisp
terpri has quit [Ping timeout: 244 seconds]
iamFIREcracker has quit [Ping timeout: 256 seconds]
Inline has joined #lisp
Stanley00 has joined #lisp
ayuce has quit [Remote host closed the connection]