jackdaniel changed the topic of #lisp to: Common Lisp, the #1=(programmable . #1#) programming language | <https://irclog.tymoon.eu/freenode/%23lisp> <https://irclog.whitequark.org/lisp> <http://ccl.clozure.com/irc-logs/lisp/> | offtopic --> #lispcafe
andreyorst has quit [Remote host closed the connection]
<White_Flame> nothing you do on the repl will ever damage your source code, so hack away
<White_Flame> when you restart-inferior-lisp, you can reload clean from source, and any droppings your repl stuff left in the package will be gone
<White_Flame> (well, barring issuing file commands etc from the repl, obv)
galex-713 has quit [Ping timeout: 272 seconds]
dbotton has joined #lisp
abhixec has quit [Quit: leaving]
gaqwas has quit [Ping timeout: 260 seconds]
Steeve has quit [Quit: end]
frost-lab has joined #lisp
<fiddlerwoaroof> stargazesparkle: C-c ~ switches the repl to the same package as your current buffer
karlosz has joined #lisp
<fiddlerwoaroof> C-c x exports the symbol at the cursor from the current package
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
SAL9000 has joined #lisp
abhixec has joined #lisp
harlchen has quit [Quit: WeeChat 3.0]
karlosz has quit [Quit: karlosz]
frost-lab has quit [Quit: Connection closed]
rogersm has joined #lisp
rogersm has quit [Ping timeout: 246 seconds]
miasuji has quit [Remote host closed the connection]
frodef has quit [Ping timeout: 264 seconds]
miasuji has joined #lisp
nicktick has joined #lisp
frost-lab has joined #lisp
rpg has joined #lisp
ralt has quit [Quit: Connection closed for inactivity]
anticrisis has joined #lisp
bjorkint0sh has quit [Quit: Leaving]
zaquest has quit [Remote host closed the connection]
zaquest has joined #lisp
miasuji has quit [Remote host closed the connection]
miasuji has joined #lisp
bitmapper has quit [Quit: Connection closed for inactivity]
bilegeek has joined #lisp
rumbler31_ has quit [Ping timeout: 256 seconds]
mankaev has quit [Ping timeout: 272 seconds]
miasuji has quit [Remote host closed the connection]
miasuji has joined #lisp
dbotton has quit [Quit: Leaving]
wxie has joined #lisp
rogersm has joined #lisp
dilated_dinosaur has quit [Ping timeout: 256 seconds]
rogersm has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 246 seconds]
miasuji has quit [Ping timeout: 264 seconds]
miasuji has joined #lisp
rumbler31_ has joined #lisp
<stargazesparkle> I just made a radical fucking connection
<stargazesparkle> Common Lisp works sort of similar to SmallTalk in how it's a system
surabax has quit [Quit: Leaving]
Misha_B has joined #lisp
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
bjorkintosh has joined #lisp
kaftejiman has quit [Remote host closed the connection]
<Gnuxie[m]> If it weren't a system it'd be a bag of shit
<Gnuxie[m]> It's very fortunate
<aeth> Smalltalk and Common Lisp are very close languages.
miasuji has quit [Remote host closed the connection]
miasuji has joined #lisp
devon has joined #lisp
<devon> What are your favorite COMPOSE and CURRY implementations? Hard to believe they're not in the standard.
<aeth> Smalltalk takes images a bit further than CL does. CL takes OOP a bit further than Smalltalk does. This is amusing because it's Smalltalk that's known for its OOP.
<aeth> devon: Alexandria's is probably the most common
dilated_dinosaur has joined #lisp
semz has quit [Ping timeout: 260 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
notzmv has quit [Remote host closed the connection]
notzmv has joined #lisp
contrapunctus has joined #lisp
dbotton has joined #lisp
miasuji has quit [Remote host closed the connection]
miasuji has joined #lisp
karlosz has joined #lisp
quazimodo has joined #lisp
karlosz has quit [Client Quit]
rumbler31_ has quit [Ping timeout: 264 seconds]
mindCrime has joined #lisp
semz has joined #lisp
raoul has quit [Quit: WeeChat 3.0]
notzmv has quit [Remote host closed the connection]
ebrasca has quit [Remote host closed the connection]
miasuji has quit [Remote host closed the connection]
imode has quit [Ping timeout: 265 seconds]
miasuji has joined #lisp
<loke[m]> devon alexandria is pretty much a standard library.
<Bike> alexandria's has that interesting multiple-value-call trick
dbotton has quit [Quit: This computer has gone to sleep]
Oladon has joined #lisp
rumbler31_ has joined #lisp
v88m has quit [Ping timeout: 256 seconds]
v88m has joined #lisp
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
imode has joined #lisp
<fiddlerwoaroof> Alexandria has a handy compiler-macro for it too
<fiddlerwoaroof> I like using a macro to alias • to ALEXANDRIA:COMPOSE
imode has quit [Client Quit]
dddddd has quit [Remote host closed the connection]
dbotton has joined #lisp
dbotton has quit [Client Quit]
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
jprajzne has quit [Quit: Leaving.]
dddddd has joined #lisp
bitmapper has joined #lisp
Jeanne-Kamikaze has joined #lisp
miasuji has quit [Ping timeout: 264 seconds]
miasuji has joined #lisp
rogersm has joined #lisp
rogersm has quit [Ping timeout: 272 seconds]
Stanley00 has joined #lisp
mrios22 has joined #lisp
Alfr_ has joined #lisp
<beach> Good morning everyone!
<mrios22> Good morning!
keyehzy has quit [Ping timeout: 264 seconds]
Alfr has quit [Ping timeout: 260 seconds]
anticrisis has quit [Read error: Connection reset by peer]
dddddd has quit [Ping timeout: 256 seconds]
dddddd has joined #lisp
imode has joined #lisp
__jrjsmrtn__ has joined #lisp
_jrjsmrtn has quit [Ping timeout: 260 seconds]
Jeanne-Kamikaze has quit [Quit: Leaving]
mindCrime has quit [Ping timeout: 240 seconds]
notzmv has joined #lisp
<stargazesparkle> I still don't understand wtf a macro is
<beach> It is an ordinary function that takes Common Lisp code and returns Common Lisp code.
<beach> Nothing else.
<stargazesparkle> O
<stargazesparkle> Wait
<stargazesparkle> Hmm
<beach> So it allows you to invent new syntax; new "special operators" if you like, by expressing new operators in terms of existing ones.
<stargazesparkle> So it's like an automatic copy and paste sort of into existing code
<mfiano> Macros are basically for two things: syntactic abstractions and evaluation control.
<beach> I hadn't thought if it like that, but that's sort of accurate.
<mfiano> If you need to create new syntax, or defer evaluation
<beach> stargazesparkle: Another way of viewing it, is that you can program the compiler to recognize new syntax, because the compiler will expand a form with your new operator. That is the reason we don't have to wait for CL21, CL24, etc, in order to get new functionality.
<beach> The application programmer can do it .
<stargazesparkle> I'm struggling to think of an example of that
Nilby has joined #lisp
<stargazesparkle> Would arrow macros be considered new syntax
<mfiano> For example, you can't re-implement `AND` as a function, because of its short-circuiting behavior. Function arguments are evaluated before application.
<beach> That's what I said.
<beach> Oh, arrow macros
<beach> ?
<mfiano> stargazesparkle: Yes
<stargazesparkle> (-> 1 (+ 2 3) #'1+ 1+ (lambda (x) (+ x 1)) (1+))
<beach> Not sure what that means, but it looks like new syntax to me.
<mfiano> beach: Arrow macros are a clojurism to remove nesting.
<beach> I see.
<stargazesparkle> Ye
<beach> stargazesparkle: New syntax is whenever you have an opeartor that does not behave like a function.
<stargazesparkle> Hmm
<mfiano> (-> 1 (+ 2 3) #'1+) ; => (1+ (+ 1 2 3))
<mfiano> or something like that
<stargazesparkle> Yes
<mfiano> -> sends the preceding return value as the first argument to the unevaluated s-expression to construct a new s-expression, then evaluates it and repeats it down the chain
<beach> Oh, the number of things #lisp participants are expected to master: Clojure, Python, JavaScript, Java, C#, all possible editors and IDEs, json, web stuff...
Bike has quit [Quit: Lost terminal]
Oladon has quit [Quit: Leaving.]
<stargazesparkle> Yes
<stargazesparkle> And because you have mastered them all you have been incredibly helpful
rogersm has joined #lisp
<stargazesparkle> However, I use the arrow-macros library on quicklisp because it is nice to do those threading things
<mrios22> I have seen people use let* as a way to get threading-macro-like behavior. Some readers may find the progression to be clearer when it is written that way.
<beach> stargazesparkle: So [and this goes for almost any language, really] a function evaluates all of its arguments before the function is invoked. You can write new functions in almost any language, like C, Java, etc.
<mfiano> You can't use LET for threading macros. only to a very limited extent
<beach> stargazesparkle: But if you want a new construct that doesn't behave like that, in most languages, you have to wait for the new standard.
<stargazesparkle> I also use let* to break up nesting
miasuji has quit [Ping timeout: 264 seconds]
<beach> stargazesparkle: In Common Lisp, you use macros in situations like that.
notzmv has quit [Remote host closed the connection]
<stargazesparkle> That makes sense
<beach> Now macros have a bad reputation because of the way they were implemented in C.
notzmv has joined #lisp
<beach> String transformation does not allow you to do the things you need for your new construct to integrate with the rest of the language.
<beach> But Common Lisp macros are not string transformations. They rely on the fact that Common Lisp code has a standardized representation in memory.
rogersm has quit [Ping timeout: 265 seconds]
<beach> So Common Lisp macros are way more powerful than C macros, and they integrate completely with the rest of the language. So completely, in fact, that many standard Common Lisp operators are specified to be macros.
<mfiano> Even languages that have AST reflection like Rust, Nim, or Julia, it's pretty laughable how painful it is to write a macro not being homoiconic. Though, for some reason, Julia (a python-like-syntax language) calls itself homoiconic...
<beach> Good point, yes.
<mfiano> Some newer languages that have true macros with painful AST node construction call themselves homoiconic because of that. I don't get it.
wxie has quit [Ping timeout: 272 seconds]
<beach> mfiano: I am often surprised to see people come here with their homegrown language that they desperately want to be "a Lisp". Maybe that "homoiconicity" phenomenon is a similar one.
recalloc has joined #lisp
<mfiano> Wikipedia: A language is homoiconic if a program written in it can be manipulated as data using the language, and thus the program's internal representation can be inferred just by reading the program itself.
<Nilby> When I programmed in C, I used macros like I use them in Lisp, but it was just far far more painful, since it crreates clashing syntax, and the only operations you have are substitution and limited concatenation. The emacs and clisp C code are examples of such trouble.
<mfiano> I don't particularly agree with that definition
<beach> Yeah, that's not quite enough is it.
<beach> stargazesparkle: Here is a small example (of an existing macro). Suppose I want an IF with no `else' branch, and an implicit PROGN, so that I can write (when (< x y) (print x) (print y)).
<beach> stargazesparkle: Clearly, it is not possible to write WHEN as a function, because the PRINT forms would always be evaluated then. So I can write a macro like this (defmacro when (test &body) (list 'if test (cons 'progn body)))
thmprover has quit [Quit: This parting was well made]
<beach> stargazesparkle: When I write (when (< x y) (print x) (print y)) the compiler turns it into (if (< x y) (progn (print x) (print y))).
ppbitb has joined #lisp
<stargazesparkle> Won't that cause problems since the expanded macro has an if with only one branch?
<beach> That happens to be an acceptable form of IF.
<beach> stargazesparkle: But I could have added a NIL to the `else' branch.
<stargazesparkle> Interesting
<beach> mfiano: Holy crap!
<mfiano> Now image writing a practical macro completely with quoting and unquoting
<mfiano> imagine*
<beach> stargazesparkle: (defmacro when (test &body) (list 'if test (cons 'progn body) nil))
<beach> mfiano: Laughable indeed! Why do they never learn?
wxie has joined #lisp
<mfiano> I know a lot of these newer languages that try to be like Lisp fairly well, and it is enough to know that I don't ever want to use them.
<saturn2> it's a really bizarre phenomenon, people who refuse to use lisp trying to mimic lisp
<beach> saturn2: Exactly!
<beach> Like I often say, people go to a lot of trouble to avoid learning Common Lisp.
<mfiano> There's more languages than there were Linux distribution's 20 years ago, because their authors haven't experienced Lisp, or were poorly educated about Lisp in school as usual.
<beach> Yes, education is to blame for a lot of it.
v88m has quit [Ping timeout: 265 seconds]
<beach> We (me and idurand) managed to teach Common Lisp to 120 undergraduates per year for 15 years or so, so I can say I did my part.
<Nilby> Even when you have a Lisp-like language and only take away the homoiconicity, like in Dylan, the macro system becomes pretty crazy. Although Dylan is nearly the most sensible approach I can think of.
notzmv has quit [Remote host closed the connection]
<beach> Our "lectures" were done at the REPL.
notzmv has joined #lisp
<mfiano> I would say Julia would be the cloest language to one I would want to use, but still far away from wanting to use it.
<Nilby> Sometime I feel like all CS/math lectures should be taught at a REPL.
<beach> Nilby: Maybe not "all", but yes, I see your point.
notzmv has quit [Remote host closed the connection]
<mfiano> One thing that disappoints me is how professors insist on just using Microsoft Notepad or similar for learning CL.
<mfiano> Didn't we just have a visitor yesterday that insisted on not using Emacs?
heisig has joined #lisp
<mfiano> It disappoints me because we don't have any books that instruct one should be using SLIME/Sly. They all start by introducing the syntax, which I feel is very wrong, because it gives a false impression.
<stargazesparkle> Yeah that visitor was me
<stargazesparkle> And now I have spacemacs
matryoshka` has joined #lisp
matryoshka has quit [Read error: Connection reset by peer]
<stargazesparkle> Does let have an implicit progn?
<mfiano> After all, one of the biggest criticisms are the parentheses, but newcomers don't understand that they don't have to count/balance them with the proper tools utilized.
<stargazesparkle> (I use paredit)
<mfiano> and they have no idea about the other introspection tools working with the image instead of sending text to a compiler.
<mfiano> The sentence structure was completely messed up in that last message, but I think you get the point. Back to code
mankaev has joined #lisp
karlosz has joined #lisp
scymtym_ has joined #lisp
scymtym has quit [Ping timeout: 246 seconds]
<mrios22> stargazesparkle: I think it has an implicit progn. You can check by writing one and doing a macro expansion.
<beach> stargazesparkle: Yes, LET has an implicit PROGN.
<beach> clhs let
<mrios22> (let ((n 1) (m 2)) (format t "Is this an implicit progn?~&") (format t "So far it looks like an implicit progn~&") (+ n m))
<beach> stargazesparkle: See that form*? That means that you can put any number of forms there.
<mrios22> stargazesparkle: That's my bargain basement check :)
<mrios22> I have a question about test suites like 5am. If I want to use the tests to check the non-exported functions in my lisp files, then how do I do that? Or does the test suite have access to the non-exported functions in a package?
<stargazesparkle> From what I gather
<stargazesparkle> You could (in-package) your tests
<beach> mrios22: Just use package::symbol.
<mrios22> beach: fantastic, that was what I was looking for.
ppbitb has left #lisp [#lisp]
<mrios22> Thank you. I'm still pretty new to this
<beach> That will change, don't worry.
remby has joined #lisp
<remby> help me pick a lisp
<mrios22> remby: what do you need? What are you interested in?
<mrios22> remby: Chances are that people on this channel will recommend Common Lisp because it can more or less do everything that you need.
<remby> jit, small binary size, can build on various distros and unix
<remby> I mean lisp compiler
<remby> I think I'm in the common lisp channel right?
<mrios22> remby: well, if you are looking for the ability to compile individual functions and files quickly, then Common Lisp can do that. I don't know anything about small or large binary sizes, sorry. And as far as I can tell, Common Lisp will work on any unix or linux that is out there. Most people here use sbcl as their common lisp compiler/interpreter. If you look up SBCL, you can figure out which platforms it operates on.
<mrios22> remby: This is a common-lisp oriented channel, as far as I can tell.
<mrios22> remby: you might want to take a look at Scheme as well. There are many implementations. My first lisp was Scheme. If you would like to learn about Lisp, CS, and scheme, you can read "The Structure and Interpretation of Computer Programs." It's free online.
<remby> I've been trying out various schemes
<remby> ran into a few issues with chicken so I decided to see what the common lisp scene was like
<mrios22> remby: I ended up using Common Lisp as my main lisp because Common Lisp has standardization and quicklisp.
<remby> you finished sicp?
<mrios22> remby: Scheme is wonderful, but the implementation and library fragmentation scares me. Quicklisp is a library/package manager for Common Lisp implementations. I've never seen a library management system that is easy and convenient as ql. The author and maintainer of the quicklisp system, Xach, hangs out here and answers questions.
<mrios22> remby: yes, I finished it, and my mind will be permanently altered (in a good way)!
<remby> that's amazing
<remby> I can't even fathom that
<remby> there is fragmentation but that wasn't the main issue for me
<remby> I guess I'm just looking for a reliable compiler
<mrios22> With all languages the main question is "can it help me do what I need to do and be helpful rather than a huge hinderance, and can I think in this language without too much trouble" -- so Scheme can be good for some things and CL better for others. For example, if I ever needed to make use of continuations, I would work with Scheme.
<remby> they aren't in common lisp?
<mrios22> remby: People on this channel tend to be big fans of SBCL as a compiler. I switched from Clojure and Scheme to CL because SBCL is such a helpful and powerful compiler.
<remby> hmm
pillton has quit [Quit: ERC (IRC client for Emacs 27.1)]
<mrios22> remby: Some libraries have implemented continuations. CL is so powerful that you can implement something like continuations. I'm not an expert, you probably should talk to phoe about this, but I think you can implement continuations using the CL condition system.
<remby> what wait?
<mrios22> remby: The Weblocks library implemented continuations so they could have a continuation-based web platform.
<remby> how even
<remby> that's nutty
jonatack has quit [Ping timeout: 240 seconds]
<mrios22> remby: That's a level of wizardry that's beyond me, honestly! I don't know how to implement continuations. At times I feel like I barely understand them. I think people in CL land avoid continuations for several reasons: they're hard to implement, hard to understand, and usually you can get away with not using them. A Scheme expert named Oleg once wrote an article talking about how continuations are probably not a good idea. Let me see
<mrios22> if I can find the link for you.
<remby> oh this guy
<remby> has a lot of notes :P
jonatack has joined #lisp
<remby> thanks
<remby> how long did sicp take?
<stargazesparkle> Is a LET inside of a LET a bad practice? Or should I use setq to redefine a declared variable?
rogersm has joined #lisp
<mrios22> remby: several months. Some ideas I didn't understand until a year later!
<remby> I see
<mfiano> You should never use SETQ, not even anywhere else.
<stargazesparkle> O
<mfiano> For additional bindings, just add more bindings to the same LET.
<stargazesparkle> What about setting a global variable?
<mrios22> remby: it's like a mathematics textbook. Read it slowly, do the exercises, let your mind expand to the right dimensions before you continue XD
<stargazesparkle> Well what if I need to do some processing before needing another binding
<mfiano> Global variables are a code smell. Avoid them whenever possible. Common Lisp's "globals" are not true globals anyway, as they have a stack of bindings of their own.
<stargazesparkle> Ex. I need to get a RESPONSE. That response may have a TOKEN. I want to do some branching if it doesn't have a TOKEN and some if it does. That does processing requires me to get another RESPONSE.
<mfiano> That's what functions are for, no?
<mrios22> remby: Back to your original question -- I'd try out SBCL and your favorite scheme implementation, and check out Clojure too. After some hacking you'll figure out what is best for your needs. :) I settled on Common Lisp because I feel like it has the best of all worlds and the people on this IRC are very nice and helpful. Have fun -- I need to get on the road :)
<mfiano> (let* ((a (do-something)) (b (do-something-to-a a))) ..)
<remby> yeah, thanks
<remby> cya
<stargazesparkle> Er... maybe better if I just post what I am working with
rogersm has quit [Ping timeout: 260 seconds]
oni-on-ion has joined #lisp
<stargazesparkle> That line there I need to work with that response
<stargazesparkle> Should I do another let to bind it or is there a way for me to create a nil binding in the first let and then set the value later if I need it
karlosz has quit [Quit: karlosz]
mrios22 has quit [Ping timeout: 246 seconds]
<beach> remby: Contrary to what mrios22 said, you can't implement first-class continuation in portable Common Lisp.
<remby> beach: so is this done is a special compiler?
<beach> It is usually not done.
<beach> And when it is, you get only limited continuations.
<beach> But first-class continuations are problematic for Common Lisp in general. Stuff like files that close and exit points that might expire.
<fiddlerwoaroof> stargazesparkle: if the variables reference each other, you can use LET*
<fiddlerwoaroof> clhs let*
<stargazesparkle> I need to maybe bind later
<stargazesparkle> I know about let*
rumbler31_ has quit [Ping timeout: 265 seconds]
<stargazesparkle> But I need an if in between bindings because I can't continue if I don't get an expected value
<fiddlerwoaroof> Ah, yeah there I'd just do another let
<beach> stargazesparkle: There is no simple rule about nesting LETs, using LET*, and using SETQ/SETF. Each one has its use in particular situations.
pp has joined #lisp
<beach> remby: Contrary to what mrios22 said, SBCL does not fulfill your requirement for small executables.
rumbler31_ has joined #lisp
<remby> hrm
<remby> the jit too?
<beach> remby: You may want to look into ECL instead for that. Then, I don't understand the obsession with small executables now that people stuff entire operating systems inside a "container".
<beach> remby: I don't understand your question.
<remby> does any common lisp compiler provide a jit?
flazh1 has quit [Ping timeout: 264 seconds]
<beach> remby: I don't think so. Why do you need it?
<fiddlerwoaroof> Depends what you mean by "jit"
<remby> hot code to native
<fiddlerwoaroof> SBCL compiles everything to native
<remby> I don't need one, I just want one :P
<fiddlerwoaroof> stargazesparkle: I added a comment with one possibility
narimiran has joined #lisp
<remby> fiddlerwoaroof: ah
<fiddlerwoaroof> stargazesparkle: If the "else" side of your IF is just going to be NIL, you might consider using WHEN instead
sauvin has joined #lisp
<beach> minion: Memo for mrios22: Try to avoid giving advice about subject you don't know.
<minion> Remembered. I'll tell mrios22 when he/she/it next speaks.
<stargazesparkle> fiddlerwoaroof: I am going to add error information there
<aeth> it took way too long for someone to point out LET*
<stargazesparkle> Say I have '((1 2) (3 4)) and '(5 6) how do I produce '((1 2) (3 4) (5 6))?
<beach> clhs append
<beach> (append x (list y))
<stargazesparkle> LET* won't work here btw
<stargazesparkle> I tried to use cons
<beach> Sure it will.
<stargazesparkle> Because I am dumb
<remby> cons will not work there
<beach> (let* ((x '((1 2) (3 4))) (y '(5 6)) (z (append x (list y)))) ...)
galex-713 has joined #lisp
<stargazesparkle> That is not what I was talking about :P
<remby> '(((1 2) (3 4)) (5 6))
<fiddlerwoaroof> stargazesparkle: I'm not sure if I have enough information to answer the question, what are you trying to do in the gist :)
<stargazesparkle> append works great
<beach> It usually does, yes.
<remby> does anyone know where or if sbcl is used in prod?
<beach> It is.
<stargazesparkle> I am sending an http request that may or may not result in a token. If I get a token I need to send that token back in another http request. If when I do that it may or may not give me another token. If I do not get the first token then I need to return an error message because I cannot proceed further.
<remby> just curious
<remby> oh
<beach> By Google for instance.
<remby> wha, woah
skapata has quit [Remote host closed the connection]
<beach> Google bought ITS which used SBCL for it's main product, an airline route thing.
<White_Flame> I've deployed it to the largest nuclear power plant in the western hemisphere
<fiddlerwoaroof> White_Flame: cool
<fiddlerwoaroof> It's also been into space
<stargazesparkle> lispworks gets the credit for the Hubble Telescope iirc
<remby> wow
<beach> remby: Don't get too excited. It is easy to think that a company is a homogeneous thing. In reality, companies consist of people, so the people who used to work for ITS probably got "bought up" with the company. That doesn't mean that Google as a whole has a policy of using SBCL.
<fiddlerwoaroof> They even connected to a REPL on a spacecraft and fixed a bug :)
<fiddlerwoaroof> beach: according to someone, they tried to rewrite ITA's product in C++
<remby> it's still impressive, used for such intense projects
<fiddlerwoaroof> They ended up with like 10x as much code and only marginal speed improvements, IIRC
<fiddlerwoaroof> So they scrapped the rewrite
<beach> fiddlerwoaroof: Why am I not surprised? It has happened before. Viaweb as I recall, but maybe it wasn't C++.
<beach> fiddlerwoaroof: Heh, nice!
<fiddlerwoaroof> Yeah, this time it has a happy ending :)
* remby ponders sbcl
<beach> remby: Like I said, it doesn't correspond to your requirements for small executables.
<saturn2> google published some open source CL libraries and a style guide, so i guess they're using it internally at least a little bit
<remby> oh right
<White_Flame> if you wanted smaller deployables, I guess you could ship .fasls?
<beach> saturn2: Actually, it was Fare who wrote that style guide.
<White_Flame> exactly the same as having the JVM installed and distributing class files
<beach> saturn2: He just happened to work for Google then.
<saturn2> i see
<fiddlerwoaroof> It depends what you mean by "small", really
<beach> saturn2: Again, companies consist of people. This style guide was not written by Google management.
<fiddlerwoaroof> My sbcl executables are like 32M
<fiddlerwoaroof> Much smaller than most of the other programs on my computer
<White_Flame> when you take 32GB of heap space, the 32MB doesn't really count for much
<remby> lol
<fiddlerwoaroof> IntelliJ is like 1+G
<White_Flame> and of course hard drives don't really perceive that amount of space anymore
<saturn2> beach: but companies generally have rules too, most employees can't just start using any language they feel like
<beach> saturn2: More often than you may think. :)
<fiddlerwoaroof> Slack is 182M
<fiddlerwoaroof> saturn2: you can't use "just any language" for mission critical software
<beach> saturn2: What most managers don't understand is the fundamental CS result of code/data equivalence.
<aeth> saturn2: acquisitions are special
<fiddlerwoaroof> But, you can use it to make things work better for you and then sneakernet the resulting tools to your coworkers :)
<beach> saturn2: So you can present your new language as an input format for a program written in a different language. They won't understand what happened to them.
<White_Flame> fiddlerwoaroof: but you might use "just any language" for the test/dev deployment of the next version of the mission critical stuff
<fiddlerwoaroof> :)
<beach> saturn2: That's how I introduced Lisp in a Pascal-only shop, a long time ago mind you.
<White_Flame> but yeah, tooling is a great place to inject lisp
<fiddlerwoaroof> Yeah, I think with .NET the prototype of the GC was written in CL
<White_Flame> especially as a code generator
<saturn2> beach: interesting
<moon-child> fiddlerwoaroof: yeah, iirc they wrote a tool to automatically translate it to c++
<beach> saturn2: Programmers are way too eager to follow rules established by people who have no clue of software development or computer science.
<moon-child> and today it's still a single 30k loc file
<White_Flame> you're giving me bad flashbacks of cyc and powerloom
<beach> saturn2: This is even more important because the people who establish those rules don't understand what is best for the company they manage.
<remby> since common lisp is so old, how is concurrency in common lisp?
<White_Flame> remby: better than most languages
<stargazesparkle> is (append (list '((1 2) (3 4)) (list (list 5 6))) clear?
<beach> remby: There is a well-established thread culture.
<White_Flame> with dynamic bindings being thread-local as a particular standout
<stargazesparkle> Er... (append '((1 2) (3 4)) (list (list 5 6))) I mean
<fiddlerwoaroof> I first started using CL because it didn't have a GIL and it was relatively easy to get a noticeable performance boost from threads
<remby> what is a GIL?
<fiddlerwoaroof> Global Interpreter Lock
<beach> stargazesparkle: Sure, but why avoid the quotes for the last part?
<aeth> seems like a style mismatch to me
<fiddlerwoaroof> Python/Ruby/Ocaml all limit you to one active thread at a time
<fiddlerwoaroof> (or did)
<aeth> Ocaml is slowly removing it
<fiddlerwoaroof> JS is just single-threaded
<stargazesparkle> That last part is not going to be '(5 6) but more like `(5 ,x)
<White_Flame> well, JS has web workers, and threaded I/O in the background
<remby> i just keep getting impressed :^)
<fiddlerwoaroof> Haskell has a decent multithread story, but you have to buy into the whole Haskell thing
<fiddlerwoaroof> The only system that's better on the concurrency front is the JVM/Clojure, IMO
<White_Flame> but "JS is just single-threaded" is accurate enough :-P
<fiddlerwoaroof> JS has fake threads
<remby> fiddlerwoaroof: it's pretty nice in go
<fiddlerwoaroof> Yeah, I always forget about go
<remby> have not tried clojure yet
<fiddlerwoaroof> Can't stand the way it looks
<remby> waah?
<fiddlerwoaroof> It's in the Java tradition of high-boilerplate languages
<remby> they fixed a lot and accommodated the C syntax family
jprajzne has joined #lisp
<fiddlerwoaroof> Plus, it looks like C
<White_Flame> fiddlerwoaroof: js web workers are real OS threads
<remby> well, I heard somewhere that is a key to language survival :P
<fiddlerwoaroof> White_Flame: yeah, but the programming model is pretty different
<fiddlerwoaroof> Are they on node?
<beach> remby: Homoiconicity is essential for avoiding boilerplate code.
<beach> remby: Let me repeat this again: People go to a lot of trouble to avoid learning Common Lisp.
<remby> I will say block structure is difficult in lisp, at least visually
<beach> Not really no.
<remby> syntax matters
andreyorst has joined #lisp
<beach> remby: Oh it does, as in C syntax makes macros impossible, so boilerplate code becomes the norm.
<remby> not sure what it is in CL, but nested map or for-each in scheme can be a bit tricky
<fiddlerwoaroof> remby: I find CL encourages me to write programs as compositions of simple functions
<moon-child> syntax does matter, but lisp syntax is excellent imo. (Not as good as apl, but still very good.)
<remby> beach: D has macros
<remby> fiddlerwoaroof: yes
<moon-child> remby: d doesn't have macros, it has 'string mixins', which are much worse
<fiddlerwoaroof> Because when you have like three or for levels of nested forms, it gets ugly
<remby> oh
<fiddlerwoaroof> But, this is goodd
<remby> I guess this is what rust does too?
<beach> remby: I think you have no idea what Common Lisp macros can do. They rely on homoiconicity.
<moon-child> rust has macros, but they're hygienic, which limits their power. And rust isn't homoiconic which makes them much less interesting
<remby> I didn't not look much into macros yet, tbh
<fiddlerwoaroof> Elixir has macros, and they even square the circle, sort of
<fiddlerwoaroof> Dylan also solved the "non-expression macros" problem, I think
<fiddlerwoaroof> "non s-expression macros", that is
<beach> remby: Macros are the reason we don't have to wait for CL21, CL24, CL27 etc, to get new features that we want.
aartaka has joined #lisp
<remby> I get that :)
<remby> another example, having a let expression with mutple variable is hard to read if it's all on the same line
waleee-cl has quit [Quit: Connection closed for inactivity]
<moon-child> well, don't put it on the same line
<moon-child> :)
<beach> Exactly!
<fiddlerwoaroof> We have big monitors these days
<remby> pft, easy way out :P
<White_Flame> I've never seen (let ((a 1) (b 2)...) ...) on one line in real code. Only IRC one-liners
<beach> Same here.
<beach> remby: I think you are inventing situations that don't occur in practice.
<remby> no, just what happened when I coded on my own
<fiddlerwoaroof> Nothing is as hard to read as this: https://github.com/lkowalick/j-interpreter/blob/master/source.c
<beach> Oh, you complain about your own code?
<remby> is that an IOCC entry? lol
<moon-child> fiddlerwoaroof: eh, it takes practice. Like anything, you have to learn it before you can understand it easily
<fiddlerwoaroof> People who write APL have weird senses of C aesthetics
<remby> beach: yeah
<remby> people who write apl are legendary
<moon-child> remby: I mean, you can declare variables all on the same line in pretty much any language. I struggle to think of one where you can't
<beach> remby: So there is one great disadvantage with Common Lisp. It can't fix code produced by bad programmers.
<remby> ah, poor me
<moon-child> fiddlerwoaroof: I think that can mostly be attributed to arthur whitney. APL-related c codebases not influenced by him tend to look much more normal
<remby> c books usually say not do this ;)
<aeth> someone needs to translate that into CL. Not cleaning it up
<aeth> the main thing CL forces you to do is put spaces between (most) tokens, which even Python doesn't force you to do.
<aeth> So you'd gain some readability
<saturn2> it's a nice touch that there's a comment explaining the simple wrapper around malloc
<saturn2> yeah that's the part i was really having trouble with
<moon-child> I think that's somebody else who was annotating the original code and got stuck halfway through
<saturn2> oh that makes sense
<moon-child> the original code is https://code.jsoftware.com/wiki/Essays/Incunabulum and has no comments
<remby> :')
<remby> imagine getting that on your desk
anticrisis has joined #lisp
<aeth> remby: that looks like the output of a debugger for someone who wrote an s-expression->C DSL and decided to make it minified instead of human readable
ex_nihilo has joined #lisp
jprajzne has quit [Ping timeout: 272 seconds]
<aeth> although, to be fair, it could be worse. 0: #\t 1: #\y 2: #\p ...
<aeth> That's why you do "pretty print" instead of inspect on strings in SLIME
aartaka has quit [Read error: Connection reset by peer]
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
<remby> I guess you guys all use emacs?
moon-child has quit [Remote host closed the connection]
earenndil has joined #lisp
<flip214> remby: no, a few vim people are around as well.
<remby> cool
earenndil is now known as moon-child
<solideogloria[m]> remby: no
<solideogloria[m]> well sometimes
<solideogloria[m]> I keep switching between emacs,vim and acme :D
<remby> acme, that's wild
<fiddlerwoaroof> remby: I started with vim/slimv
<fiddlerwoaroof> I still use it occasionally, it works pretty well
<fiddlerwoaroof> aeth: someone on HN explained why the code looks like that. Basically, the more global a name is, the easier it is to remember because it's used more, so why waste characters on a descriptive name?
<solideogloria[m]> I like the mouse chords in acme
<solideogloria[m]> and I use a script that automatically adds or removes parens depending on the selection
<remby> kinda amusing we drag these environments around, but then again, the ones that support them are not always sufficient
<remby> solideogloria[m]: cool
<remby> you don't miss paren highlight?
<solideogloria[m]> I have a script that simulates what emacs does when you add a closing paren
<solideogloria[m]> creates a new window and tells what function it terminates
<solideogloria[m]> so it takes care of that
mrios22 has joined #lisp
<solideogloria[m]> but I mostly toy around in acme, :)
<solideogloria[m]> vim and emacs are way better experiences
nicktick has quit [Ping timeout: 240 seconds]
<beach> remby: To most experienced Common Lisp programmers, parentheses are transparent. They just don't exist. Indentation is what gives the clue to the program structure.
rgherdt has joined #lisp
<remby> I guess
<remby> what about when you are at the repl
nicktick has joined #lisp
<beach> Indentation works there too.
<remby> I've gotten lost trying to close parens a few times
<remby> but those lisps didn't have much for their repl
<beach> The corresponding opening parenthesis should blink for you.
<solideogloria[m]> Paren highlight works in the repl as well
<beach> "those lisps"?
<solideogloria[m]> oh you mean the bare repl ?
<remby> yeah
attila_lendvai has joined #lisp
<solideogloria[m]> I thought you meant something like slime
<beach> remby: Never use a bare REPL. Always use SLIME.
<remby> haha, I see :)
<solideogloria[m]> remby take a look at sbcli if you want something more featureful than rlwrap for sbcl
<beach> remby: You would typically have a split Emacs frame with the REPL in one window and one or more buffers next to it.
<remby> solideogloria[m]: thanks
<solideogloria[m]> gives an experience like haskells ghci
ralt has joined #lisp
<stargazesparkle> I need to figure out smooth scrolling on Emacs
<solideogloria[m]> smooth-scrolling is a package right ?
<remby> of course it's in melpa :P
luckless has quit [Quit: luckless]
<stargazesparkle> I just want the mouse wheel to not scroll a whole screen
<stargazesparkle> Just like a line at a time
luckless has joined #lisp
<beach> stargazesparkle: It is much faster to avoid the mouse altogether.
<solideogloria[m]> (setq scroll-step 1) ?
<stargazesparkle> The key bindings for navigation are stupid af in Emacs
<beach> stargazesparkle: For code, use things like M-f M-b, C-M-f, C-M-b, C-M-t etc.
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<solideogloria[m]> that's why evil mode exists :)
<beach> stargazesparkle: Which ones?
<Nilby> stargazesparkle: mwheel-scroll-amount
contrapunctus has joined #lisp
<stargazesparkle> I'm using spacemacs atm so I don't have to deal with stupid things like multi-key chords to move a line up or down
<beach> stargazesparkle: It is much more efficient for Common Lisp code to move by program units than by lines/characters. Plus, if you DO want to move up a line, C-p and C-n work fine. Even the arrow keys.
<beach> Since the control key and n/p are on different fingers, they are both instantaneous.
<fiddlerwoaroof> Yeah, I use C-M-u, C-M-f a ton, once I discovered them
<stargazesparkle> HJKL are much nicer
<beach> OK, you use those then. Good luck.
<fiddlerwoaroof> The thing is, in CL you want motion commands that move by lists
<beach> stargazesparkle: But please don't use words like "stupid" for the habits you don't understand.
<fiddlerwoaroof> I almost want to go to "the opening parentheses" and so I hit C-M-u
<fiddlerwoaroof> s/almost/almost always/
<beach> I use C-M-a and C-M-e a lot.
<fiddlerwoaroof> Yeah, those too
<fiddlerwoaroof> C-M-k to kill an expression
<stargazesparkle> C and M are so far out of the way which makes them really inconvenient because I have to remove one hand from a typing position to strike them
<solideogloria[m]> in vim it's just a % to switch between closing and starting parens
<solideogloria[m]> in normal mode
<beach> stargazesparkle: Put Control where capslock is, and use C-[ instead of M-
<fiddlerwoaroof> solideogloria[m]: you have to be on the parens for that
<beach> stargazesparkle: Again, please don't have opinions about habits you don't know.
<fiddlerwoaroof> If you're at the beginning of the second argument of a three-line if expression, C-M-u takes you to the opening parens of the if expression
<stargazesparkle> You can criticize the usability of something without having to go and adopt it first
<beach> stargazesparkle: That should be avoided if you are ignorant of the way it is used.
<fiddlerwoaroof> Well, if you haven't learned to use something, you often don't understand the ergonomics
<mrios22> I'm getting an error in the quicklisp fiveAM library. Can someone else replicate it to see if it's just me? I'm following the tutorial at http://turtleware.eu/posts/Tutorial-Working-with-FiveAM.html and I'm having trouble doing def-suite. Every time I try to run it, it raises an error saying that the name of the suite is undefined.
<minion> mrios22, memo from beach: Try to avoid giving advice about subject you don't know.
<solideogloria[m]> killing an expression in vim is a da(
<fiddlerwoaroof> mrios22: I suspect you haven't imported the symbol into the current package
<fiddlerwoaroof> solideogloria[m]: only if the expression is a list. C-M-k kills "a lisp expression"
<beach> mrios22: Errors are not "raised" in Common Lisp. They are "signaled".
nicktick has quit [Ping timeout: 246 seconds]
<mrios22> beach: roger that.
nicktick has joined #lisp
Mandus_ is now known as Mandus
<mrios22> minion: ? I hope I didn't cause offense :)
<minion> ? I hope I didn't cause offense ): An error was encountered in lookup: Parse error:URI "https://www.cliki.net/?%20I%20hope%20I%20didn';t%20cause%20offense%20)?source" contains illegal character #\? at position 69..
<flip214> well done ... bug bounty applies, here's a "b"
<phoe> mrios22: minion is a bit, the original note was from beach
<mrios22> phoe: thanks
<beach> A "bot" rather.
<phoe> bot, yes, sorry
<mrios22> fiddlerwoaroof: I can replicate the bug by doing (progn (ql:quickload :fiveam) (def-suite test-suite))
<beach> minion: Are you a bot?
<minion> i'm not a bot. i prefer the term ``electronically composed''.
rogersm has joined #lisp
<mrios22> The error happens when I define the suite.
<saturn2> that tutorial tells you to write defpackage and in-package forms, you need those
<mrios22> saturn2: I discovered the problem in my file. I forgot the (in-package ...) command. Thanks.
rogersm has quit [Ping timeout: 256 seconds]
slyrus has quit [Remote host closed the connection]
slyrus has joined #lisp
aartaka has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
amb007 has quit [Read error: Connection reset by peer]
jonatack has quit [Ping timeout: 246 seconds]
jonatack has joined #lisp
luckless has quit [Quit: luckless]
luckless has joined #lisp
amb007 has joined #lisp
Cymew has joined #lisp
luckless has quit [Client Quit]
luckless has joined #lisp
varjag has joined #lisp
<solideogloria[m]> this might be a dumb question, but how do I check if the variable given to case is equal to multiple keys than just one for each form?
<solideogloria[m]> (or key1 key2) form works, but it gives a style warning
<ralt> what's the warning?
<solideogloria[m]> duplicate key because I used (or key1 key2) twice
contrapunctus has left #lisp ["Disconnected: closed"]
gaqwas has joined #lisp
<beach> solideogloria[m]: Just put all keys in a list.
<beach> (case x ((key2 key2) ...))
<beach> clhs case
liberliver has joined #lisp
makomo has joined #lisp
<beach> Notice that normal-clause has (keys form*) in it.
<beach> And notice that keys is a "designator for a list of objects"
contrapunctus has joined #lisp
<beach> So it is not a type specifier, which means that your OR is just another key.
rogersm has joined #lisp
<beach> So if you used OR in more than one clause, that might be the reason for the warning.
<beach> solideogloria[m]: Look in the glossary for "list designator". Then you will see that NIL designates an empty list, and any other atom designates a singleton list containing that atom.
pve has joined #lisp
jprajzne has joined #lisp
rogersm has quit [Ping timeout: 264 seconds]
<beach> solideogloria[m]: Does that makes sense to you?
* beach fears the answer is "no" :(
hendursa1 has joined #lisp
remby has quit [Quit: remby]
hendursaga has quit [Ping timeout: 240 seconds]
remby has joined #lisp
<phoe> beach: they'll respond, have faith and patience
<beach> Oh, OK. :)
scymtym__ has joined #lisp
scymtym_ has quit [Ping timeout: 240 seconds]
<solideogloria[m]> got it beach
<beach> Great!
bilegeek has quit [Quit: Leaving]
cosimone has joined #lisp
nicktick has quit [Ping timeout: 260 seconds]
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
frodef has joined #lisp
Bubo_ has joined #lisp
Bubo_ has left #lisp [#lisp]
orivej has joined #lisp
norserob has quit [Quit: leaving]
BuboBubo has joined #lisp
luckless has quit [Ping timeout: 240 seconds]
luckless has joined #lisp
BuboBubo has quit []
<stargazesparkle> What is this called: (1 . 2)
<stargazesparkle> I am trying to learn what to call things
<phoe> a cons cell
<phoe> whose CAR is the integer 1 and whose CDR is the integer 2
<stargazesparkle> What if I didn't have the .?
<beach> Dotted pair.
<phoe> then it would be a list of two elements
<stargazesparkle> Is that just a cons?
<phoe> (1 2) === (1 . (2 . NIL))
<beach> (1 . 2) is a dotted pair.
<stargazesparkle> Oh fuck that makes sense
<beach> (1 2) is a proper list.
<phoe> lists are made of conses
<phoe> and conses are made of magic
wxie has quit [Ping timeout: 264 seconds]
<stargazesparkle> (:a 1) is just a list too right?
<frodef> NIL is the magic cons.
<frodef> yes
<phoe> yes, it's (:A . (1 . NIL))
<phoe> frodef: actually NIL is not a cons
<frodef> a list is defined recursively as either the empty list NIL, or (<element> . <list>)
<frodef> phoe: hence it's magic ;)
<phoe> frodef: a proper list, if we'd like the strict terms
<phoe> lists can be proper, improper, circular
<phoe> proper end with a NIL, improper end with a non-NIL, circular... don't end
<saturn2> magic because the reader magically knows () is another way of writing NIL?
saganman has joined #lisp
<frodef> saturn2: and because (car nil) is nil.
<saturn2> oh
<frodef> ..and cdr, obviously.
<phoe> that's a special case of CAR and CDR though, rather than an effect of NIL hypothetically being a cons
mankaev has quit [Read error: Connection reset by peer]
<frodef> phoe: yes, but it's sometimes useful to think of as a cons-cell that points to itself.
<beach> Maybe, but that would confuse the hell out of newbies.
cosimone has quit [Quit: cosimone]
<frodef> isn't that what we're here for?
norserob has joined #lisp
<beach> Some people here seem to have that as an objective, sure. :)
<phoe> well yes, and (typep nil 'cons) ;=> NIL
<frodef> well, shouldn't be too confusing to anyone comfortable with pointers and linked lists, really.
<phoe> so looking from the strict point of view, NIL isn't a cons - even if it kinda sorta behaves like one when put to CAR and CDR
<phoe> Schemers will also heavily disagree because their CARs and CDRs signal errors with empty lists instead
<phoe> I think that when someone goes for details and background info then it's important to know that CAR/CDR of NIL is NIL instead of an error purely for practical reasons
<beach> And for hysterical raisins.
<stargazesparkle> This has cleared up some of the confusion that I had
<phoe> NIL being both a symbol and a list is actually a bit troublesome when it comes to optimizing list accesses
mankaev has joined #lisp
<beach> stargazesparkle: Good. What you need to keep in mind is that a Common Lisp list is not an abstract data type. You constantly need to think about how it is represented.
<Nilby> NIL being magic is a convenience that points to a deeper truth
<phoe> the two common ways of representing NIL internally are representing it as a symbol and special-casing CAR/CDR, or representing it as a weird cons similar to (NIL . NIL) and special-casing tons of symbol operators
<stargazesparkle> What do you mean by thinking about how it is represented
<frodef> phoe: tons? Isn't it about 5?
<phoe> frodef: well, compared to CAR/CDR
<phoe> the former means that CAR/CDR are a bit slower now and they're heavily used in Lisp code; the latter means that things in the symbol world are gonna get messy because symbols also tend to be used a lot in some programs
<phoe> stargazesparkle: how NIL is implemented
<frodef> i'd say NIL is used tons more as a cons than as a symbol.
random-nick has joined #lisp
<frodef> well, mostly it's used for its identity, I guess.
<stargazesparkle> How do you differentiate between it's use as a symbol and as a cons?
<phoe> stargazesparkle: by writing it in code in a different way
<Alfr_> stargazesparkle, it's never a cons.
trocado has quit [Ping timeout: 240 seconds]
<phoe> oh right - as a symbol and as a list
<phoe> NIL, 'NIL, (), '()
<phoe> these are four different ways conveying different meanings
<stargazesparkle> Okay
<stargazesparkle> I've only used the first thus far
<phoe> (defun foo nil 42) would be a very bad way of defining a function though
mrios22 has quit [Ping timeout: 264 seconds]
<beach> stargazesparkle: () is used for empty parameter lists.
<stargazesparkle> Yeah I have used that form then
<stargazesparkle> What does it mean when a ' prefixes a label or expression?
<stargazesparkle> Like 'nil
Duuqnd has joined #lisp
<phoe> oh
<phoe> you *need* to read an intro book to Lisp
<phoe> like PCL or Gentle
<phoe> it is a quote, and quoting is one of the most important mechanisms of Lisp dialects in general
<stargazesparkle> I have read absolutely no books lol and am just brute forcing this shit so far
<stargazesparkle> I should though
<phoe> that's... a tough way of learning
<phoe> (list pi 'pi pi 'pi)
<stargazesparkle> It's been rough
<phoe> no wonder it's been rough
<beach> For the teachers as well.
<Alfr_> stargazesparkle, or memorize the spec. ;)
<stargazesparkle> Idk what #'1+ really means either but I do know that I can do that to sort of pass 1+ to another function
<phoe> minion: tell stargazesparkle about pcl
<minion> stargazesparkle: look at pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<phoe> please digest that one first
<beach> Now I keep forgetting where in the Common Lisp HyperSpec those different uses of NIL are discussed.
<phoe> it'll tell you all you want to know about ' and #' and how they differ and how they're used.
<Alfr_> clhs 2.4.8.2
<Alfr_> stargazesparkle, ^
<stargazesparkle> Oh okay that makes sense
<stargazesparkle> I swear I'm not dumb I just don't know the names of things
mankaev has quit [Read error: Connection reset by peer]
mankaev has joined #lisp
<ralt> you are actually dumb because you don't want to read a few chapters of a free online book that will give you all the names of things you need :)
<stargazesparkle> This is going to be like that one time I tried learning C and wrote code like *********deck because I don't actually know what a pointer was
<stargazesparkle> I'll read it when I wake up
<stargazesparkle> Atm I am too sleepy to digest something as dense as a book
<phoe> go get your rest then
saganman has quit [Ping timeout: 260 seconds]
<stargazesparkle> I can't sleep yet
<stargazesparkle> I'm just... in a limbo
<frodef> lispbo?
<phoe> well, this does sound like a problem #lisp cannot help you with
<stargazesparkle> I'm sure there is a macro for it
<stargazesparkle> Har har
<stargazesparkle> Anyway GN and thanks y'all
lowryder has quit [Ping timeout: 264 seconds]
lowryder has joined #lisp
rogersm has joined #lisp
rogersm has quit [Ping timeout: 256 seconds]
<oni-on-ion> that reminds me of learning C (on wolfenstein3d source code). did not know pointers for a while
EZEK has joined #lisp
<EZEK> hi
<beach> Hello EZEK.
<phoe> heyyy
<EZEK> how are yall?
<beach> That's off topic :)
<phoe> beach: xD
<phoe> come on, let's not be *this* orthodox
<beach> EZEK: What can we do for you?
<phoe> I don't imagine #lisp as a place where small amounts of greetings and small chat are considered offtopic
<beach> EZEK: You are new here right?
<beach> phoe: Hence the smiley.
<phoe> Internet transfers emotions really poorly; the smiley could be read as sarcasm when lacking context, and I kinda don'have context because I know you
<phoe> might not be the case for other/new people
<phoe> s/don'have/do have/
<beach> OK, I apologize.
<beach> EZEK: ^.
<phoe> no problem; it's just the issue of IRC being a poor fit for some things, like all protocols that perform human-to-text transformations
<phoe> EZEK: what's up?
aorst has joined #lisp
andreyorst has quit [Ping timeout: 246 seconds]
dilated_dinosaur has quit [Ping timeout: 264 seconds]
vegansbane6 has quit [Quit: The Lounge - https://thelounge.chat]
pfdietz has quit [Remote host closed the connection]
hendursa1 has quit [Ping timeout: 240 seconds]
hendursa1 has joined #lisp
norserob has quit [Remote host closed the connection]
rogersm has joined #lisp
<jmercouris> good morning everyone
<phoe> heyyy
v3ga has quit [Ping timeout: 272 seconds]
jonatack has quit [Quit: jonatack]
norserob has joined #lisp
rogersm_ has joined #lisp
jonatack has joined #lisp
vegansbane6 has joined #lisp
v3ga has joined #lisp
mrios22 has joined #lisp
jonatack has quit [Ping timeout: 240 seconds]
rogersm_ has quit [Ping timeout: 264 seconds]
jonatack has joined #lisp
EZEK has quit [Read error: Connection reset by peer]
rogersm has quit [Quit: Leaving...]
paul0 has joined #lisp
zxcvz has joined #lisp
v88m has joined #lisp
Stanley00 has quit [Remote host closed the connection]
surabax has joined #lisp
jeosol has quit [Remote host closed the connection]
Bubo_ has joined #lisp
Bubo_ has quit []
BuboBubo_ has joined #lisp
BuboBubo_ has left #lisp [#lisp]
scymtym__ is now known as scymtym
<jmercouris> I have the unicode ID for a character, how can I convert that to the actual character?
<jmercouris> I.E. I have 97, I would like to get a lowercase A
<jmercouris> 'A'
<frodef> CODE-CHAR ?
<frodef> denoted #\A in CL.
<jmercouris> frodef: right
<jmercouris> that is not guaranteed to be unicode though, is it?
gko_ has joined #lisp
<jackdaniel> it would be conforming for the implementation to return #\x
<frodef> jmercouris: that's implementation-dependent, I believe.
<jmercouris> right, so it happens to work on some implementations, but it is no guarantee
<jackdaniel> afair the only gurantee is that (eql char (code-char (char-code char)))
<jmercouris> I guess I will just have to settle for that
<jackdaniel> from the practical standpoint it will be usually unicode though (or at least ascii)
<phoe> for all practical purposes code-char is good on all implementations that implement unicode
<frodef> there are libraries like cl-unicode that I'm guessing deals with this.
<phoe> also cl-unicode
<jmercouris> hm, OK, thanks for the help
<jmercouris> I will look into these shims if it comes to be a problem
imode has quit [Ping timeout: 260 seconds]
isBEKaml has joined #lisp
rogersm has joined #lisp
rogersm has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 256 seconds]
andreyorst has joined #lisp
scymtym has quit [Ping timeout: 264 seconds]
aorst has quit [Ping timeout: 246 seconds]
akoana has joined #lisp
isBEKaml has quit [Quit: leaving]
birdwing has joined #lisp
igemnace has quit [Quit: WeeChat 3.0]
dbotton has joined #lisp
mrios22 has quit [Remote host closed the connection]
stzsch|2 has joined #lisp
gutter` has joined #lisp
stzsch has quit [Read error: Connection reset by peer]
gutter has quit [Read error: Connection reset by peer]
dilated_dinosaur has joined #lisp
dbotton has quit [Quit: Leaving]
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
scymtym has joined #lisp
luckless has quit [Ping timeout: 240 seconds]
rpg has joined #lisp
wsinatra has joined #lisp
galex-713 has quit [Read error: Connection reset by peer]
galex-713 has joined #lisp
luckless has joined #lisp
rogersm has joined #lisp
Blackraider has joined #lisp
Blackraider has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
rogersm has quit [Ping timeout: 264 seconds]
Bike has joined #lisp
rumbler31_ has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
todun has joined #lisp
pfdietz has joined #lisp
trocado has joined #lisp
dbotton has joined #lisp
<pfdietz> NIL punning is a bit of ancestral baggage in Common Lisp. Scheme got rid of it, but also had many other differences.
trocado has quit [Ping timeout: 246 seconds]
<frodef> scheme got rid of most of the things that are great about CL, imo.
mrios22 has joined #lisp
euandreh has quit [Ping timeout: 272 seconds]
<jmercouris> I'm using gtk_widget_get_size_request from this page: https://developer.gnome.org/gtk3/stable/GtkWidget.html
<jmercouris> what I am trying to figure out is how to make a pointer to some memory address in CFFI
<jmercouris> because gtk_widget_get_size_request is supposed to populate the addresses with the correct values of the calculations
euandreh has joined #lisp
<jackdaniel> you know, this is documented in cffi manual
<jmercouris> here is the twist
<jmercouris> I am doing this with cl gobject introspection
<jmercouris> therefore, I am not sure doing it the way I described will even work
<jmercouris> also it is a "gint"
<jmercouris> not an "int"
<jmercouris> whatever that means
<jmercouris> so I can't exactly just declare a int, can I?
<jmercouris> so yes, I COULD (cffi:make-pointer 1)
<jmercouris> but I don't know if that makes any sense
<phoe> what type is a gint under the hood?
<jmercouris> I have no idea I'm afraid
<jackdaniel> second result in dgg under "gtk gint"
<jmercouris> I see, I haven't had much luck in the past with searching for GTK lore
<jackdaniel> you could invest some time in searching for information skill
<jmercouris> I am usually only looking at the documentation
<pfdietz> I think cffi could use some optimization. I made a change to it recently that sped up an application that uses it by about 10%.
<jmercouris> pfdietz: you're telling me, we have CFFI performance problems ALL the time
frodef has quit [Quit: ERC (IRC client for Emacs 26.3)]
sjl has joined #lisp
rumbler31_ has joined #lisp
hiroaki has quit [Ping timeout: 260 seconds]
Duuqnd has quit [Remote host closed the connection]
hiroaki has joined #lisp
Duuqnd has joined #lisp
hiroaki has quit [Remote host closed the connection]
<pfdietz> EQL hash tables can be much faster than EQUAL hash tables. With the former, lookups on :uint32 were mostly hitting the hash table previous key cache.
hiroaki has joined #lisp
<pfdietz> I'm sure there are many other pieces of low hanging fruit. For example, it doesn't have to constantly be rechecking for typedef circularity.
<_death> this kind of performance naiveté is not limited to cffi.. we're just Lisp programmers abiding by Perlis ;)
frost-lab has quit [Quit: Connection closed]
hiroaki has quit [Remote host closed the connection]
hiroaki has joined #lisp
<pfdietz> On the plus side, it lets us engage in performance yak shaving.
ebrasca has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
luckless_ has joined #lisp
waleee-cl has joined #lisp
<_death> there are a zillion testing libraries, but not a lot of benchmarking libraries.. asdf has a test-op but no benchmark-op..
luckless has quit [Ping timeout: 240 seconds]
<pfdietz> My other performance peeve: json parsers.
<phoe> pfdietz: zulu.inuoe is working on this
<pfdietz> I know there was discussion recently about it.
<phoe> I'll race him a little bit, once I finish yak shaving a state machine library
Cymew has quit [Ping timeout: 265 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<jmercouris> ah... yes a state machine library, I am working on one as well
<jmercouris> for internal reasons though
<phoe> what is yours going to be like?
<jmercouris> I will be using it for machine learning purposes
amb007 has quit [Read error: Connection reset by peer]
<jmercouris> so it will just have a class called 'state'
<jmercouris> and there will be a slot called transitions
<jmercouris> and there will also be transition objects
<jmercouris> transition objects can contain guards, predicates, etc
amb007 has joined #lisp
<jmercouris> the whole point of this FSM is to model nominal operation of a system
<jmercouris> when the system detects an errant transition, a guard not satisfied, etc, it signals an error
<jmercouris> to elaborate, the slot called transitions will contain a list of transition objects
<phoe> oh, sounds nice
<jmercouris> the really cool thing about this model is that it can be trained by observing a system under nominal conditions
<jmercouris> therefore I do not have to program 'what' to look for, I only give it some signals, and these are modeled by the system and saved in the transition objects
<jmercouris> it's not a terribly complex system, but my goal is not performance or anything, but adaptability/customizability
<jmercouris> as I will be using it to model and observe non-uniform systems
<phoe> I'm trying to get compile-time checks for invalid transitions and such in my own FSM
<jmercouris> that's pretty cool
<jmercouris> how does that work at compile time?
<jmercouris> are the transitions known at that time?
<jmercouris> you have a description language for writing out your FSM?
<phoe> first you define a state machine that lists all transitions, so which states can go into which states
<jmercouris> I see
<jmercouris> and then what is a so-called invalid transition?
<jmercouris> a transition that does not exist in your drawn out FSM?
<phoe> then you define what a given state does, and it has access to the info stored in a state machine information
<phoe> and therefore a macroexpander for a given state can check if a transition is allowed in the state machine
<phoe> if it's allowed, it can expand into proper code; if it's not, it can signal a macroexpansion-time error
iamFIREcracker has joined #lisp
<jmercouris> hm I see
<jmercouris> what kind of applications do you see for this?
<phoe> a JSON parser :D
<jmercouris> 11
<jmercouris> ay yai yai, it all comes back to this
<jmercouris> well, a good a usage as any
<phoe> but, no, I want to be able to compile my state machine into a single tagbody form
<jmercouris> I see, that will be a pretty novel approach
<phoe> (well, a PROG form, to be precise)
<phoe> no CLOS, no MOP, no method calls, no structs, no anything - just LET over BLOCK over TAGBODY that uses generated GO forms to jump across states
scymtym has joined #lisp
<phoe> if I do it correctly, I'll also be able to test individual states rather than the whole state machine at once
<phoe> should be fast.
<jmercouris> that's crazy, you are basically writing ASM
<phoe> (tagbody 10 (print "yes") 20 (go 10))
<jmercouris> except you are rather writing a system to write ASM
<jmercouris> you are writing a compiler for a JSON parser in a way
<jmercouris> every time we write a macro, we are writing a mini compiler
<jmercouris> if I think about it
luckless_ has quit [Quit: luckless_]
luckless has joined #lisp
<phoe> well, if a compiler transforms source code into source code
<phoe> then each macro function is a compiler
<phoe> and since each idempotent mostly-pure function is allowed to be a good macro function...
* phoe thinks, has he accidentally been writing compilers for the past few years?
nicktick has joined #lisp
frodef has joined #lisp
<jmercouris> phoe: you have, without knowing it
<jmercouris> that's the difference between a Lisp developer and other developers
<jmercouris> a Lisp developer writes compilers on accident
<jmercouris> its the itch I had so often in other languages, I didn't even know what I was missing
<jmercouris> I always thought to myself, "but all of these stubs could be auto generated"
<jmercouris> sure there were mechanisms, kludges you could use, but sometimes a macro is invaluable
<jmercouris> anyways, preaching to the choir is pointless
<phoe> hm
Duuqnd has quit [Remote host closed the connection]
<Xach> if not compilers, nanotranspilers
v88m has quit [Read error: Connection reset by peer]
v88m has joined #lisp
gaqwas has quit [Remote host closed the connection]
<_death> the compiler provides a hook for ad hoc extensions.. you can write an extension which is a compiler itself
rogersm has joined #lisp
<jmercouris> pjb would argue that transpilers aren't a thing
<jmercouris> and that the only thing is compilers
msk_ has joined #lisp
<jmercouris> from Wikipedia "In computing, a compiler is a computer program that translates computer code written in one programming language (the source language) into another language (the target language)"
<phoe> _death: do you mean the infamous *macroexpand-hook*?
msk has quit [Remote host closed the connection]
<jmercouris> maybe he means GCC extensions
<jmercouris> or LLVM frontends
<_death> phoe: I mean macros
<jmercouris> isn't it kind of redundant to say "extensible macros"?
<jmercouris> aren't macros by definition extensions?
<jmercouris> so shouldn't we call Emacs just Macs?
wsinatra has quit [Ping timeout: 264 seconds]
<_death> E is for editor?
<jmercouris> yes, damnit :-D
<jmercouris> EMACS (Editor MACroS)
<pfdietz> I LOVE the macroexpand hook!
Josh_2 has joined #lisp
rogersm has quit [Ping timeout: 264 seconds]
<Josh_2> Hi, has anyone got any experience serving videos from hunchentoot to ios users?
raamdev[m] has quit [Quit: Idle for 30+ days]
<jackdaniel> Josh_2: if you serve a big file, then you should be vary, that hunchentoot first loads the file into memory and after that it sends it
<jmercouris> Josh_2: I have experience serving videos via Lisp
<jmercouris> Josh_2: I VERY much strongly suggest letting a reverse proxy handle it
andreyorst_ has joined #lisp
<jmercouris> it will be significantly more performant
<Josh_2> Well I use nginx
<Josh_2> and pass traffic from nginx to my hunchentoot instance
<Josh_2> the problem isn't just loading up videos and sending them jackdaniel, the problem is that safari has a very specific way you have to respond to certain headers
<jmercouris> write a NGINX rule for this
<jmercouris> and let it handle that directory separately
<jmercouris> I'll show you a sample configuration file that I use
<Josh_2> okay
<jmercouris> Josh_2:
<jmercouris> as you can see, /static will be handled by Nginx, anything else will proxy pass through
<Josh_2> right
<Josh_2> okay I can have a similar config however the way my site works right now is you have a html page and within it a single video, the video is chosed based on a get parameter
<Josh_2> chosen*
<jmercouris> that is irrelevant
<jmercouris> the assets on that page will still be fetched by Nginx
<jmercouris> the page can be dynamically generated, but the content static
<jmercouris> for example our homepage: https://nyxt.atlas.engineer
<jmercouris> dynamically generated, the videos statically served
<jmercouris> the images as well
<jmercouris> am I making sense?
<Josh_2> Yes I understand you completely
<jmercouris> OK
<Josh_2> but I don't think my example is so simple
<jmercouris> are you sure?
<jmercouris> unless the videos are dynamically generated, it is
<jmercouris> even IF the videos are dynamically generated, you could write the file stream to the static directory
<jmercouris> and have Nginx serve them
jeosol has joined #lisp
<Josh_2> how do I get nginx to select the correct file? because currently I am just doing (to-octets (random (length <my static dir))) and then serving that
<jmercouris> the correct file is determined by the URL
<jmercouris> so you would create a video tag and set the URL to whatever
<jmercouris> relative to your root
<jmercouris> URLS can be relative
<Josh_2> yes I understand that
<jmercouris> so if you have something in /static/potato on your disk
<jmercouris> you could have <video rel="/static/potato"> and it would load it
<Josh_2> I guess I can just rename all the content to obscure their names
<jmercouris> it would try to find an asset located at josh_2.com/static/potato
<Josh_2> yes I understand
<jmercouris> you may also require authentication for the assets
<jmercouris> this can be configured for Nginx as well
<Josh_2> Okay I think I know a solution
<jmercouris> I guess you were trying to use Lisp as an insulation to protect some assets?
<jmercouris> you can do the same with Nginx
<Josh_2> nope
<Josh_2> I am trying to serve random content each refresh
<jmercouris> that is still very possible
<jmercouris> I don't see what the problem is, your Lisp application just needs to know all of the content, which it can scan by itself using UIOP
<jmercouris> it can then just randomize what video tag it generates
<Josh_2> I have a redirect button that randomizes a get parameter, the get parameter is a random position in a list of files (the content) then when the page is loaded the video in that position of the list is loaded
<Josh_2> yes
<jmercouris> I see
<Josh_2> I think I will do that, I will just have to mass rename the content
<jmercouris> OK
<jmercouris> I suggest using emacs
<Josh_2> I am using emacs :P
<jmercouris> you can use C-x C-q to edit the files en masse
<Josh_2> okay coolio
<jmercouris> in dired, the file names become editable like a text file
BuboBubo has joined #lisp
<Josh_2> yep
<jmercouris> good luck Josh the 2nd
<jmercouris> hopefully that was helpful
<jmercouris> so, whenever I launch a GTK window via Gobject introspection I lose my REPL
<jmercouris> is there a way to prevent that?
<jmercouris> so that I may still type interactively?
surabax_ has joined #lisp
<Josh_2> do I have to keep the extension on my files for nginx to determine the mime type? they are all mp4
<jmercouris> Josh_2: yes
<jmercouris> Josh_2: typically
<Josh_2> okay
heisig has quit [Quit: Leaving]
surabax is now known as Guest58664
surabax_ is now known as surabax
Guest58664 has quit [Killed (rothfuss.freenode.net (Nickname regained by services))]
<Josh_2> in your config file is 'root /root/nyxt-site/;' the root location of your site?
<jmercouris> Josh_2: correct
<Josh_2> okay cool
<Josh_2> I just need a neat way of adding new files and keeping them in line with the naming scheme and all should be hunky dory
Stanley00 has joined #lisp
gutter` has quit [Remote host closed the connection]
Stanley00 has quit [Ping timeout: 246 seconds]
hiroaki has quit [Ping timeout: 272 seconds]
luni has joined #lisp
rogersm has joined #lisp
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
wsinatra has joined #lisp
hiroaki has joined #lisp
todun has quit [Quit: todun]
rogersm_ has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
fangyrn has joined #lisp
rogersm_ has quit [Ping timeout: 240 seconds]
Bahman has joined #lisp
dyelar has joined #lisp
gaqwas has joined #lisp
<Josh_2> is there a way I can move a file without having rewrite the file in a new directory?
mindCrime has joined #lisp
gioyik has joined #lisp
harlchen has joined #lisp
<Nilby> Josh_2: maybe rename-file
v88m has quit [Ping timeout: 260 seconds]
pfdietz has quit [Ping timeout: 245 seconds]
yonkunas has joined #lisp
v88m has joined #lisp
<rogersm> Josh_2: does the code need to be portable?
<contrapunctus> I happened to type `ecl` at a terminal and got this - http://paste.debian.net/1180220/ (typed and entered 1, but got the same prompt again and again; if I C-d all prompts, it segfaults.)
<travv0> that's a pretty old version of ecl
dbotton has quit [Quit: Leaving]
kini has quit [Quit: bye]
kini has joined #lisp
<contrapunctus> Debian Sta(b)le
luni has quit [Quit: Connection closed]
<jeosol> Is anyone working on natural language processing with CL (open libs) and have recommendations. Looking at cliki, I see a few libraries langutils and elsewhere vseloved's cl-nlp. Haven't used any system in CL but family with python's spaCy
<jeosol> s/family/familiar.
<jeosol> Also, not an NLP expert, but my larger goal is to part some document, excel file and extract word tokens that my help me create rules (.e.g., crude decision tree)
Steeve has joined #lisp
<fangyrn> jeosol: there is https://github.com/vseloved/cl-nlp, but I have never used it
<fangyrn> sorry, didn't realize you already mentioned it. I am an idiot.
<jeosol> fargyrn: no worries.
<fangyrn> jeosol: If you use ABCL you will be able to use Java NLP libraries really easily and those are quite well-renowned, like the stanford one
<jeosol> I am just trying to get high-level recommendations from those who may have worked in this space.
gutter has joined #lisp
notzmv has joined #lisp
<jeosol> oh ok. Unfortunately, my base code is in SBCL and never used other implementations, but I guess if nothing, I can look at ABCL and I can try to investigate separately
Steeve has quit [Client Quit]
<jeosol> fangyrn: Did you mean the Stanford CoreNLP above?
mrios22 has quit [Ping timeout: 240 seconds]
lucasb has joined #lisp
Steeve has joined #lisp
recalloc has quit [Remote host closed the connection]
ym has joined #lisp
hvxgr has quit [Quit: leaving]
<ym> Hi. Trying to wrap CLX into CLOS, getting error "Asynchronous VALUE-ERROR in request 31 (last request was 38) Code 1.0 [CreateWindow] Value 0." Could somebody guess what the problem could be?
<fangyrn> jeosol: yes. there is another one, openlp from googling right now. I just remember learning about
<fangyrn> I just remember learning about corenlp. I thought it seemed like quite a good nlp library (it had a lot of cool papers, I don't know about documentation).
<jackdaniel> ym: maybe you try to create-window with either x or y dimension = 0?
<jackdaniel> while it is ok-ish for pixmaps afair it doesn't work for windows
<jackdaniel> ym: what do you mean by "wrapping into clos"?
<jackdaniel> while by default everything is a structure, you may easily change it with a flag, so instead of structure-class you have standard-class instances
<jackdaniel> the flag is called xlib::*def-clx-class-use-defclass*
andreyorst_ has quit [Ping timeout: 265 seconds]
<ym> I use classes to encapsulate CLX parameters like window position, geometry, hierarchy etc and also to be able to create window with default parameters like just (make-instance 'x-window).
<ym> 0 window geometry doesn't seems like the case.
abhixec has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
rumpelszn has joined #lisp
<jackdaniel> I'd check for 0 values either way, that's what the error says
<jackdaniel> erm, I've meant width and height, not x and y
<jackdaniel> it would be easier if you could show the relevant code
rumpelszn has quit [Client Quit]
villanella has joined #lisp
andreyorst_ has joined #lisp
villanella has quit [Client Quit]
gko_ has quit [Ping timeout: 260 seconds]
<jackdaniel> there is nothing wrong in your code that I could immedietely find
<ym> Me neither. Same code without CLOS works fine.
<jackdaniel> apparently it is not the same code - maybe try to minimize it and trace xlib calls in the working and not working version to spot a difference
<aeth> fiddlerwoaroof: To me, I have a different approach. Essentially, if it's designed to be used inline, then being short probably makes sense. So vec+ might make more sense than vector-+... and Scheme's various aref equivalents are fairly annoying, e.g. vector-ref vs aref.
<aeth> But most things aren't really designed to be used on one line with many other things... basically just refs and arithmetic, most of the time.
<aeth> I guess SETF as well.
<aeth> jmercouris: Generally, for Unicode, if I know the implementation is OK, I'll use the implementation thing (so CODE-CHAR / CHAR-CODE in this case) and then for implementations I don't know, I'll have dependency, maybe even an optional dependency that's only loaded for those generic implementations, that guarantees the behavior.
<aeth> jmercouris: Because it'll be much slower.
<aeth> jmercouris: e.g. an inline UNICODE-CODE-CHAR function that #+(or sbcl ccl ecl ...) uses CODE-CHAR and otherwise uses a portability library, just in case.
kaftejiman has joined #lisp
<aeth> Something like this probably could be a library because it won't really cause any problems except if it makes something hit SBCL's inline expansion limit (which is to prevent accidental recursion of an inline function)
Steeve has quit [Quit: end]
matryoshka` has quit [Quit: ZNC 1.8.2 - https://znc.in]
matryoshka has joined #lisp
<Josh_2> rogersm: no it doesn't
<Josh_2> I'm using sbcl
<rogersm> Josh_2: is this for unix? What about calling mv?
<Josh_2> yes I could just call mv
<Josh_2> I suppose that is the easiest way
<rogersm> If I'm not mistaken asdf had a run-shell-command
<Josh_2> uiop has a command for running shell commands
<rogersm> uiop then
<Josh_2> (uiop:run-program .. )
hnOsmium0001 has joined #lisp
abhixec has joined #lisp
<Josh_2> Yep worked like a charm
contrapunctus has left #lisp ["Disconnected: closed"]
gxt has quit [Ping timeout: 240 seconds]
contrapunctus has joined #lisp
Steeve has joined #lisp
Steeve has quit [Client Quit]
<Josh_2> jmercouris: your version using nginx to serve content appears to be working just fine, thanks!
<rogersm> any of you using Fukamichi's mito db library?
gxt has joined #lisp
catern has quit [Quit: catern]
rogersm_ has joined #lisp
matryoshka has quit [Read error: Connection reset by peer]
matryoshka has joined #lisp
Lord_of_Life_ has joined #lisp
matryoshka` has joined #lisp
matryoshka has quit [Read error: Connection reset by peer]
Lord_of_Life has quit [Ping timeout: 272 seconds]
Lord_of_Life_ is now known as Lord_of_Life
matryoshka` has quit [Client Quit]
rogersm_ has quit [Ping timeout: 240 seconds]
matryoshka has joined #lisp
aeth has quit [Ping timeout: 265 seconds]
<ym> Damn. How that comes that slime's restart-inferior-lisp doesn't actually restarts inferior lisp program?
<phoe> wait
<phoe> how
matryoshka has quit [Client Quit]
<phoe> it restarts it for me
matryoshka has joined #lisp
Steeve has joined #lisp
aeth has joined #lisp
<scymtym> it doesn't (and can't) work if the connection was made with M-x slime-connect instead of M-x slime
abhixec has quit [Ping timeout: 264 seconds]
<phoe> oh! yes
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
matryoshka has quit [Quit: ZNC 1.8.2 - https://znc.in]
matryoshka has joined #lisp
remby has quit [Quit: remby]
rogersm has quit [Quit: Leaving...]
matryoshka has quit [Client Quit]
flazh has joined #lisp
matryoshka has joined #lisp
matryoshka has quit [Quit: ZNC 1.8.2 - https://znc.in]
matryoshka has joined #lisp
sauvin has quit [Remote host closed the connection]
birdwing has quit [Ping timeout: 272 seconds]
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
matryoshka has quit [Read error: Connection reset by peer]
matryoshka has joined #lisp
matryoshka has quit [Read error: Connection reset by peer]
<fiddlerwoaroof> Does anyone have experience with traversing all of an ASDF system's components and those of its dependencies?
matryoshka has joined #lisp
<phoe> fiddlerwoaroof: you mean getting a list of all transitive dependencies?
<fiddlerwoaroof> I want to map over every component of every dependency
rumbler31_ has quit [Ping timeout: 246 seconds]
<phoe> oh, *components*
<phoe> I haven't done that
<fiddlerwoaroof> Plus every component of the specified system
joast has quit [Read error: Connection reset by peer]
joast has joined #lisp
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
rpg has joined #lisp
<devon> Has anyone ever used TRIVIAL-MMAP? Examples don't compile, macroexpansion time file access, posix munmap called with wrong args, ... and that's just at first glance.
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
luni has joined #lisp
matryoshka has quit [Client Quit]
amb007 has quit [Ping timeout: 260 seconds]
amb007 has joined #lisp
<devon> QL seems entirely uncurated, except they have to compile.
<Xach> devon: that's accurate
<devon> LOL, how might we address this?
<Xach> devon: I'm not sure - what is your goal?
amb007 has quit [Read error: Connection reset by peer]
<contrapunctus> (It's like sharing that link is my primary contribution to this channel. 😏)
amb007 has joined #lisp
ym has quit [Quit: Leaving]
<devon> Xach: In this case, to use mmap without crashes, memory leaks, re-inventing existing systems, ...
amb007 has quit [Read error: Connection reset by peer]
<Bike> have you tried shinmera's library?
troydm has quit [Quit: What is Hope? That all of your wishes and all of your dreams come true? To turn back time because things were not supposed to happen like that (C) Rau Le Creuset]
amb007 has joined #lisp
<devon> The bad system was smallest so I tried it first.
troydm has joined #lisp
<Bike> okay, so i mean, if shinmera's library works you can use mmap without crashes and so on, so there's your goal met. If what you want is for the first system you find to work for you that's a little different.
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<Xach> devon: right - so do you see the process as doing more than just compile, like try running tests for each project too?
fourier has joined #lisp
rumbler31_ has joined #lisp
fourier has quit [Changing host]
fourier has joined #lisp
jonatack has quit [Quit: jonatack]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<devon> Xach: These particular broken examples are embedded in the doc and this particular broken system has no tests. However, I see a clue in (quicklisp-client:who-depends-on "trivial-mmap") => NIL and (quicklisp-client:who-depends-on "mmap") => ("3bz" "cl-maxminddb" "mmap-test" "pngload")
<Bike> the tests would just be written by the library developer, right? doesn't seem like that would work to weed out poorly functioning libraries, they'd just have poorly functioning tests
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
eddof13 has joined #lisp
Stanley00 has joined #lisp
jonatack has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
amb007 has joined #lisp
skapata has joined #lisp
gxt has quit [Ping timeout: 240 seconds]
gxt has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
Stanley00 has quit [Ping timeout: 246 seconds]
amb007 has joined #lisp
<devon> Xach: To help find good systems, perhasp QL:SYSTEM-APROPOS or similar should allow ranking by popularity, i.e., how many other authors use this as a component?
jonatack has quit [Ping timeout: 240 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
jonatack has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
<_death> recently a dataset has been made that contains the number of downloads for quicklisp projects
amb007 has joined #lisp
<Xach> devon: that's an interesting metric
<Xach> some time ago i came up with a plan to allow anyone to contribute "tests" to any project, to be run when building quicklisp dists.
rumbler31_ has quit [Ping timeout: 240 seconds]
<Xach> this is it --> https://github.com/quicklisp/qlt
<Xach> i have not used it or tried to get others to use it though :~(
l1x has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<devon> Xach: It's not in QuickLisp but I'll try it anyway.
amb007 has quit [Read error: Connection reset by peer]
<Xach> devon: it sprung from a very specific situation and it might not solve a problem you have, though, sorry :~(
amb007 has joined #lisp
<Xach> sprung? sprang.
hendursaga has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 246 seconds]
stzsch|2 has quit [Quit: KVIrc 5.0.0 Aria http://www.kvirc.net/]
amb007 has quit [Read error: Connection reset by peer]
hendursaga has joined #lisp
stzsch has joined #lisp
amb007 has joined #lisp
andreyorst_ has quit [Ping timeout: 264 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<_death> I too have a poc mmap library, but it may break at any time..
<Josh_2> I have dumped my lisp image and it runs and executes as expected on my machine, but when I load it to my server I have the following problem https://plaster.tymoon.eu/view/2229#2229 now I don't understand why It's working fine on my machine but failing on my server
frgo has joined #lisp
<Josh_2> my server is running sbcl 2.0.6 and my machine is running 2.0.11
anticrisis has joined #lisp
<Josh_2> the image was build with asdf:make
rumbler31_ has joined #lisp
<_death> Josh_2: is your image a core file or an executable?
<Josh_2> hmm
<Josh_2> it is built with :build-operation "program-op" in my asd and I have a little makefile that loads the asd, quickloads the project then executes asdf:make
<_death> shouldn't expect an old sbcl to load a core produced by a new one
<Josh_2> oh also I have (defmethod asdf:perform ((o asdf:image-op) (c asdf:system)) (uiop:dump-image (asdf:output-file o c) :executable t :compression t)) in my asd
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
<_death> an executable, so I guess the sbcl on your server is irrelevant
dbotton has joined #lisp
<Josh_2> yes
<Josh_2> well I guess I can just build the system on my server
<Josh_2> ¯\_(ツ)_/¯
<_death> I would try checking how clack "handlers" work, that may have something to do with the failure
erronius has joined #lisp
<erronius> Is there anyoen here?
rumbler31_ has quit [Ping timeout: 264 seconds]
liberliver has quit [Quit: liberliver]
rogersm has joined #lisp
<Josh_2> erronius: nope
<Xach> erronius: i am here
<Josh_2> except all the people who are talking obviously
<erronius> Ah
<erronius> Thanks for the info.
<erronius> Now what? I've got things that are mandated of me that I've got to do something about but I'm not allowed to.
<erronius> By my own actions.
<erronius> "What do I do about the loopback adapter?"
<erronius> Or usually because I never come to a terminal that I trust enough.
<Josh_2> _death: building on the server worked
<erronius> "Look at me, look at me, look at me!" But it's someone else saying that, but I'm the me, of them, that is who's being looked at?
rogersm has quit [Ping timeout: 246 seconds]
<erronius> At least I'm not involuntarily shouting "I'll take point!" anymore.
<erronius> Gotta go
<Xach> Ok
matryoshka has joined #lisp
aeth_ has joined #lisp
aeth has quit [Disconnected by services]
aeth_ is now known as aeth
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
Steeve has quit [Quit: end]
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
aartaka_d has quit [Ping timeout: 240 seconds]
matryoshka has quit [Client Quit]
matryoshka has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
Stanley00 has joined #lisp
hendursaga has joined #lisp
<etimmons> Josh_2: Ugh. I've dealt with that error too many times before
rumbler31_ has joined #lisp
<etimmons> Clack lazy loads its backends
<etimmons> Try quickloading :clack-handler-hunchentoot before the asdf:make
miracle_fox has joined #lisp
Stanley00 has quit [Ping timeout: 264 seconds]
Nilby has quit [Read error: Connection reset by peer]
abhixec has joined #lisp
wsinatra has quit [Ping timeout: 272 seconds]
semz has quit [Quit: Leaving]
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Remote host closed the connection]
karlosz has joined #lisp
<Josh_2> I am trying to connect my remote image using slynk, I keep getting the following error https://plaster.tymoon.eu/view/2230#2230 the file it is looking for does exist
<phoe> Josh_2: does this file actually exist?
<Xach> well, i'm thinking of adopting access into sharplispers temporarily
<Josh_2> yes the file exists
<phoe> Xach: you mean qlt?
<Xach> no word from AccelerationNet about it
<Xach> phoe: no
<phoe> oh, access, the library
<phoe> Josh_2: weird. (probe-file #p"/home/josh/quicklisp/dists/quicklisp/software/sly-20201220-git/slynk/slynk-backend.lisp")? `ls -alh /home/josh/quicklisp/dists/quicklisp/software/sly-20201220-git/slynk/slynk-backend.lisp`?
miasuji has joined #lisp
<Josh_2> phoe the former returned the pathname
<phoe> so the file *does* exist
<phoe> let's grab a stacktrace
zacts has joined #lisp
<Josh_2> https://plaster.tymoon.eu/view/2230#2230 includes backtrace now
zacts has quit [Client Quit]
<stargazesparkle> Aww, ironclad doesn't support AES in GSM mode
<phoe> hey wait, that's a different error
<phoe> the first one was about a .lisp file and the second is about a .fasl file
<phoe> anyway, what if you hit restart 0 or something?
<Josh_2> oh right
<Josh_2> one sec sorry
<Josh_2> if I hit 0 I get the error I mentioned
<Josh_2> I will append that to the paste
<phoe> weird; now it's complaining about completion, previously it was complaining about backend
fourier has quit [Remote host closed the connection]
<phoe> do you have unix rights to access the file?
<Josh_2> yes It's the same user
<Josh_2> I will double check
<Josh_2> oh wait thats on the remote server
<phoe> ...
<phoe> do you have the file on the same machine where you are executing the Lisp process?
<phoe> :D
<Josh_2> uh that might be why
wsinatra has joined #lisp
<Josh_2> #P"/home/manage/.cache/common-lisp/sbcl-2.0.11-linux-x64/home/josh/quicklisp/dists/quicklisp/software/sly-20201220-git/slynk/slynk-completion.fasl" that is a big invalid pathname
<phoe> not really invalid
<phoe> that's what CL caches look like
<phoe> ...oh, wait, did you copy FASLs from one machine from the other?
<Josh_2> no
<phoe> huh
<phoe> why did you get a josh pathname on a manage user then
<phoe> oh well
<Josh_2> manage is the user on the remote server
<Josh_2> josh is my local user
<Josh_2> that fasl doesn't exist on the remote server anyway
fourier has joined #lisp
<Josh_2> slynk-backend-tmpA72A9OJZ.fasl slynk-completion-tmpD2D7RXIM.fasl slynk-source-path-parser-tmp47SOVWJ1.fasl slynk-tmp24BDVRKR.fasl those exist in the directory is it searching for
fourier has quit [Changing host]
fourier has joined #lisp
dbotton has quit [Quit: Leaving]
sjl has quit [Ping timeout: 265 seconds]
aorst has joined #lisp
BuboBubo has quit []
andreyorst has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
manicennui has joined #lisp
narimiran has quit [Ping timeout: 256 seconds]
lowryder has quit [Ping timeout: 246 seconds]
Codaraxis has joined #lisp
lowryder has joined #lisp
imode has joined #lisp
pve has quit [Quit: leaving]
rogersm has joined #lisp
rogersm has quit [Ping timeout: 240 seconds]
miasuji has quit [Remote host closed the connection]
miasuji has joined #lisp
ex_nihilo has quit [Read error: Connection reset by peer]
l1x has quit [Quit: Connection closed for inactivity]
euandreh has quit [Ping timeout: 246 seconds]
* frodef quite enjoys emacs keyboard macros.
rozenglass has joined #lisp
wsinatra has quit [Quit: WeeChat 3.0]
luni has quit [Quit: Connection closed]
jprajzne has quit [Quit: Leaving.]
mindCrime has quit [Ping timeout: 260 seconds]
yonkunas has quit [Quit: Connection closed for inactivity]
pp is now known as ppbitb
akoana has left #lisp ["Leaving"]
harlchen has quit [Quit: WeeChat 3.0]
attila_lendvai has quit [Ping timeout: 272 seconds]
rpg has quit [Ping timeout: 246 seconds]