<clhelp>
To see if a variable was passed in with a default value
<moon-child>
oh, I see. Hmm
<clhelp>
Was trying to get it to take the same argument structure as let
<moon-child>
you can use (cadr genvar) rather than (car (cdr genvar)). You might want to further ensure that the passed structure is a proper two-element list
<clhelp>
Hm, oay
<clhelp>
okay*
<moon-child>
I would also consider first doing a pass on 'vars' to homogenize it (turn (a (b 2) c) into ((a nil) (b 2) (c nil))), so that way you don't have to duplicate the branch
<clhelp>
Alright
<moon-child>
but that's a matter of taste; since you're only iterating through the list twice, it's not a big deal either way
<clhelp>
Still a bit confused about the stray comma in the nested let...
<clhelp>
Oh, okay
<moon-child>
what don't you understand about the second comma?
<clhelp>
The macro generates an extra comma in the nested let; before the variable list, specificaly
kevingal has quit [Remote host closed the connection]
lisp123 has quit [Ping timeout: 268 seconds]
taiju has quit [Ping timeout: 258 seconds]
pjb has quit [Remote host closed the connection]
taiju has joined #commonlisp
Nilby has joined #commonlisp
Inline has quit [Remote host closed the connection]
Inline has joined #commonlisp
wheelsucker has quit [Remote host closed the connection]
wheelsucker has joined #commonlisp
blihp has joined #commonlisp
prxq has joined #commonlisp
prxq_ has quit [Ping timeout: 265 seconds]
beach` has joined #commonlisp
beach has quit [Ping timeout: 250 seconds]
beach` is now known as beach
dsk has joined #commonlisp
<beach>
Good morning everyone!
<Josh_2>
Mornin'
bhaible has quit [Remote host closed the connection]
bhaible has joined #commonlisp
bhaible has quit [Remote host closed the connection]
bhaible has joined #commonlisp
cmack has joined #commonlisp
karlosz has joined #commonlisp
karlosz has quit [Client Quit]
lisp123 has joined #commonlisp
<blihp>
I'm curious if anyone can point me in the direction of any work regarding quantifying and comparing the shape of structured data (graphs in particular)?
<beach>
Stuff like that is often NP-complete.
<blihp>
no 'good enough' approximations that you're aware of? I'm looking for something that gets me in the ballpark rather than extreme precision or accuracy
<blihp>
i.e. something to tell me whether or not I need to take a closer look at two or more graphs
<beach>
I suspect the kind of acceptable approximations greatly depend on the application, which is why I don't think there is any general algorithms.
<blihp>
fair enough. that explains why I'm not finding much :-)
<beach>
I may be wrong, but I suspect you are out of luck.
<moon-child>
there was a paper recently about merging identical or partially-identical function bodies in llvm that might be of interest. But I agree with beach: it's hard to give a general answer without knowing more about the problem domain
<beach>
clhelp: I am not going to attempt to debug that. Double backquotes are messy. But ,, is usually a bad sign.
<clhelp>
There's an extra comma in the nested let, and I have no idea why
<kathe>
sort-of off-topic; would anyone know whether LispWorks (except the IDE) is written mostly in CommonLisp just like SBCL is (unlike Clisp's case)?
<clhelp>
Sure; do you know if there's a better way to write this?
<beach>
clhelp: I think there should be a comma before each VAR.
<beach>
You don't want literal VAR1, VAR2, and TESTVAR in the expansion.
<kathe>
i am on a GUI IRC client now, one which does not show the welcome messages while joining the commonlisp channel, would someone please share the link for the log?
<clhelp>
Yeah... that's another issue
<beach>
kathe: Probably.
<clhelp>
Here's the intended output: https:/0x0.st/-fLN.txt
<clhelp>
Yeah, though the loop is executed, so clearly the ,, is being interpreted correctly
<beach>
kathe: It would be insane to write the better part of a Common Lisp implementation in anything but Common Lisp.
<beach>
kathe: In fact, Common Lisp would be a good choice for any compiler-related work. I am amazed that the GCC and LLVM people use such low-level languages for it.
<kathe>
beach: true, but ultimately, the base interpreter is written in something like C or assembly, but in the case of Squeak (Smalltalk) the whole system is written in Smalltalk-80 and then internally compiled to create native systems for working with Squeak itself. Sort of a meta-compiler.
<clhelp>
This is probably not a great way to write with-gensyms anyway, since it backquotes the forms passed to it
<clhelp>
Would be nice to know why it doesn't work, though
<beach>
kathe: What "base interpreter" are you talking about?
<beach>
kathe: Most modern Common Lisp systems don't have an interpreter at all, and the compiler is written in Common Lisp.
<clhelp>
SICL includes a large amount of C, yeah?
<beach>
clhelp: There is not a single line of C in SICL.
<kathe>
beach: if there's no base interpreter, how does the REPL work? something has to interpret that isn't it?
<clhelp>
Oh, hm... wonder hat I am thinking of, in that case
<clhelp>
what*
<beach>
kathe: No, it is compiled on the fly. Read-Compile-Execute-Print.
<beach>
kathe: Misconceptions like that are often the reason people avoid interactive languages, because they think: interactive => interpretation => slow.
<kathe>
beach: I think you're mistaken. The base system has to be an interpreter, just like the first Lisp coded up by McCarthy's intern in assembler even though he was specifically told to write a compiler, he'd written an interpreter.
<moon-child>
beach: I thought sicl (or cleavir?) includes an ast interpreter?
<moon-child>
kathe: obviously you have to bootstrap somehow. That does not mean you have to have an interpreter
<beach>
moon-child: Only for bootstrapping.
<beach>
kathe: I guess my decade of work on SICL was in vain then.
<clhelp>
kathe: SBCL's repl, at least, compiles its input
<kathe>
beach: Clisp has it's interpreter written in C.
<beach>
kathe: Yes, I know.
<kathe>
beach: the rest of Clisp is in Common Lisp.
<moon-child>
yes, clisp is a lisp interpreter written in c. That is not a categorical statement
<beach>
kathe: CLISP is odd in that respect.
<kathe>
beach: I guess SBCL and other's have have their interpreters written in Common Lisp which are then compiled into native binaries while building. But they also must have compilers to compile Common Lisp to native code while generating binaries of other Common Lisp applications written in them.
<beach>
kathe: It is great that you brought up that issue, because it is essential that you understand that an interpreter is not required.
<beach>
kathe: SBCL does have an interpreter, but it is not usually used. And SICL doesn't have an interpreter, and won't have one later either.
<kathe>
beach: then why does Lisp lore talk about the revolt by McCarthy's intern who realised that it would be wiser to write an interpreter first to run Lisp and then write a compiler in Lisp for building application binaries?
<beach>
kathe: The input is read by READ which is written in Common Lisp. Then it is compiled using the compiler, which is written in Common Lisp. The output of the compiler is native executable instructions for the processor in question. Then those instructions are executed by the processor.
karlosz has joined #commonlisp
<kathe>
beach: it was that first revolt which created the interpreter which led to the REPL which changed everything by bringing in bottom-up style of writing code.
<beach>
kathe: In 1958 they didn't have any Lisp system to bootstrap from. Now we do.
<blihp>
kathe: you're talking about 50+ years ago... radically different expectations and hardware capabilities
<kathe>
blihp: 50+ years ago, compilers were more preferable than interpreters.
<kathe>
that is why McCarthy insisted on a compiler.
<kathe>
but that smart intern wrote an interpreter instead.
<beach>
kathe: As blihp points out, things are different now.
<kathe>
beach: okay.
<beach>
kathe: We have excellent existing Common Lisp implementations that can be used for bootstrapping.
<kathe>
beach: most Common Lisp implementations depend on Clisp for bootstrapping them on new platforms.
<beach>
So?
<kathe>
because Clisp is written in C which is simpler and easier to port to newer architectures.
<beach>
kathe: So SICL is written entirely in Common Lisp. And I use SBCL (at the moment, but any conforming implementation will do) for bootstrapping.
<kakuhen>
isn't ECL written in C as well? I swore some Linux distributions use ECL to bootstrap SBCL
<kakuhen>
more so than CLISP nowadays
lad has quit [Ping timeout: 268 seconds]
<beach>
kathe: Superior to what?
<beach>
kathe: Like I said, interpreters are slow, so if most Common Lisp systems were interpreted, then even fewer people would consider Common Lisp.
<kathe>
beach: try moving a pure Common Lisp implementation across architectures without having a native Common Lisp environment for the newer architecture. Good luck with that.
<kakuhen>
kathe: doesn't cross-compilation make this point a bit moot?
<beach>
kathe: Same problem with any language, including C. You just cross compiler.
<beach>
*cross compile.
<blihp>
kathe: lots of ways to skin that cat
<kathe>
beach: C usually is provided the luxury of a full-blown native development environment by the provider of the newer architecture.
<Mrtn[m]>
Poor cat ...
<kakuhen>
kathe: I recall asking a question here a few weeks ago on how people would introduce a Common Lisp implementation on a new architecture where one already doesn't exist, and I got a good answer from phoe. In short, cross-compilation is useful here.
<kathe>
kakuhen: okay.
<beach>
kathe: I am not sure what your point is. Are you saying we should stop writing Common Lisp systems that generate efficient code, and perhaps also abandon the ones we have?
<kakuhen>
I should have their explanation stored somewhere in my logs and send them, if that's not against any rules here
<kathe>
beach: that is extreme. I mean, interpreters are vital to provide a richer REPL experience.
<blihp>
in the end, it really depends on what the *particular* implementation needs
<moon-child>
kathe: if you would like your compiler to run at all on the target architecture, it will have to generate code for the latter. Which being the case it's a smop to make it cross-compile for that architecture
<kathe>
beach: Even Perl5 code is compiled by it's "interpreter".
<beach>
kathe: The compiler has a code-generation phase. You just write a code generator for the new architecture and then run the code generation on an existing system.
<beach>
kathe: Interpreters are absolutely not necessary for a REPL, as SBCL and others show, and it is essential that you understand that.
<kathe>
beach: okay, understood.
<moon-child>
kathe: a compiler can arguably provide a richer repl experience than an interpreter, because it is likely to perform more static analysis of the code it compiles
<Mrtn[m]>
Beach, interesting angle. I used to think that with the improvement of hardware, pseudo architectures like Java-bytecode might become increasingly interesting.
<moon-child>
if anything. In practice the difference is likely to be negligible
<moon-child>
Mrtn[m]: jvm and llvm are not uninteresting, but you still have to write a compiler for them
<kakuhen>
yeah honestly I don't really think twice about whether I am interpreting or compiling lisp code when I work on a project
<kakuhen>
SLY is good at hiding the ugly details from me, and I just know that C-c C-c on the relevant region will update my program
<beach>
kakuhen: That's because you don't have to, and that's because people write compilers for you that generate efficient code.
<kathe>
kakuhen, the first thing that comes to mind when-ever i encounter any new language/programming-system is whether it is compiled or interpreted.
<beach>
Mrtn[m]: I agree with moon-child.
<kathe>
beach: thanks for the clarification about modern Common Lisp.
<beach>
Pleasure.
<Mrtn[m]>
moon-child: But only once, and that could be a highly optimised jit-compiler for good measure, I guess.
<kathe>
kakuhen, I don't use Emacs and it's environment, so that never happened to me.
<Mrtn[m]>
beach: Java-bytecode was just meant as an example. I think we need something that supports native threads.
<beach>
Mrtn[m]: That approach is good in theory, but existing virtual machines are often not such a good fit for Common Lisp.
<kathe>
kakuhen: I write code in a separate editor and load it in the REPL in a separate window.
<moon-child>
Mrtn[m]: the other problem is that such architectures tend only to be suited to a relatively narrow body of languages. The jvm does well enough for java, but it would not do a good job of compiling common lisp or haskell, which is why common lisp and haskell implementations do not (generally) target it
<blihp>
Mrtn[m]: see the opensmalltalk vm for an example of what I think you're describing... it scales from a bytecode interpreter to a highly performant JIT compiler in a single architecture
<Mrtn[m]>
beach: Exactly. 😁
<blihp>
very handy for porting to new architectures
<kakuhen>
kathe: the ability to move a pointer to any region in a buffer and evaluate a lisp expression (or compile a region of lisp code) really made me rethink REPLs
<kakuhen>
coming from python, I used to find REPLs as a very "rigid" and 1-dimensional thing, and my view changed after using emacs for a long enough time
<moon-child>
similarly the raku people made their own vm in no small part because no existing vm could efficiently implement their variety of dynamic dispatch. By the same token, their vm, though generic, is unlikely to see many targets because of the overhead associated with its dispatch
<Mrtn[m]>
Blihp: Cool. I never looked into small-talk. I thought it was an interior programming language for the Macintosh machine.
<kathe>
kakuhen: I personally think Emacs and it's toolkit is overly hyped up. Especially when compared to commercial IDEs like LispWorks.
<kakuhen>
it probably is, but most of us probably don't want to drop $1,000+ on a lisp compiler (yet)
<Mrtn[m]>
Kathe: How many decades have you worked with Emacs?
<kathe>
it's not just a compiler, it's full environment.
<kakuhen>
I'm aware.
<moon-child>
isn't there a free version of lispworks?
<blihp>
Mrtn[m]: it's been multi-platform since the 80's
<kathe>
Mrtn[m]: I hated Emacs ever since I touched it 25 years back.
<kakuhen>
kathe: CAPI looks very interesting, but I first want to see how the "modernization" efforts in McCLIM go before I try it out
<Mrtn[m]>
kathe: Then you're biased. 😁
<kathe>
Mrtn[m]: I was raised on edit.com and then "vi".
<Mrtn[m]>
bliph: Oh, so it did start out on a Mac?
<kakuhen>
kathe: CAPI is the one 'killer' feature in LispWorks to me, since it seems to provide something that sounds as good as qtools but not have the headaches associated with ffi madness
<blihp>
Mrtn[m]: you're thinking of Squeak which originated on a Mac in the 90's when Allan Kay got the band back together at Apple for a while
<kakuhen>
I know that Clozure CL has an objective-c bridge and you can treat objective-c objects as CLOS objects (which is really slick), but it's been largely unmaintained and I haven't gotten it to work on any modern Mac, yet.
<blihp>
but it was very quickly ported to windows and linux
<Mrtn[m]>
Kathe: I used VI until I figured out how to use Emacs.
<kathe>
kakuhen: there are many "killer" features in LispWorks, the most important one being it is so tightly integrated with the visual graphical toolkit to aid development.
<blihp>
kakuhen: that's a bummer. it used to be very nice (I haven't used it in over a decade though)
<Mrtn[m]>
Blihp: Yeah, that's when I first heard of it. Start 90's.
<kakuhen>
objective-c is a bit of an oddball since you are able to create and inspect objects at runtime (much like CLOS), but a very big difference from Common Lisp is that you do not have access to the compiler at runtime, whereas in Common Lisp I think you do (please correct me if this is wrong)
<blihp>
I'm actually troubleshooting some Smalltalk stuff on Linux right now which is why I'm futzing around in IRC... I don't feel like working :-)
<kakuhen>
so being able to write graphical mac programs with this bridge sounds awesome to me, but i sadly havent gotten it working
<kakuhen>
it's mostly due to the extra commands that happen when you (require 'cocoa-application) or whatever the name was
<Mrtn[m]>
Kathe: I wouldn't regress to a proprietary development tool now. I'd rather write my stuff with /bin/ed
<kakuhen>
it tries to create some folders and files in /usr/local/share (or /opt/local/share), which typically doesn't offer your user write access
<kakuhen>
so CCL immediately drops into the debugger over the failed writes
<blihp>
all I can tell you is that even when it was working, the obj-c bridge was pretty manual (at least when I was using it)... but it was very, very nice if you didn't mind wrapping the frameworks yourself
<kathe>
Mrtn[m]: "ed" is the one true editor. 😁️
<Mrtn[m]>
Kathe: The "standard". 😀
<kathe>
Mrtn[m]: 🤣️
<kathe>
beach: can you share the URL for SICL?
<kakuhen>
blihp: right, i understood implicitly that I will have to programmatically set up NSWindows and constraints
<kakuhen>
thankfully my exposure to interface builder in the past weeks has convinced me more and more of "going nibless"
<kathe>
Google shows results for sickles.
<blihp>
are you on an old version of os x? I thought they deprecated IB years ago
<blihp>
(I have not kept up at all with the state of the art on the mac side)
<kakuhen>
blihp: interface builder is not deprecated at all. It is "deprecated" for iOS apps in the sense that you must provide a splash screen as a storyboard (making pure IB programs impossible to submit to app store), but that's all.
<beach>
minion: Please tell kathe about SICL.
<minion>
kathe: SICL: SICL is a (perhaps futile) attempt to re-implement Common Lisp from scratch, hopefully using improved programming and bootstrapping techniques. See https://github.com/robert-strandh/SICL
<beach>
kathe: It is not finished, so don't try to use it.
<blihp>
ah, cool. I actually liked IB quite a bit when I was doing obj-c stuff
<kakuhen>
I like IB, until the inevitable insertion of constraints.
<kakuhen>
I'm assuming that will annoy me a lot if I ever get the obj-c bridge in ccl workoing
<kakuhen>
working*
<kakuhen>
i cant imagine writing all of that in code when through ib it's already very sensitive and results often differ at runtime
<clhelp>
Since there're a few more people here now, I'll try and post my question once more; does anyone know what's wrong with this macro: https://0x0.st/-fLP.txt
<clhelp>
Specifically, why is there an extra comma in the nested let?
<clhelp>
(The generated one, that is)
<beach>
Not only is McCLIM being worked on ("modernized"?) but some of us are (slowly) working on an IDE for Common Lisp.
<kathe>
beach: can you share some links to details about that IDE for Common Lisp?
<clhelp>
beach: Are you behind the climacs project? Currently a vim user, but would use a non-elisp emacs-like in a heartbeat
<beach>
The hope is that the user experience of writing Common Lisp code is going to be unbeatable by anything else. We still have a ways to go, though.
<clhelp>
And by non-elisp, I probably mean common lisp
<beach>
kathe: There is no single project at the moment. There are bits an pieces though, like Clouseau in McCLIM.
<blihp>
beach: it was a pleasant surprise to see how well the pieces of that are shaping up... I definitely got a flavor for where you're going with it
<beach>
clhelp: yes, and we are working on Second Climacs, which is version 2.
<beach>
blihp: Great! Thanks!
<clhelp>
Thanks for doing that!
<beach>
clhelp: Actually, scymtym is the one working directly on those parts right now.
<clhelp>
Oh, okay
<beach>
clhelp: I designed the incremental reader for the Common Lisp buffer.
<Guest82>
the maximum time, load time, and setup time, and that fixed that issue for me
<Guest82>
I was trying to figure out where those settings are called in the sbcl bin
<Guest82>
or in ros
<Guest82>
but couldn't figure it out
<Guest82>
I think the issue is just that, that my computer is a bit slow, and I need to pass on some setting to the sbcl, or ros, to give it a longer timeout before declaring an error like network down
<Guest82>
Do you know how I can do that?
<Guest82>
Where is the best place to ask a question like this? here or overflow?
<beach>
Probably here.
<Guest82>
ok, so at least I'm int he right place. Was the question clear? Should I just wait in the hopes that someone will answer or if I didn't get an answer relatively quickly I should despair???
<Guest82>
I've been dealing with this for a few days now...
<Guest82>
btw thanks for replying to me! It makes me feel like I'm not just being ignored
<beach>
This is Sunday lunch time in Europe, and many people here have families that they would rather spend time with on a Sunday.
<Guest82>
oh, I hear
<beach>
And it is not the domain of expertise of everyone. Many people here are interested in how Common Lisp is implemented for instance, and not so much in web applications. That is certainly my case.
<beach>
So you may have to be patient.
<beach>
Oh, and Fukamachi-ware is notoriously badly documented, so some people stay away from it for that reason.
rgherdt has joined #commonlisp
[deleted] has quit [Read error: Connection reset by peer]
livoreno has joined #commonlisp
<Guest82>
ok, thanks for letting me know
shka has joined #commonlisp
kevingal has quit [Remote host closed the connection]
Lycurgus has joined #commonlisp
<blihp>
Guest82: for a small (in terms of users) project like that, I generally have more success contacting the author directly (try opening an issue on github) as finding other users of the library may be difficult
<Guest82>
ok, thanks, I thought it's not really an issue with his library, rather an issue with how can I call roswell
<Guest82>
Who should I contact? qlot or roswell?
<Guest82>
blihp thanks for getting back to me!
<blihp>
don't know... I'm not familiar with the packages.
<blihp>
got to head out... sorry I couldn't be more help
<Guest82>
blihp thanks for trying!
xsperry has quit [Remote host closed the connection]
blihp has quit [Ping timeout: 240 seconds]
xsperry has joined #commonlisp
Guest82 has quit [Quit: Client closed]
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
pjb has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
tyson2 has joined #commonlisp
IAmRasputin has joined #commonlisp
IAmRasputin has quit [Ping timeout: 240 seconds]
domovod has joined #commonlisp
random-nick has joined #commonlisp
kakuhen has quit [Quit: Leaving...]
treflip has quit [Remote host closed the connection]
cage has joined #commonlisp
<shka>
lol, alloy does not even depends on the alexandria
<shka>
it uses it for tests though
Alfr has joined #commonlisp
igemnace has quit [Quit: WeeChat 3.2]
derelict has joined #commonlisp
<shka>
Shinmera: hey, what is the alloy-glfw and when i can get it?
<shka>
it seems that examples depend on it
<Shinmera>
?
<shka>
right, some context is needed
<shka>
i just download alloy, and was planning to tinker with it
<Shinmera>
it's... in the source? alloy/renderers/glfw/alloy-glfw.asd
<shka>
oooh
<shka>
i wonder why ag failed to find this asd file
<shka>
Shinmera: sorry for the hassle
<shka>
oh, it did not failed, it just listed it on the very bottom :D
froggey has quit [Ping timeout: 252 seconds]
<shka>
Shinmera: it all works just fine
froggey has joined #commonlisp
igemnace has joined #commonlisp
<Shinmera>
Not really. The GLFW backend uses fond for rendering text, which has several issues. The MSDF text renderer is leagues better, but atlas generation is broken right now.
<shka>
Shinmera: well, examples look fine for me, but i don't know how they are supposed to look
attila_lendvai has joined #commonlisp
<Shinmera>
they'll probably look fine, the devil's in the details
<Shinmera>
(text wrapping, text bounding, glyph rendering, etc.)
<shka>
ah, ok
<shka>
any tips on what parts of the code to read to be able to implement my own widget?
[deleted] has joined #commonlisp
tyson2 has quit [Ping timeout: 265 seconds]
livoreno has quit [Ping timeout: 272 seconds]
<shka>
Shinmera: anyway, code looks really slick, and examples are easy to understand
<Shinmera>
uuuuh
<Shinmera>
not sure what you mean by widget, and also not sure I know good starter points in general.
<Shinmera>
haven't had time to concern myself much with that stuff.
<shka>
well, let's say that i want to render a button, but this time triangle :-)
<shka>
i mean, a triangle button
<Shinmera>
you'll need to either define a button subclass and use presentations:define-realization, or use the :shapes initarg... if I recall right? That stuff is part of the presentations stuff, renderers/simple/presentations/
<shka>
i will take a look there, thanks for help
<shka>
have a nice sunday
easye` has joined #commonlisp
easye` is now known as easye
rgherdt has quit [Remote host closed the connection]
kathe has joined #commonlisp
kathe has quit [Client Quit]
notzmv has quit [Ping timeout: 265 seconds]
tyson2 has joined #commonlisp
char has joined #commonlisp
Inline has quit [Quit: Leaving]
Inline has joined #commonlisp
d4ryus has quit [Quit: WeeChat 3.2]
d4ryus has joined #commonlisp
<Josh_2>
'ello
<Josh_2>
Anyone know if ChanL spawns a new thread each time pexec is called or if it grabs a running thread from a pool?
Guest82 has joined #commonlisp
varjag has joined #commonlisp
<Alfr>
Josh_2, it's SEND won't. It just tries to put VALUE into some channel.
<Guest82>
Hi, I'm getting socket errors saying the network is down, but really it's because my computer is slow... Does anyone know where to change an argument to make the timeout longer so that I can run the app?
<Alfr>
You'd have to create worker threads which receive-process-loop on such channels and manage them.
<Guest82>
I had this issue with slyblime and changed it there in the settings, now I'm trying to run some lisp code from the terminal as a bash program and I don't know where to fix
<Guest82>
Alfr is that for me?
<Alfr>
Guest82, no, it's for Josh_2. You just happened to pop up unexpectedly. ;)
<Guest82>
Alfr Oh ok, thanks
<Guest82>
Does anyone know is there an argument to pass into sbcl command line to make it wait for a response longer before declaring that a network error is down or that a problem is happening?
<Josh_2>
there is a lot of overhead when creating os threads
<Josh_2>
I am surprised that chanl has gone with that
pjb has quit [Ping timeout: 258 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #commonlisp
Nilby has joined #commonlisp
Noisytoot has quit [Ping timeout: 240 seconds]
tyson2 has quit [Ping timeout: 256 seconds]
<etimmons>
Guest82: To answer your direct question, I don't think there is one. That's likely to be something the application creating the socket is responsible for.
<etimmons>
But I also doubt that's your actual problem. The error in your pastebin is network down, not a timeout.
<char>
Does anyone know what is happening with cl-password-store. It look exactly what I want, but it looks to have some major issues
<minion>
char, memo from phoe: <> is often called a diamond so it becomes pronunciable
<Alfr>
Josh_2, that's not what I said. You have to create those receive-process-loop threads upfront.
<Josh_2>
char: I wrote a basic file based password store
<Guest82>
etimmons Thanks for getting back to me! Yeah, the reason I thought so is because I was also having problems developing on hunchenhoot in sublime text's slyblime and this solved the issue: https://github.com/s-clerc/slyblime/issues/11
<Guest82>
Changing the variables there of loading_time, setup_time, and maximum_timeout
<Josh_2>
Alfr: ah okay
<Alfr>
Josh_2, so bare bones for such a thread could be simply running the following thunk: (lambda () (loop (process (receive some-channel))))
<Josh_2>
oh I see
<Alfr>
s/receive/recv/g
<Guest82>
etimmons otherwise I didn't know where to go from here. I thought it reports network down because it doesn't wait long enough for a response from the server... when installing things with qlot, it happened a few times and if I ran the command right away it would work finishing the download, and would break again with another download, so I had to
<Guest82>
just run the command successively a few times till it worked, but the same didn't work with running the server...
<Guest82>
I'm new at lisp, I've been trying to use it for a project to learn it, but I keep getting bogged down by these types of errors for which I don't know where to turn for answers... I worked as a software developer doing serious back end web development with big data and a bunch of different systems, so I figured I would be able to work on lisp for a
<Josh_2>
That could be useful Alfr, allows me to easily just send commands to be executed in the background
<Guest82>
web app as well...
<Josh_2>
type errors?
<Josh_2>
oh sorry 'types of errors'
<Josh_2>
Guest82: not sure if anyone in here uses Sublime, most use Emacs or Vim
<Josh_2>
Guest82: imo you should either just use Clack or Hunchentoot and then add on functionality you need from external libraries
<char>
Josh_2: Do you accept contributions, could I add asd and maybe salting?
<Guest82>
Josh_2 thanks. I tried using Hunchentoot and it worked well, I was hoping to use something more in par with regular web dev frameworks and not feel like I have to reinvent the wheel... but probably that's more lispy, to put the system together myself?
<Josh_2>
char: sure
<Guest82>
Can anyone try to replicate what I did to determine if it's an issue with my system or the software? Here are the steps I took https://pastebin.com/LGUcmUkH based on the getting started here: https://github.com/fukamachi/utopian Note that the DB part can be skipped...
<Josh_2>
Guest82: Unfortunately we dont have an epic web framework, probably because CL makes the individual so productive you dont need one
<shka>
Guest82: i will try to replicate this
<shka>
give me a second
<shka>
Guest82: System "utopian/main" not found
<Guest82>
Josh_2 haha thanks, yeah, that's why I'm trying to learn... but it's a bit of a bumpier road than most others so far
<Guest82>
shka Thanks!
<Guest82>
shka Sorry, missed a set: "Ensure ~/.roswell/bin is in your shell $PATH.
<shka>
well, glad to be of assistance i guess
<Guest82>
shka that was for you to be able to replicate :D
<Guest82>
hehe sorry, my bad
<shka>
i think that it is in my path already
<Guest82>
I forgot to include that step in the paste bin
<Guest82>
oh
<Guest82>
hum, can you open a new bash session or terminal or reload the path?
<shka>
export PATH=$PATH:~/.roswell/bin
<shka>
yup
<shka>
i am pretty sure that my setup is fine
<Guest82>
and it still didn't work with a new terminal session?
<shka>
no, the same error
<Guest82>
strange, give me a sec
<Guest82>
this worked well "ros install fukamachi/utopian"?
<shka>
:depends-on ("utopian/main")
<Josh_2>
fukamachiware
<shka>
i think that readme is missing something, honestly
<shka>
anyway, i got to go
<shka>
sorry that i can't help
<Guest82>
can you check ~/.roswell/bin/utopian is actually there? ls ~/.roswell/bin
<Guest82>
ok, thanks for trying shka!
<shka>
Guest82: no, just lem
<shka>
which i installed befored
tyson2 has joined #commonlisp
<Guest82>
oh, can you try running again "ros install fukamachi/utopian"
<Guest82>
ros install fukamachi/lsx
<shka>
i can, but i won't there will be the same result
<Guest82>
ros install fukamachi/qlot
<shka>
yeah, lsx istalls
<Guest82>
strange, seems like the installs are not working, for me they worked...
<shka>
qlot does not
<shka>
anyway, i am pretty sure that this is the issue for me
<Guest82>
hm, oh well, I guess we tried, each one got stuck at a different step, thanks again!
<shka>
well, the line above this one
<Guest82>
got it
<shka>
this whole system supposed to depend on the uotpian/main
<shka>
and utopian/main is not found
<shka>
so that's it i guess
<Guest82>
ok, thanks shka
<Guest82>
as an aside for learning how to debug things, how would I go about finding out where in the code is this issue? https://pastebin.com/rYuT3igz
Noisytoot has joined #commonlisp
kevingal has joined #commonlisp
<Guest82>
Josh_2 is caveman2 also good? I tried using caveman2 for a todo app and it worked, meaning I was able to figure out how to use it, radiance seemed cool but didn't end up going through TLDR... Why is Clack more accepted? Just because it's an abstraction layer?
blihp has joined #commonlisp
<Guest82>
I can put things together from external libraries, but that's exactly what it seemed that this utopian project is doing...
blihp has quit [Client Quit]
blihp has joined #commonlisp
<Josh_2>
Personally never used roswell or any of the external tools for managing lisp projects, other than quicklisp ofc
<Josh_2>
Also I just use hunchentoot, although if I knew I had a high traffic project then I'd use clack because it supports Woo as a backend
<Josh_2>
like if I was writing an application service for Matrix then I would use Clack because Woo is so fast
<Guest82>
Have you used Woo or just saw the claims?
lucerne has quit [Remote host closed the connection]
<Josh_2>
Nope, not sure what sort of performance I could squeeze out of hunchentoot if I tried quux-hunchentoot
<jackdaniel>
being twice as fast as 1ms gives you 2ms, if you don't own gazillion computers with gazillion^2 connections then this doesn't matter
<jackdaniel>
mind that performance ususally comes at the maintanance cost
<Guest82>
ok, thanks Josh_2 and jackdaniel for the input
<Guest82>
Will try to take it from here, we'll see how it goes
<Josh_2>
jackdaniel: this is why I normally just use hunchentoot, I prefer the extensibility of hunchentoot and I'm not concerned with the speed
<Guest82>
Are there any commercial projects that actually use lisp for a web app? besides the flight company?
<loke[m]>
I've gotten good enough performance from hunchentoot
<Josh_2>
plus you can use a server like Nginx to serve content like images
<Josh_2>
Guest82: do my own count?
<contrapunctus>
Guest82: Bevuta GMbH uses (and develops) CHICKEN Scheme...and for CL there's also Grammarly, if I remember correctly.
<contrapunctus>
Guest82: also, does GOAL and GOOL count? At least one of them was implemented using Common Lisp. Naughty Dog seems to use Racket these days. https://youtu.be/Ox2H3kUQByo?t=2274
<shka>
oh god, that dangling parenthesis
<char>
Josh_2: I notice that you use a lot of CHECK-TYPE. Is there a reason for that over declare type?
<Josh_2>
contrapunctus: the dropped parens :(
<shka>
char: there is
<shka>
char: declare type does not mandates that type is checked
<shka>
instead, compiler may trust you that the type is a specified
<char>
shka: ah, sbcl does mandate though right?
<shka>
SBCL will omit the type check, when speed is 3 and safety 0
<shka>
i think
<shka>
i mean, it will do that for sure when speed is 3 and safety 0
<shka>
i did not dig into manual to check for sure
<contrapunctus>
shka, Josh_2: maybe it's a new kind of #lang 😏️
<shka>
anyway, i advice to use check-type if you want portable and solid behavior on the past, current and the future SBCL versions
<Josh_2>
char: I wrote that bit of code quite a while ago :O if I went through it now I'd probably get rid of them
<shka>
anyway, does not change my statement, check-type is a better pick if you just want to check type
<char>
in terms of preformace, I think compiler can optimize on declare, but can it optimize on check-type?
<jackdaniel>
char: it can; what's more in general sense it can't optimize solely based on declare (i.e it needs to insert the type check in order to optimize), otherwise you may get segfaults and other fancy things
<Josh_2>
char: I did a quick update on trivial-password-store, added an asd and a package
<char>
Josh_2: nice, no exports?
<Josh_2>
added
waleee has joined #commonlisp
Guest82 has quit [Quit: Client closed]
derelict has quit [Quit: WeeChat 3.2]
greyrat has quit [Quit: Bye]
<Josh_2>
char: changed a few other things
<Josh_2>
Sorry I meant *broke* a few things
cage has quit [Read error: Connection reset by peer]
<Josh_2>
Okay unbroken
<lisp123>
why do companies move away from CL after developing applicaitons in it
<lisp123>
e.g. reddit
<lisp123>
seems strange for anyone who has programmed CL to a reasonable degree
<lisp123>
perhaps the original engineers were sidelined by the political type?
<Josh_2>
reddit said it was because of libraries
<Josh_2>
but times have changed
<Josh_2>
lots of libraries exist now :D
<lisp123>
Yeah there is a lot now
<lisp123>
QuickLisp really is world-class compared to other languages
<lisp123>
ONE line and you have a full library to use
<Josh_2>
Quicklisp does make things easy
greyrat has joined #commonlisp
lucerne has joined #commonlisp
<char>
quicklisp is very good. I've also been trying out guix, and it is pretty nice too.
cage has joined #commonlisp
<lisp123>
what is guiz
<lisp123>
guix*
susam has left #commonlisp [#commonlisp]
susam has joined #commonlisp
treflip has joined #commonlisp
treflip has quit [Remote host closed the connection]
amb007 has quit [Ping timeout: 272 seconds]
treflip has joined #commonlisp
amb007 has joined #commonlisp
Guest82 has joined #commonlisp
<Josh_2>
GNU Guix
derelict has joined #commonlisp
<hendursaga>
lisp123: it's GNU Guile based mind you
<lisp123>
thanks Josh_2 and hendursaga
<lisp123>
I've herad good things about GNU Guile, its on my list to check out as I complete my transformation into a GPL / FSF supporter
<hendursaga>
lisp123: you mean, cult follower? :)
<lisp123>
hendursaga: Exactly :) I had the word on the tip of my tongue but couldn't find it
<Josh_2>
I used Guile in a university project
Lycurgus has joined #commonlisp
domovod has quit [Quit: WeeChat 3.2]
<Josh_2>
Condition variables stop spinning right?
bhaible has quit [Remote host closed the connection]
bhaible has joined #commonlisp
<Josh_2>
maybe its semaphores
<char>
Josh_2: This is quite an ... interesting way of printing objects
<Josh_2>
in that password store?
<char>
yes
<Josh_2>
Well I did make it in a couple hours as a challenge for some discord server i was in
treflip has quit [Remote host closed the connection]
lisp123 has quit [Remote host closed the connection]
<char>
It seems like it needs some work before it is really usable
lisp123 has joined #commonlisp
cammie has joined #commonlisp
cammie has quit [Client Quit]
lisp123 has quit [Ping timeout: 268 seconds]
<Josh_2>
What do you think needs doing?
<char>
Josh_2: I'm also not sure bringing in babel was a good idea. I'm getting a end-off-input error now
<Josh_2>
huh
<Josh_2>
alright one sec then
<char>
Josh_2: salt, and I'm not sure that the to-encrypt arg is supposed to be, maybe just a little more documentation and exmaple would do.
<Josh_2>
I can't remember if a salt is actually required because I use an IV
<Josh_2>
if you encrypt the same thing twice it will have different outputs
<Josh_2>
One sec I'm going to add a condition as well
Cymew has joined #commonlisp
karlosz has joined #commonlisp
tyson2` has joined #commonlisp
tyson2 has quit [Ping timeout: 252 seconds]
Cymew has quit [Ping timeout: 240 seconds]
karlosz has quit [Quit: karlosz]
peterhil has quit [Ping timeout: 256 seconds]
Cymew has joined #commonlisp
cage has quit [Quit: rcirc on GNU Emacs 27.1]
lisp123 has joined #commonlisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #commonlisp
kpoeck has joined #commonlisp
cuz has joined #commonlisp
Guest82 has quit [Quit: Client closed]
lisp123 has quit [Ping timeout: 258 seconds]
treere has joined #commonlisp
<Josh_2>
char: updated with new readme.
<Josh_2>
changed the interface to make it easier as well
peterhil has joined #commonlisp
treere has quit [Quit: Leaving]
<char>
wow examples are powerful. And help me realize that this is not at all what I'm looking for. Cool project still though.
<Josh_2>
xD
<Josh_2>
Well that can just go back into the "things I dont touch" folder
<Josh_2>
char: what is it you are looking for?
<char>
This is more for making a password manager to keep track of a single user's passwords to many different locations. I am looking for a generic way to keep track of many users' passwords for a single website. I still appreciate your updates.
<Josh_2>
hmm
<Josh_2>
Have a user as a group? Each location an entry, and a single password that you keep to decrypt them
<char>
Something like that could work. The user's password would be the "pass" arg and the and I would make sure that the decrypted result is correct
<Josh_2>
Tbf you can just hack up the source, and make it your own, the important part is the encryption/decryption of passwords, even if you just took the functions below *prng* you would off to a good start
<Josh_2>
I believe that the encryption used by default is basically the hardest ironclad has, threefish1024, a 128bit IV and a sha512 hashed key
<Josh_2>
total overkill btw
<char>
I could, but for now, I want something that just works.
cuz has quit [Ping timeout: 256 seconds]
yitzi has joined #commonlisp
lad has joined #commonlisp
shka has quit [Ping timeout: 272 seconds]
akoana has joined #commonlisp
char has quit [Ping timeout: 252 seconds]
cuz has joined #commonlisp
kevingal has quit [Remote host closed the connection]
tyson2` has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
tyson2` has joined #commonlisp
tyson2`` has joined #commonlisp
bhaible has quit [Remote host closed the connection]
bhaible has joined #commonlisp
tyson2` has quit [Ping timeout: 240 seconds]
tyson2`` has quit [Ping timeout: 252 seconds]
tyson2` has joined #commonlisp
bhaible has quit [Remote host closed the connection]
bhaible has joined #commonlisp
dsk has quit [Ping timeout: 256 seconds]
bhaible has quit [Remote host closed the connection]
tyson2` has quit [Ping timeout: 272 seconds]
tyson2``` has joined #commonlisp
bhaible has joined #commonlisp
tyson2``` has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
karlosz has joined #commonlisp
bhaible has quit [Remote host closed the connection]
bhaible has joined #commonlisp
cuz has quit [Ping timeout: 256 seconds]
kpoeck has quit [Ping timeout: 246 seconds]
lotuseater has left #commonlisp [ERC (IRC client for Emacs 27.2)]
kpoeck has joined #commonlisp
kpoeck has left #commonlisp [#commonlisp]
Oladon has joined #commonlisp
Lycurgus has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
kakuhen has joined #commonlisp
IPmonger has joined #commonlisp
IPmonger has quit [Remote host closed the connection]
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
varjag has quit [Ping timeout: 256 seconds]
lad has quit [Remote host closed the connection]
cjb has joined #commonlisp
char has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
mason has joined #commonlisp
pve has quit [Quit: leaving]
karlosz has quit [Quit: karlosz]
akoana has quit [Quit: leaving]
random-nick has quit [Ping timeout: 258 seconds]
Cymew has quit [Ping timeout: 265 seconds]
<aeth>
OK, I'm stumped. Is there a way to check for EOF without hanging when it's a byte stream? With a character stream it's just testing against READ-CHAR-NO-HANG.
<aeth>
Because LISTEN (the only way to not hang with a byte input stream?) appears to have the extreme design flaw of returning NIL on EOF, but the byte stream consisting solely of EOF is still OPEN-STREAM-P (which is so the EOF can be read) so that check won't work, either.
<_death>
yeah, unfortunately there is no read-byte-no-hang.. in my dbus library I assumed the stream was bivalent and used read-char-no-hang
tfb has joined #commonlisp
tfb has quit [Client Quit]
Alfr is now known as Guest5258
Guest5258 has quit [Killed (sodium.libera.chat (Nickname regained by services))]
Alfr has joined #commonlisp
<aeth>
So does usocket have a way to test this by testing the TCP connection instead of testing the stream? Because usocket apparently came from cl-irc and this is *really* basic IRC stuff... losing a connection to a server.
<aeth>
An IRC stream must be a byte stream rather than a character stream because unless UTF8ONLY, then the encoding of IRC is not guaranteed to be UTF8... and UTF8ONLY can only be established in the RPL_ISUPPORT which must happen after the connection is established, on at least the 5th line.