<Josh_2>
I dont see a problem but why aren't you using asdf to build?
<Yehowshua>
well, I have not yet tried asdf, only packages
<Josh_2>
Well you should look into asdf
<Yehowshua>
noted
<Josh_2>
After the first time asdf is pretty easy
<Josh_2>
Basically any CL project you can find on github will have a .asd, you can just copy that and replace what you want, ezpz problem solved :P
waleee has quit [Ping timeout: 240 seconds]
<Yehowshua>
will look into then
Yehowshua has quit [Quit: Client closed]
paulapatience has quit [Read error: Connection reset by peer]
markthom_ has quit [Quit: Client closed]
<jcowan>
lukego: There are a few other alphabets with case: Cyrillic, Coptic, Armenian, Adlam, Warang Citi, Cherokee, Garay, and Osage. Cyrillic is the most important after Latin because it's used by about 50 languages today.
Josh_2 has quit [Remote host closed the connection]
tyson2 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
makomo has quit [Ping timeout: 250 seconds]
montxero has quit [Read error: Connection reset by peer]
montxero has joined #commonlisp
<beach>
Good morning everyone!
semz has quit [Ping timeout: 256 seconds]
igemnace has joined #commonlisp
Lycurgus has joined #commonlisp
semz has joined #commonlisp
perrierjouet has quit [Quit: WeeChat 3.2]
<lukego>
jcowan: Tricky business. I would like a convenient way to use Greek letters in symbol names without case conversion. How should that affect other alphabets though? Options range from making all non-latin alphabets case-sensitive to leaving alphabets alone and defining new private unicode symbolic/non-alphabetic counterparts to the Greek alphabet to use in symbols.
lad has quit [Ping timeout: 252 seconds]
pranavats has left #commonlisp [Disconnected: Replaced by new connection]
<lukego>
I sense that I need to find a comp.lang.lisp post by Kent Pitman establishing the context of the whole READTABLE-CASE business.
pranavats has joined #commonlisp
rain3 has joined #commonlisp
akoana has joined #commonlisp
Bike has quit [Quit: Connection closed]
Everything has quit [Quit: leaving]
<lukego>
SBCL seems to compile really, really quickly even on my crappy laptop cpu. I wonder if it has improved a lot over the years or if I've just started mentally comparing it with LLVM?
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 245 seconds]
Qwnavery has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
Oladon has joined #commonlisp
Qwnavery has quit [Quit: WeeChat 3.2]
asarch has joined #commonlisp
<asarch>
One stupid question: an empty block closure is just nil, right?
<beach>
asarch: What is a "block closure", and what do you mean by "is"?
<kakuhen>
beach: I would guess (lambda () )
<kakuhen>
but i could be wrong, so i guess we should wait
<beach>
I prefer to see the answer.
<hayley>
The term "block closure" isn't defined anywhere, and a function is definitely not NIL.
<pjb>
((lambda())) #| --> nil |#
<beach>
pjb: So assume that "is" means "evaluates to"? I don't.
<hayley>
Oh, the last time someone said evaluates-to was an equivalence relation was fun.
<beach>
Heh!
<kakuhen>
i wonder what relation they were using and how they arrived to that w
shka has joined #commonlisp
Oladon has quit [Quit: Leaving.]
gaqwas has joined #commonlisp
<asarch>
Well, in Smalltalk there is a piece of code: html callback: [].
<asarch>
In this case, the callback handler is assigned an empty block closure
<asarch>
If that was a CLOS object, it would be like: (make-instance 'html :callback nil), right?
<akoana>
maybe a stupid question: if *ht* is a hash-table with integer values, and i want to increment (or initialize) each value, is this safe: (maphash #'(lambda (k v) (incf (gethash k *ht* 0))) *ht*) ?
<beach>
asarch: So a "block closure" is a Smalltalk term?
<pjb>
asarch: the equivalent of [] in lisp is (lambda ())
pve has joined #commonlisp
<pjb>
asarch: but indeed, in lisp we would more often use nil as a designator for (lambda ()); the function receiving the parameter would do something like (when callback (funcall callback)) instead of just (funcall callback).
<asarch>
I see
<White_Flame>
akoana: yep, though you don't need the #', that's pretty legacy
<asarch>
Thank you! Thank you very much :-)
jans has joined #commonlisp
<pjb>
asarch: other do-nothing functions are: (function identity) and (constantly nil)
<hayley>
I thought [ ... ] were called blocks and not closures.
<pjb>
yes, but they're really closures.
<White_Flame>
would the lisp equivalent be an empty (progn)?
<White_Flame>
instead of a lambda?
<hayley>
[ ] = (lambda ())
<akoana>
White_Flame: ah there, currently reading that... missed it (what a shame)
<White_Flame>
ok
<akoana>
White_Flame: thanks again
VincentVega has joined #commonlisp
<White_Flame>
akoana: np
<beach>
asarch: Thanks, but I am not that interested. I have a lot of other stuff to do more urgently.
lisp123 has quit [Ping timeout: 256 seconds]
<asarch>
Ok. Maybe later then
<beach>
Yes, after I finish SICL.
<hayley>
SIS (SIS Implements Smalltalk)
lisp123 has joined #commonlisp
<mfiano>
Does anyone know of a min heap based queue implementation that allows accessing the priority?
<beach>
lisp123: I think it is great that you are helping out in #clschool, but you need to be careful about getting your facts straight. There is nothing in the Common Lisp standard that says that functions are stored in symbol objects. And there is nothing that says that LOAD results in interpreted code.
<mfiano>
Currently using damn-fast-priority-queue, but doesn't seem to allow that. I need to keep dequeueing items until the priority is > some value (priorities are timestamps for deferred thunks to be executed some time later)
<beach>
pjb: I don't really understand what I am looking at, but that sounds like good news.
hendursa1 has joined #commonlisp
hendursaga has quit [Ping timeout: 276 seconds]
<moon-child>
[evaluates to as an equivalence relation] in fairness, the way 'is' is used, it's not generally an equivalence relation either
<moon-child>
it's generally not commutative, or transitive. 'life is fun' does not imply that 'fun is life'. (Except insofar as english _grammar_ is ambiguous--but the semantics are not)
<kakuhen>
except for transitivity, statements of the form "All X are Y" are an example of what you're saying I guess
<kakuhen>
but this is getting p off-topic now heh
lisp123 has quit [Ping timeout: 245 seconds]
<moon-child>
kakuhen: that is begging the question; 'are' is just another conjugation of 'is'. Translating my statement accordingly, we get 'all lives are fun', which is not illuminating. 'Is' in that case means 'has the attribute'
<moon-child>
but it surely can mean any number of other things
cosimone has joined #commonlisp
asarch has quit [Quit: Leaving]
cage has joined #commonlisp
<hayley>
I think the matters are different when we discuss objects and not properties. "1 + 1 is 2" would be another example where "is" probably is an equivalence relation.
peterhil has joined #commonlisp
<hayley>
Also, SIS Implements Smalltalk implies the existence of SIS 2 (SIS Implements Self), SIC (SIC Implements C), SIR (SIR Implements Racket), and SIS the prequel (SIS Implements SNOBOL)
<lotuseater>
or SIGH (SIGH implements Glasgow Haskell)
<moon-child>
hayley: well, sure, you can construct specific situations in which it (arguably?) denotes an equivalence relation. But english is not formally specified, so it is difficult to make such exclusive statements
<hayley>
moon-child: Sure. But "is" in a sentence "'X is X" compares two objects, and so to me we are considering if the objects are equal.
<hayley>
Actually, I think the situation I was referring to had someone say "'X is equivalent to X".
<moon-child>
'asarch | One stupid question: an empty block closure is just nil, right?'
cosimone has quit [Ping timeout: 252 seconds]
<moon-child>
you also have to qualify 'object'--though I guess that only matters if talking about the real world; in a programming language, it is easy
<lukego>
regarding greek letter capitalization, my current kludge is to hack the SBCL reader/printer to only do case conversion on STANDARD-CHAR. That'll hopefully be good enough to get enough experience to decide that the whole idea is misguided anyway.
<beach>
lukego: But when I suggested the use of Eclector (which allows stuff like that to be configured) you told me that this was not enough.
kuler has quit [Ping timeout: 276 seconds]
<pve>
lukego: How do you detect when case conversion is needed? Did you make every relevant character a macro character?
Lycurgus has joined #commonlisp
<pjb>
beach: it means that one may install clisp 2.49.92 easily on macOS using MacPort (sudo port install clisp).
amb007 has quit [Ping timeout: 240 seconds]
amb007 has joined #commonlisp
<beach>
pjb: What is MacPort?
* Lycurgus
assumes it's one of the two things you use to get unix pkgs on mac
<beach>
pjb: Never mind. I'll look it up
<Lycurgus>
brew being the other
<Lycurgus>
i use ports
<hayley>
Yes, a package manager for macOS.
<Lycurgus>
it's actually called MacPorts but tends to get called port because that's the command line name
<Lycurgus>
MacPorts would have been semantically suggestive in a way the singular isn't
<lukego>
beach: I'm totally figuring this out as I go along here and changing my mind on every step. no good solution found. but certainly from my perspective replacing the whole reader seems like a much bigger change than a ~ five line hack to sbcl
<lukego>
beach: also it's a meta-goal of mine to get into the habit of treating SBCL source code as read/write and getting to know it better, so it's a useful exercise to see how its printing/reading/unicode support works
rain3 has quit [Ping timeout: 256 seconds]
<pve>
lukego: Oh! I see. My (only) idea would have been to make every standard-char a macro character, and then read characters until a terminating macro character, and then intern with case conversion.
<pve>
(haven't tried it, so it may not work)
<lukego>
noted in case the feature is useful and I need to find a better formulation
<pjb>
lukego: IMO, it'd be better to keep CL function working as specified on the standard-character, and define a new API (eg. unicode:localised-string-upcase unicode:localised-sort etc) to work on extended-characters.
<pve>
lukego: I believee the "intern with case conversion" part would have to deal with escape characters though ("|...|", "\")
<lukego>
I'll be back for more ideas if the syntax turns out to be helpful in practice. Could also be that it just "causes cancer of the semicolon."
kakuhen has quit [Quit: Leaving...]
<lukego>
but it seems like when you start having code with variable names like MU, RHO, SIGMA, etc, then it's a plausible idea
<pjb>
lukego: have you tried pretty-greek?
<lukego>
pjb: no, decided to take this route instead
<pjb>
the landscape is nice.
<lukego>
Julia has nice support for this. They don't have the issue with case and in the editor/repl you can always tab-complete to turn TeX syntax like \lambda into a unicode character (and easily paste a unicode character to see which escape generates it when in doubt.)
molson_ has joined #commonlisp
<lukego>
relatedly, I'm wondering about a Lisp syntax for vectoriz/matrix/array arithmetic in the style of R/Julia/etc. anyone know one?
<lukego>
I used GENERIC-CL to add methods so that e.g. (+ #(0 1 2) #(1 1 1)) => #(1 2 3) but there are various downsides and I wonder if separate operators make better sense.
<lukego>
GENERIC-CL is pretty heavyweight though, basically an opinionated new interface to COMMON-LISP.
attila_lendvai has joined #commonlisp
molson has quit [Ping timeout: 256 seconds]
<pve>
I wonder if there's a way to "switch" readers to eclector while loading/compiling a file? A bit like (eval-when (:compile-toplevel :load-toplevel :execute) (setf *read-table* *my-readtable*)).
Jach has quit [Remote host closed the connection]
Jach has joined #commonlisp
markasoftware_ has joined #commonlisp
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
markasoftware has quit [Ping timeout: 276 seconds]
<pjb>
lukego: it can be made more lightweight with the help of compiler-macros, but it would be nice if the compiler would give the compiler macro its type inference or declarations results.
<pjb>
(define-compiler-macro my:+ (&whole form &rest args) (&rest types) (if (every (lambda (type) (subtypep type 'number)) types) `(cl:+ ,@args) form))
makomo has joined #commonlisp
<pjb>
So that in (lambda (x) (let ((y 42)) (and (integerp x) (my:+ x y)))) it would expand to (cl:+ x y).
<pjb>
or in (lambda (x) (declare (real x)) (let ((y 42)) (my:+ x y)))
<pjb>
currently, compiler macros would only know that the arguments are x and y, and wouldn't know anything about them.
<pjb>
Well, it could be realized by giving an implementation dependent API on the &environment parameter to query the type of the parameters.
<lukego>
Nifty. Maybe tricky to predict behavior as a user though? I'm wondering if e.g. (v+ x y) for vector addition makes sense. have to write code and see. Certainly as an occasional R/Julia hacker I often get confused about what is vector, what is scalar, what can be either
<pjb>
That would be more compatible.
montxero has quit [Read error: No route to host]
<lukego>
Julia seems to have quite a lot of DWIM in their "broadcasting" feature where you make editorial decisions about dispatch when extending + etc with methods for new types.
<pjb>
it depends if you think like a programmer or like a mathematician.
<pjb>
Mathematicians like overloading of operators…
montxero has joined #commonlisp
<lukego>
I liked the Connection Machine Lisp syntax for parallelizing and reducing subexpressions, fwiw.
<pve>
Here's what I got so far regarding "enabling" eclector. Am I on the right track? :)
<hayley>
lukego: Petalisp used to use α and β for maps and reduces, if that's what you mean.
<pve>
it's still missing the client stuff
cosimone has joined #commonlisp
<Lycurgus>
apparently it did use alpha; lukego did you have hands on a Connection Machine?
<lukego>
Lycurgus: no, and apparently CMLisp never got productionized anyway, but it was my favourite CS paper for many years anyway, worked hard to grokking the examples.
<lukego>
They had a syntax over a Lisp expression that would map-reduce parallelize it, it was really neat.
<lukego>
yeah. as they say in the paper, like backquote but not for saying what is quoted but rather what is "vectorized"
<lukego>
So if A is an array an N is a number then in R you might simply say "R * N" but maybe in CMLisp style one would write α(+ ̇·A N) to parallelize the expression (α) and splice (·) individual elements in places. (Or maybe I have it backwards.)
<lukego>
I think they also had β to reduce a vector into a scalar, but I need to reread the paper.
random-nick has joined #commonlisp
Lycurgus has quit [Quit: Exeunt]
akoana has quit [Quit: leaving]
cosimone has quit [Ping timeout: 250 seconds]
rain3 has joined #commonlisp
tyson2 has joined #commonlisp
Mandus has quit [Ping timeout: 252 seconds]
Mandus has joined #commonlisp
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 245 seconds]
Mandus has quit [Ping timeout: 252 seconds]
amb007 has quit [Read error: Connection reset by peer]
Mandus has joined #commonlisp
amb007 has joined #commonlisp
Lord_of_Life has joined #commonlisp
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
pranavats has left #commonlisp [#commonlisp]
Guest12 has joined #commonlisp
lisp123 has joined #commonlisp
amb007 has quit [Ping timeout: 240 seconds]
yitzi has joined #commonlisp
amb007 has joined #commonlisp
utis has quit [Quit: leaving]
Oladon has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
hendursa1 has quit [Quit: hendursa1]
aleamb has joined #commonlisp
hendursaga has joined #commonlisp
pranavats has joined #commonlisp
waleee has joined #commonlisp
azimut_ has quit [Ping timeout: 276 seconds]
dra has joined #commonlisp
brettgilio has joined #commonlisp
<lukego>
okay, pushing my luck, now compiling αα(+ ••a •b c)) as the "array comprehension" Vᵢⱼ = Aᵢⱼ + Bᵢ + C. I wonder if this is a reasonable basis for an alternative to R/Julia style vectorized operators? https://imgur.com/a/hdjEK7w
<hayley>
I'd just write (petalisp:α #'+ a b c) which is more APL-esque.
<lukego>
okay, I need to have a look at petalisp...
<hayley>
Though the name is now petalisp:lazy-map, but the point is that the mapping function happily implicily broadcasts.
<lukego>
AGPL. Oops.
<hayley>
I think my operational description would suffice then.
<hayley>
But the nice thing about implicit broadcasting is that you can write code which works on a vector, and then it will still work in parallel on a 2-dimensional array just fine (as well as more dimensions).
<lukego>
Yeah, my idea here was to explicitly avoid that, because I find it confusing in R. but maybe I'm being a wimp.
<lukego>
Julia code at least, at my current level of sophistication, is hard to read when I'm not sure what the actual and intended behavior of passing broadcastable parameters is (and not confident that those are the same thing)
<hayley>
To each their own, there's nothing wimpish about it.
<lukego>
but Julia supports automatic broadcasting on a whole range of types, via adding methods to the broadcasting machinery, and it has a DWIM flavor where there are multiple possible interpretations and the library author picks the one that makes sense to them
<beach>
What should happen when the following form is evaluated: (coerce 1d3 '(complex single-float)) provided single-float and double-float are distinct types?
random-nick has quit [Quit: quit]
<hayley>
I would intuitively expect it to evaluate to #c(1.0s0 0.0s0), but the HyperSpec description of COERCE seems to leave the element type "unused", and keeps the type of the object being coerced.
<beach>
So then I think the first exceptional situation applies.
<beach>
The coercion is not possible because the definition of "coercion" is that the resulting object is of the type requested.
<hayley>
But the "Arguments and Values" section specifies that the return value is of the provided type specifier (unless a rational is to be coerced to a complex number) - right.
<beach>
Exactly.
<beach>
So it would not be conforming behavior to return an object that is not of the type givcen.
<beach>
given.
<hayley>
Right.
<beach>
Thanks for confirming.
Oladon has quit [Quit: Leaving.]
random-nick has joined #commonlisp
srhm has joined #commonlisp
<hayley>
In my worthless opinion, if a complex element type was provided, the object provided should be coerced to that type first. But I guess you are asking because you are implementing COERCE, and such a change would be out of scope for WSCL.
<beach>
I think your opinion is contrary to my reading of the standard, and I agree that such a change is out of scope for WSCL.
<beach>
However, WSCL could make this situation more explicit.
<hayley>
...so notions of "intuitive behaviour" aren't relevant now, and we're just reading the specification. Which is fine.
<lukego>
Petalisp looks pretty awesome, thanks for bringing it to my attention. I think that my hack is meant a bit more as a convenience for day-to-day programming in comparison
<hayley>
Right, yes, it is just what I would expect COERCE to do prior to reading the specification, and I think we have come to the same reading of the standard.
<beach>
Great!
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 245 seconds]
lisp123 has joined #commonlisp
<lisp123>
beach: Got it, thanks.
<beach>
Good! In fact, in SICL, the only slots of a symbol are the name and the package.
<lisp123>
In that case, where does the value attribute, function attribute and property list go?
<lukego>
Hey, I went to all that trouble using a unicode bracket as my LET sugar, and now the thought occurs that [ and ] are actually avaliable for reader macros? :)
<hayley>
Those associations are stored in an environment object.
<beach>
lisp123: In the environment.
<lisp123>
I see, thanks.
<hayley>
lukego: Yes. Oh, so are #t and #f, so you can use your favourite representation of Scheme booleans :)
<beach>
lisp123: The value isn't practical to store there anyway, if the system has threads.
<beach>
lisp123: And by storing things in the environment, a symbol can have different functions and values bound to it in different environments.
<lukego>
anyway it's been a nice exercise in mutating my lisp environment. if I stick at it then maybe my 100th idea will end up being a good one :)
<lisp123>
beach & hayley: On an unrelated but perhaps related note, have you read 'Macroexpand-All - Code Walker' by Richard Waters?
<beach>
Not me, but I know how to write such a thing.
<lisp123>
One of the issues there is extracting information and adding information to Environments in a portable way, is this something SICL will help with?
<hayley>
Nor me, but if I can find the right part of CST-to-AST quickly enough, I can pretend I know how to write such a thing.
<beach>
Yes, Trucler was written for that purpose.
<lisp123>
Great, hopefully that gets adopted across the board.
<beach>
lisp123: Trucler is like a modern CLOS-based version of the environment protocol from CLtL2.
<beach>
lisp123: Don't count on it.
<lisp123>
I see all these code walkers online, but none seem to be perfect
<lisp123>
As in 100% error free
<beach>
A code walker is highly dependent on the host Common Lisp system.
<hayley>
It is tricky to write a code walker when implementations introduce their own special forms, yes.
<beach>
Trucler just proposes a bunch of classes and generic functions that the client Common Lisp system must then configure.
<beach>
Well, "just" is not fair. It does a good job of maintaining the lexical environment of course.
<lisp123>
Nice
<beach>
In fact, I think Trucler comes with configurations for SBCL.
<beach>
And also for a "reference implementation" which is what SICL uses (of course).
<lisp123>
Can an end user plug and play these modules if the maintainer of the implementation hasn't yet?
<beach>
Sure, nothing special is required, but the end user may need to know how the system represents its environments, and in particular the global environment.
<lisp123>
That sounds good, I look forward to doing so in the future
<beach>
Like, in most Common Lisp systems there is not one object representing the global environment. It is "spread out", as in functions are often in symbol slots, and method combinations may be in a hash table referenced from a special variable.
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<lisp123>
That makes sense
<beach>
Oh? Not to me. I think it makes a lot more sense to collect everything that has to do with the global environment in a first-class object.
<lisp123>
As in it makes sense that one needs to understand how the system represents its environment, if its spread across multiple facets of the implementation
<lisp123>
(i.e. more complex than a simple substitution)
<lisp123>
random-nick: Thanks for the link. I plan to write my own so that I also learn more about how Lisp works, and since there is always some edge case that isn't covered, I prefer to have a full understanding, if I am going to use it
<lisp123>
But it seems pretty good from a quick read - if I ever had to something serious, I would look to using it
cosimone has joined #commonlisp
<jcowan>
beach, hayley: I agree with your interpretation of the COERCE spec. I think the reason we didn't get an intuitive result is that nobody thought about changing COERCE when the idea of upgraded complex types was introduced into the standard.
<jcowan>
Notice the mention of upgrading under the "SEQUENCE" section of COERCE.
<borodust>
etimmons: are there any recommended github actions to use clpm from?
<beach>
jcowan: That's a very plausible explanation.
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
<borodust>
yitzi: thanks for adding clpm to aur!
<yitzi>
You are welcome!
Oladon has joined #commonlisp
<etimmons>
borodust: Not yet. The vast majority of my time is spent in one Gitlab install or another, so I haven't invested in github actions yet.
<etimmons>
yitzi: Thank you from me as well!
<yitzi>
etimmons: my pleasure. Let me know if you need comaintainer access at any point to the AUR repo.
<borodust>
hmm, sbcl complains the core clpm uses is incompatible, dayum
<etimmons>
yitzi: Ha. I'd have to learn AUR first, otherwise I'd be more dangerous than helpful.
<etimmons>
Also, I finally got M1 support (largely thanks to Stas for quickly fixing the SBCL bug I found). So I'm literally in the process of cutting 0.4.0-rc.1.
tyson2 has joined #commonlisp
<etimmons>
(and for fixing the bug during a freeze, no less!)
<yitzi>
borodust: Updated the AUR pkg to remove symbol strip
<borodust>
yitzi: that was really fast xD i just downloaded PKBUILD and !strip is already there
<borodust>
thanks
<borodust>
yitzi: yup, it works now
<borodust>
it's better to bump pkbuild version though in such cases cuz some aur manager (such as yay) keep build files for some time
<borodust>
and they won't refresh them if version is the same
<borodust>
meaning they would use outdated package sources
amb007 has quit [Ping timeout: 252 seconds]
amb007 has joined #commonlisp
<yitzi>
borodust: great! I'll bump the pkg version in just a bit.
attila_lendvai has quit [Ping timeout: 245 seconds]
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
lisp123 has joined #commonlisp
charles_ is now known as char
lisp123 has quit [Ping timeout: 252 seconds]
<borodust>
etimmons: clpm does not search recursively for systems in git/github/gitlab, does it?
<borodust>
like i have a collection of systems as submodules in a single mother repo
<borodust>
what i wanted to try is to add clpmfile that looks for systems in the repo above and quicklisp, then init that bundle on CI machine, then build a CL application out of that
<etimmons>
It does, but it doesn't clone submodules.
<borodust>
i see
<etimmons>
That could probably be added as an option, but I need to do some experimentation to figure out how to deal with submodules in bare repos (if that's even possible) and if `git archive` also dumps the contents of the submodules
<etimmons>
side note: my work on libgit2 bindings (which I just realized I still need to share) is so that I can bundle libgit2 with CLPM and not worry about having a git executable handy
rain3 has quit [Remote host closed the connection]
tyson2 has joined #commonlisp
<borodust>
etimmons: thanks! that would be much helpful
<borodust>
etimmons: also, git lfs is a fairly popular thing too
<borodust>
for now i'll go with more classic approach: quicklisp dist ;p
<etimmons>
Oh, good point about LFS.
tyson2 has quit [Remote host closed the connection]
Oladon has quit [Quit: Leaving.]
tyson2 has joined #commonlisp
khrbt has quit [Ping timeout: 256 seconds]
khrbt has joined #commonlisp
Josh_2 has joined #commonlisp
tyson2 has quit [Quit: ERC (IRC client for Emacs 27.2)]
<Josh_2>
sbcl comes with asdf doesn't it?
<Josh_2>
Just installed 2.1.8 from the site on a fresh vps and I'm getting an error saying that asdf doesn't exist
<borodust>
Josh_2: try (require 'asdf)
<Josh_2>
Well that worked
<Josh_2>
Guess its because I'm trying to execute a binary I built on a different machine
<borodust>
Josh_2: more likely that your other machine has .sbclrc that setups initial environment
<borodust>
and this clean one doesn't, meaning sbcl starts w/o any initialization
<Guest12>
So I have this quicklisp project in my local-projects directory, having made some significant changes to existing lisp files, I notice that a ql:quickload of the project from fresh lisps is (sbcl or clisp) is loading old cached out of date fasls. Is there some asdf or quicklisp incantation I'm supposed to use? I expected the more recent lisp
<Guest12>
source files woule automatically cause the fasls to be regenerated.
<Josh_2>
borodust: the only thing in my .sbclrc is what is added by quicklisp, this is true on both machines
<borodust>
Josh_2: quicklisp most likely initializes asdf via require
<borodust>
cuz it needs it to properly function
<borodust>
#'ensure-asdf-loaded in ~/quicklisp/setup.lisp
<lukego>
oh shoot now I found APRIL, an APL embedded in Common Lisp, and remembered I have a copy of the APL book somewhere...
amb007 has quit [Ping timeout: 256 seconds]
amb007 has joined #commonlisp
<Josh_2>
both my user and root have the quicklisp load functionality in .sbclrc
<Shinmera>
Good evening everyone. Just published a new update on our Lisp-powered game, and perhaps more importantly, a new public demo release along with it: https://reader.tymoon.eu/article/400
<lotuseater>
Cool that you come along with that so well. :)
<Shinmera>
I could do with another programmer, honestly!
<Shinmera>
Unfortunately the budget can't afford one :(
<borodust>
Shinmera: congratz!
<lotuseater>
Oh too bad.
<Shinmera>
borodust: thanks!
<Shinmera>
Had two critical bug discoveries yesterday afternoon. Made for a very stressful saturday evening, hah
<Josh_2>
borodust: well I got that single program to work by just building it on my vps
<lotuseater>
phew but hunting bugs is good
djuber has quit [Ping timeout: 240 seconds]
<etimmons>
Shinmera: Congrats! Finally added it to my Steam wishlist as well.
<Shinmera>
etimmons: much appreciated!
Cymew has joined #commonlisp
<aeth>
careful
<aeth>
lotuseater: every time I think I find a use for #. it turns out not to be too useful
<aeth>
usually a clearer alternative way
<lotuseater>
aeth ^^ with great power ...
<aeth>
e.g. #. is necessary in types, or you could just use DEFTYPE. Similarly, you can DEFMACRO a lot of things that would otherwise require #.
<aeth>
the important common factor here is that it gives a name to what you're doing, instead of leaving it up to the reader
<etimmons>
borodust: Also, I looked into it briefly. The submodule stuff is not going to be trivial. I think I'll aim to just code it once using my libgit2 bindings instead of twice (the other place being to hack it together using the git executable directly).
<borodust>
etimmons: no hurry, i'll use plain ql dist for now to arrange all required dependencies and then use it as a source in my clpmfile
<borodust>
etimmons: thanks for you work on clpm
<etimmons>
Great!
<etimmons>
yw! It always makes me happy to learn about more people that are using or interested in using it!
<borodust>
cuz i also use git lfs and i expect that would be a pain to add to clpm
<borodust>
or maybe not, didn't look into that)
<etimmons>
I'm honestly not sure, but I suspect the submodules will be a bigger change
<etimmons>
That's because right now it uses `git archive` to basically extract a specific commit from a repo. And `git archive` does not recurse into submodules at all.
<etimmons>
For LFS, I feel the worst case is clpm needs to check out a working tree and grab stuff from LFS before creating the archive
<lotuseater>
and if you try using darcs or pijul for it?
<etimmons>
git is the only supported VCS at the moment.
<etimmons>
I think mercurial will be next, and then darcs
<lotuseater>
okay I didn't come into touch with older vcs other than git, just darcs cause of Haskell studies
cosimone has quit [Ping timeout: 252 seconds]
<borodust>
svn is still popular in gamedev ;p
<lotuseater>
:)
<etimmons>
Really? I thought svn went the way of the dinosaurs by now...
<borodust>
yes, unfortunately, git only recently getting more or less acceptable support for handling binary files with git lfs
<etimmons>
That's a good point. I always forget how (relatively) new lfs is
<borodust>
and gamedev is full of binaries and also favors centralized workflows
<aeth>
I'm just barely old enough to have used cvs, svn, and hg before git took over the world. No darcs, though. But, yes, for binary files, git isn't very good, so some niches still use them. For the most part, though, people who work with binary files still don't understand the value of version control at all, though
<borodust>
aeth: well, not quite true
<lotuseater>
there was also some other thing to manage big files with git but not really check them in so the commits won't get unneccessary big ..
<borodust>
artists, animators, modellers, game designers are all quite understand why this is important to have :)
<borodust>
i mean, in our studio at least
lisp123 has joined #commonlisp
<aeth>
I don't work for a studio, but my impression from posts online is that the programmers have to convince everyone else about the value of using version control.
<lotuseater>
borodust: all the high detail models seem to be the reason such new games like Cyberpunk 2077 are so big ^^
<lotuseater>
ah right, it was git-annex
lisp123_ has joined #commonlisp
<Josh_2>
Does cffi follow symlinks?
khrbt has quit [Ping timeout: 252 seconds]
<borodust>
Josh_2: linker does
<borodust>
meaning you can use a link with #'cffi:load-foreign-library
khrbt has joined #commonlisp
<Josh_2>
Well once again I am having troubles with my new VPS. I start my binary and immediately get the error 'error opening shared object "libolm.so.3"'
<borodust>
lotuseater: pretty much
<Josh_2>
libolm.so.3 is in /usr/local/lib but its a symlink to libolm.so.3.2.4
<borodust>
content is everything games are today
<Josh_2>
on my on my old vps its not a symlink
<lotuseater>
but I don't know why patches are sometimes about 30GB big
lisp123 has quit [Ping timeout: 250 seconds]
khrbt_ has joined #commonlisp
<Josh_2>
man this is annoying... and I cant skirt around this one by building it on my vps
khrbt has quit [Ping timeout: 252 seconds]
jans has quit [Remote host closed the connection]
<etimmons>
Josh_2: Have you tried running `ldconfig` ?
cosimone has joined #commonlisp
khrbt_ has quit [Ping timeout: 252 seconds]
lisp123 has joined #commonlisp
lisp123_ has quit [Ping timeout: 245 seconds]
<Josh_2>
Huh I think that worked
<Josh_2>
thanks etimmons
<Josh_2>
now I have to fix the "Couldn't load #P"/usr/share/common-lisp/source/cl-asdf/asdf.asd"
<etimmons>
Yep! The fact that it was in `/usr/local/` is what made me suspect that.
<etimmons>
Seems like the library got placed in the folder without updating the linker cache.
<borodust>
wows, latest sbcl is built against glibc 2.28 and ubuntu lts uses 2.27 T_T
robin has quit [Read error: Connection reset by peer]
<Josh_2>
I've had this stupid problem before and I cannot remember how I fixed it
<Josh_2>
:angry:
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Spawns_Carpeting has joined #commonlisp
VincentVega has quit [Read error: Connection reset by peer]
<Josh_2>
Slynk has to be added as a dependency in my project if I want to have slynk:create-server in my startup function, but when it is added its causing my lisp image to look for a .fasl that was compiled on my machine.. not the machine that its being deployed on
montxero has quit [Read error: No route to host]
SAL9000 has quit [Quit: WeeChat 3.1]
SAL9000 has joined #commonlisp
montxero has joined #commonlisp
shka has quit [Ping timeout: 252 seconds]
<Josh_2>
now I dont know why I can run ql:quickload :slynk on my old vps within my dumped image, but I can't on my new one :'(
Lord_of_Life_ has joined #commonlisp
yitzi has quit [Quit: Leaving]
<Josh_2>
just checked the irc logs looking for where I was complaining about this last time, ofcourse I wrote "I got it to work!" and never said how...
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
cosimone has quit [Ping timeout: 252 seconds]
<Josh_2>
noice
<Josh_2>
I got it to work, just to spite my future self I should not explain how
Cymew has quit [Ping timeout: 252 seconds]
<Josh_2>
oh wait
<lisp123>
Josh_2: I know the feeling, better write it down now! (as much as you feel you will remember for next time...surely it can't happen again...been there, done that :P)
Bike has quit [Quit: Connection closed]
avodonosov has joined #commonlisp
pve has quit [Quit: leaving]
<Josh_2>
Well my future self obviously sensed me about to spite myself, turns out I had not fixed it I was looking at the wrong vps...
gaqwas has quit [Read error: Connection reset by peer]
gaqwas has joined #commonlisp
<Josh_2>
okay I actually did fix it, what a PITA
<Josh_2>
for my future self, to fix it you have to create a user on the VPS with the same name as whatever name you use to create the image, then you have to copy your ~/quicklisp into that users home directory.
<Josh_2>
sly has to be within local-projects.
<Josh_2>
you also have to copy the content of .cache/common-lisp from that user to the user you want.. you know it would probably be best to just use the same username on your home and remote machine
makomo has quit [Ping timeout: 240 seconds]
gaqwas has quit [Read error: Connection reset by peer]
gaqwas has joined #commonlisp
gaqwas has quit [Remote host closed the connection]
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
frgo has quit [Remote host closed the connection]
frgo has joined #commonlisp
lisp123 has quit [Ping timeout: 252 seconds]
ahlk has quit [Read error: Connection reset by peer]
ahlk has joined #commonlisp
kakuhen has joined #commonlisp
Skyfire has quit [Quit: WeeChat 3.2]
Guest12 has quit [Ping timeout: 256 seconds]
montxero has quit [Read error: Connection reset by peer]
lisp123 has joined #commonlisp
montxero has joined #commonlisp
lisp123 has quit [Ping timeout: 256 seconds]
pillton has joined #commonlisp
cjb has joined #commonlisp
dra_ has joined #commonlisp
dra has quit [Ping timeout: 256 seconds]
dra_ has quit [Quit: Leaving]
dra has joined #commonlisp
montxero has quit [Read error: Connection reset by peer]