Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<Josh_2>
what am I missing with all this packaging stuff that means I can't call the functions from my the packages I :use?
<aeth>
Josh_2: case-sensitivity is what you're missing
<Josh_2>
aaaaaaaaaah cmon
Kundry_Wag has quit [Ping timeout: 250 seconds]
<aeth>
Josh_2: you don't export 'write-pin you export '|write-pin| because you're using the symbol named "write-pin" not "WRITE-PIN". Things are upcased by default, not case-insensitive by default.
mathrick has joined #lisp
<aeth>
Just export #:write-pin
<Josh_2>
hnng
<Josh_2>
clhs uses "symbol" for some reason ¯\_(ツ)_/¯
PuercoPope has joined #lisp
<Josh_2>
that's why I used ""
<aeth>
You can export "WRITE-PIN" and some people use it as a micro-optimization. This might be important if you're running it on a computer from the 1980s.
manjaroi3 has joined #lisp
bitmapper has quit [Ping timeout: 240 seconds]
<Josh_2>
welllll
<Josh_2>
I'm using a rasp pi zero w so basically xD
asarch has quit [Quit: Leaving]
<aeth>
That's probably more powerful than a Pentium 3
<Josh_2>
700hz of pure power
nitrix has quit [Quit: Quit]
nitrix has joined #lisp
mathrick has quit [Ping timeout: 268 seconds]
stepnem_ has quit [Ping timeout: 250 seconds]
mathrick has joined #lisp
shifty has joined #lisp
<no-defun-allowed>
*700MHz
<Josh_2>
yes my mistake
<mister_m>
When defining a macro, and using a let statement with a (gensym) invocation, is there a way I can provide a value to the let-binding in addition to having the macro expander generate a symbol for me? Or do I need to invoke (gensym) in one let binding, and then assign to the gen'd symbol in other using let*?
<Xach>
mister_m: i don't fully follow the question, but macros are just functions return source code, so you can use anything you like to form that returned code
<Xach>
gensym is not required, it's to avoid a specific tricky situation
clothespin__ has joined #lisp
<mister_m>
Xach right, but in a let binding i can provide a value (let ((thing "test")) ...) - can i provide a value if I also have to (gensym) the ``thing`` binding?
clothespin_ has quit [Ping timeout: 246 seconds]
pjb has joined #lisp
wiselord has quit [Ping timeout: 245 seconds]
<Xach>
mister_m: yes. it's a symbol, just like THING is a symbol
<Xach>
references to that symbol in other parts of the code only care about its identity, not its name or package
<Xach>
(of course, symbols with the same name in the same package are identical)
<Xach>
but symbols with the same name in no package need not be
madage has quit [Read error: Connection reset by peer]
zooey has quit [Remote host closed the connection]
oxford has quit [Read error: Connection reset by peer]
gxt has quit [Read error: Connection reset by peer]
zooey has joined #lisp
oxford has joined #lisp
gxt has joined #lisp
madage has joined #lisp
isBEKaml has joined #lisp
Kundry_Wag has joined #lisp
* akoana
this is a proof of reincarnation with a new identity :)
hvxgr has joined #lisp
ebzzry has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
ebzzry_ has joined #lisp
manjaroi3 has quit [Quit: leaving]
ebzzry has quit [Ping timeout: 265 seconds]
ebzzry_ has quit [Read error: Connection reset by peer]
ebzzry_ has joined #lisp
drainful has quit [Ping timeout: 240 seconds]
gabiruh_ has quit [Read error: Connection reset by peer]
gabiruh has joined #lisp
orivej has joined #lisp
t3rtius has joined #lisp
drainful has joined #lisp
isBEKaml has quit [Quit: leaving]
LeifErikson has joined #lisp
gravicappa has joined #lisp
t3rtius has quit [Quit: leaving]
marusich has joined #lisp
<beach>
Good morning everyone!
ebzzry_ has quit [Read error: Connection reset by peer]
ebzzry_ has joined #lisp
t3rtius has joined #lisp
t3rtius has quit [Client Quit]
t3rtius has joined #lisp
t3rtius has quit [Remote host closed the connection]
t3rtius has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
t3rtius has quit [Quit: ERC has quit.]
t3rtius has joined #lisp
<mfiano>
Is POSITION the idiomatic thing to use when checking for the presence of an element in a vector, when the vector can have nil elements and the element to be checked can also be nil?
<beach>
Sounds good to me.
<beach>
... as long as you don't do (if (position ...) ...)
<mfiano>
Ok. I'll just add a comment because I can see that confusing me at a later date (not using the integral return; this is simple for an ASSERT).
<beach>
Sounds good to me.
<mfiano>
simply, rather.
<beach>
... as long as you don't do (assert (position ....)).
<aeth>
beach: what's the issue with doing if (position ...)?
<beach>
... because of page 13 of the LUV slides by Norvig and Pitman.
<beach>
The reader expects a Boolean value for IF and ASSERT, but POSITION does not return a Boolean value.
<beach>
It returns a position OR a default value.
<mfiano>
Can you elaborate on the "don't do (assert (position ...)), or is that the PN/KP thing too?
<mfiano>
Aha
<beach>
ASSERT takes a Boolean expression, and POSITION does not return a Boolean expression.
<aeth>
beach: so would the correct behavior be to define a function that does (if (position ...) t nil) then?
<beach>
No.
<beach>
(if (null (position ...)) ... ...)
<mfiano>
Is there a distinction in the spec that specifies that it cannot be a generalized boolean? Maybe I should just read this paper. Have a link, beach?
<beach>
NULL tests whether the value returned by POSITION is the default (i.e. NIL).
<beach>
And (NULL ...) is a Boolean expression.
<beach>
mfiano: It has nothing to do with semantics. It has to do with the message that you send to the person reading your code.
<beach>
If we were only interested in semantics, there would be no problem with obfuscated code.
<beach>
mfiano: LUV slides by Norvig and Pitman, page 13.
<beach>
If you type that to Google, you get a few PDF links.
<mfiano>
I'm not familiar with this acronym
<mfiano>
Aha, ok. I was reading the title. That is the venue if I actually click through to one of them :)
<beach>
Lisp Users and Vendors Conference August 10, 1993.
<mfiano>
Yeah I read this multiple times. Perhaps time for another.
vlatkoB has joined #lisp
<mfiano>
beach: So would you do (unless (null (position nil sequence)) t), (not (null (position nil sequence))), or other for ASSERT?
LeifErikson has quit [Quit: rcirc on GNU Emacs 26.3]
karlosz has joined #lisp
<beach>
I would do the (assert (not (null (position...))))
<beach>
Or more likely, I would signal an error, as in (when (null (position ...)) (error...))
LeifErikson has joined #lisp
ggole has joined #lisp
kotrcka has joined #lisp
akoana has quit [Quit: leaving]
_whitelogger has joined #lisp
ebzzry_ has quit [Read error: Connection reset by peer]
kotrcka has quit [Remote host closed the connection]
_whitelogger has joined #lisp
libertyprime has joined #lisp
Oladon has joined #lisp
libertyprime has quit [Ping timeout: 240 seconds]
libertyprime has joined #lisp
smokeink has quit [Remote host closed the connection]
shka_ has joined #lisp
Volt_ has quit [Quit: exit();]
smokeink has joined #lisp
libertyprime has quit [Ping timeout: 240 seconds]
<pjb>
beach: you are wrong: IF and ASSERT DO NOT EXPECT a BOOLEAN! They expect a generalized boolean. POSITION returns a generalized boolean. It's perfectly compatible with IF or ASSERT.
<pjb>
Of course, you are entitled to write your programs in a subset of CL, and nobody will reproach it to you. But people can use the full CL language.
<aeth>
it's funny that the three of us have different opinions here because I'd still say write a trivial function (inline it if performance is a concern, since its so trivial its implementation will never change) that is self-documenting in its name
<aeth>
then there's no need to add a comment
karlosz has quit [Remote host closed the connection]
LeifErikson has quit [Remote host closed the connection]
jonatack has quit [Read error: Connection reset by peer]
<beach>
pjb: You must have read only part of the exchange. I explicitly said that it has nothing to do with semantics, and everything to do with communication with the person reading the code.
<pjb>
Still my point. (if (not (null (position …))) …) is a heavier cognitive load, to somebody who knows CL. When I see it, I start to wonder what's happening so special, why don't we just test (if (position …) …). And it's not even a double negation such as (not (not …)). You have to think hard to realize that it meant nothing.
<pjb>
beach: I realize that one can expect from smart and even not so smart compilers to optimize (not (null …)) out.
<beach>
I find it amusing that my arguments about conventions are nearly always met with individual opinions. Let me give a parallel concerning English prose.
<beach>
*I* might think it is fine to write text that has dangling participles, because after all *I* wrote it so *I* know what I meant. But that's not the point.
<beach>
The point is that even though *I* don't mind writing and reading such prose, I still don't write like that when it is meant for other people to read.
<beach>
When I write for other people to read, I can't ask each individual reader what they want, because I probably don't even know them. So I have to follow CONVENTIONS, whether I like those conventions or not.
<beach>
This aspect seems to be lost on many people here, very likely because they have little or no experience with working in teams, or with writing code that might some day be maintained by others.
<pjb>
beach: you are assuming what other people expect. I'm telling you that for me, it's harder to read (if (not (null (position …))) …) than (if (position …) …).
<beach>
Notice the "for me".
<pjb>
Yep.
<pjb>
And I can assume that for some others it might be the same.
<beach>
I am not assuming what other people expect. I am posing that we should all adopt the same conventions, thereby getting used to what others expect. Of course, the way the community is made up right not, this is impossible.
<pjb>
The convention I would propose is to use the semantics specified in the language.
<beach>
Wow.
<beach>
Amazing.
<beach>
So anything semantically correct is conventional.
<beach>
That would be... let's say "interesting".
<pjb>
When you call a function, you have to know what type of argument it expects, and what type of results it returns. If you write in a subset of the language that don't assume all the possible values, you are both limiting yourself and risking serious problems.
<pjb>
We see the problems all the time in C, because a lot of people don't know C, but assume some higher level language with C syntax…
<MichaelRaskin>
If you use English as analogy, let's consider the amazing convention of never splitting an infinitive and how it used to phrases that look tortured (and are still no easier to read)
<fengshaun>
is it possible to have the local copy of hyperspec be searchable (short of grep'ing the directory)?
<pjb>
fengshaun: yes.
<pjb>
fengshaun: there's a version of it in info format (it was distributed once with gcl IIRC).
<beach>
MichaelRaskin: That is not a convention. It is a stupid idea proposed by besservissers who have no training. Check Pinker for a more informed opinion.
<fengshaun>
pjb, hmm I just downloaded hyperspec-7 from lispworks
<pjb>
or that.
<fengshaun>
it's just a bunch of html files
<beach>
MichaelRaskin: I am quoting Norvig and Pitman for a reason. I consider them the analogue of Pinker.
<MichaelRaskin>
beach: it _is_ literally a convention. A Convention produced by people who didn't understand what they are doing, but now (unfortunately) widespread enough to become a convention in many places.
<beach>
Whatever.
<MichaelRaskin>
I know that a lot of conventions proposed make code harder to read for me whenever they are literally followed
<MichaelRaskin>
I know I am not alone
ArthurStrong has joined #lisp
<beach>
MichaelRaskin: They only make it harder to read for people who stubbornly refuse to follow conventions established by smart, experienced, and knowledgeable people like Norvig and Pitman.
<aeth>
e.g. my line length limit is 100 lines, but I go over that in a few places, because sometimes it makes things less readable to put a fake break in
ArthurStrong has left #lisp [#lisp]
<pjb>
And Pitman, who AFAIK hasn't written a line of lisp code for more than 20 years.
jonatack has joined #lisp
<beach>
I think I totally fail to get this idea across, and I shouldn't be surprised. I will stop trying now.
<shka_>
hmmm, this started with lisp at some point?
<MichaelRaskin>
beach: when people who actually follow the specific authority are not easier to find than people who think this authority is harmful...
<fengshaun>
pjb, thanks! that works too
<pjb>
beach: and there is old code that you still have to be able to read. This is why I think my approach is better: stick to the CLHS.
<beach>
pjb: Yeah, and the other day we saw someone saying that "Norvig is a traitor", so we shouldn't listen to him either. Sheesh!
<pjb>
:-)
<aeth>
Speaking of Python, I think Python's a bit too dogmatic on the side of having one true style that must never be violated. CL generally seems to be a nice middle ground, keeping important conventions like parentheses, comments, and indentation (unlike C and C++, where indentation and bracket management is a bit of a nightmare)
<MichaelRaskin>
The idea that following a convention that doesn't fit one's way of thinking about things (and of writing in other languages) will make this convention feel natural is pretty optimisitic
<shka_>
MichaelRaskin: mind is a flexible thing, it can adapt
<aeth>
Oh, and sticking to kebab-case is another important thing CL does.
<aeth>
In some languages, I have to use CamelCase libraries in my underscore_case project and, well, it's a bit ugly
<MichaelRaskin>
shka_: note that I never identified as CL-only programmer
<shka_>
aeth: kebab-case does not require use of shift key, therefore it is superior ;-)
<MichaelRaskin>
Which means that my mind will adapt to the entirety of what I do, not just to a specific style of Lisp
<MichaelRaskin>
(and of course if writing style conflicts with the mindset used for planning out the algorithms, either the latter wins out, or I become worse at making code correct)
<pjb>
Also, the question of style in Lisp cannot be resolved globally, because you can use different programming styles (and worse, mix them!) when you use embedded DSLs, or merely a new macro. Each program, each function can have its own style!
dale has quit [Quit: My computer has gone to sleep]
<beach>
Right, let's abandon the very idea of conventions.
<beach>
pjb: Not meant particularly for you.
<pjb>
Global conventions. I don't mind local or program-specific conventions.
<pjb>
And even personnal style.
<aeth>
Imo... Programming is like art, as a special case of writing. You need conventions. You need to know the conventions. You need to mostly follow the conventions. But once you're good enough, you can break conventions in certain places.
<aeth>
Dogmatic linters to enforce 100% usage of conventions are too easy for programmers to write, but they're not necessarily the right thing to do.
<shka_>
this discussion isn't very useful, isn't it?
<pjb>
A lot of programming team try to enforce a uniform style to depersonalize the code (and then use git history to find out who wrote what), but I like it when each programmer has a personal style and this can be seen in the code.
<pjb>
(By the way, recently AI algorithms determined that Molière wrote his pieces alone, and that Shakespear had help…).
brown121407 has quit [Ping timeout: 265 seconds]
brown121408 has joined #lisp
<no-defun-allowed>
pjb: In that case, I would rather stick to a convention to hide myself.
dddddd has quit [Remote host closed the connection]
anlsh has quit [Ping timeout: 250 seconds]
shka_ has quit [Quit: Konversation terminated!]
rgherdt has joined #lisp
<no-defun-allowed>
MichaelRaskin: Sticking to one convention for all languages is probably very, very bad. The closest to writing "Lisp" layout in C could be the GNU standard, and the reverse is the stuff you get on #clschool on a very bad day.
<aeth>
pjb: That sounds impractical. The Google Common Lisp Style Guide seems more pragmatic because a lot of the time when more than one convention exists, it says to use the existing convention in an area, which helps keep things somewhat locally uniform.
<aeth>
(I say "an area" because I forget if it says "file" or something broader)
<aeth>
Well, I guess it's kind of vague there, too. e.g. "Choose wisely, but above all, consistently with yourself and other developers, within a same file, package, system, project, etc."
<MichaelRaskin>
no-defun-allowed: it's never the same convention, but some consistency of approaching semantically the same things
<no-defun-allowed>
Perhaps C and Lisp are a worse pair than average, but I don't think I would expect to write things with similar semantics in those, either.
<aeth>
MichaelRaskin: The problem is that Lisp's expression-oriented nature leads to very different idioms than in most languages. There's no need to set an intermediate variable in a COND, or even return to an intermediate variable in a COND, or even use a COND where an IF will do even if it would look too ugly/complicated with a "? ... : ..." ternary in most languages
<MichaelRaskin>
Having more options doesn't mean _always_ picking them
<MichaelRaskin>
(Even if it does mean picking them often)
<easye>
"inconsistency is the hobgoblin of limited minds"
<aeth>
The thing is, in CL nearly everything has a return value (only (values) doesn't, unless someone wrote code that returns (values), which is very unidiomatic and almost always implicitly inserts a NIL, anyway)... and almost all of those return values are meaningful (although it's kind of 50/50 with NIL)
nika has joined #lisp
<easye>
> unless someone wrote code that returns (values)
<aeth>
CL for some reason is even more consistent and ideologically pure here than Scheme (very surprising), which often returns #<unspecified> or some other incredibly literal interpretation of its specification... which can mean different code even betwen CL and Scheme, two very close languages.
<easye>
I know someone who uses that to indicated that they have thought about the return at that point in the function and declare that it should return without values on purpose.
<easye>
I don't code that way, but I obey his convention in the code I fix.
shka_ has joined #lisp
Oladon has quit [Quit: Leaving.]
<easye>
(VALUES) Is actually preferable than RETURN-FROM 'cuz it makes changing function naming more difficult which often leads to mistakes.
<pjb>
easye: my point: don't prefer, use both! (return-from this-function (values))
<easye>
pjb: sounds great.
<easye>
Except that I invariably forget to change the RETURN-FROM function name parameter.
<pjb>
Happily, it's lexical, so you get a compilation error!
<easye>
Still, I am probably happy to have RETURN-FROM require one to name the function that one is returning from, as I get a warning at compile time rather than have the program misbehave.
Lord_of_Life has quit [Read error: Connection reset by peer]
Lord_of_Life has joined #lisp
jcob has quit [*.net *.split]
Patzy has quit [*.net *.split]
Nikotiini has quit [*.net *.split]
AdmiralBumbleBee has quit [*.net *.split]
stepnem has quit [Ping timeout: 240 seconds]
stepnem has joined #lisp
Patzy has joined #lisp
Nikotiini has joined #lisp
jcob has joined #lisp
AdmiralBumbleBee has joined #lisp
varjag has joined #lisp
heisig has joined #lisp
FreeBirdLjj has joined #lisp
t3rtius has quit [Ping timeout: 246 seconds]
FreeBirdLjj has quit [Ping timeout: 245 seconds]
eagleflo has joined #lisp
random-nick has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
beach has quit [Ping timeout: 246 seconds]
beach has joined #lisp
libertyprime has joined #lisp
jonatack has joined #lisp
brown121408 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
dmiles has quit [Read error: Connection reset by peer]
dmiles has joined #lisp
heisig has quit [Quit: Leaving]
scymtym has quit [Ping timeout: 240 seconds]
clothespin__ has quit [Ping timeout: 276 seconds]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
ebzzry_ has joined #lisp
josemanuel has joined #lisp
t3rtius has joined #lisp
thmj has joined #lisp
madage has quit [Remote host closed the connection]
t3rtius has quit [Read error: Connection reset by peer]
stepnem has quit [Ping timeout: 252 seconds]
stepnem has joined #lisp
enrio has joined #lisp
hiroaki has joined #lisp
hiroaki has quit [Remote host closed the connection]
scymtym has joined #lisp
hiroaki has joined #lisp
thmj has left #lisp [#lisp]
FreeBirdLjj has joined #lisp
paul0 has quit [Remote host closed the connection]
paul0 has joined #lisp
srji has quit [Quit: leaving]
srji has joined #lisp
wxie has joined #lisp
* Xach
publishes a new dist update
<phoe>
<3
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 268 seconds]
<Shinmera>
Aw man, just missed the window to add a library then?
Lycurgus has joined #lisp
wxie has quit [Ping timeout: 245 seconds]
<Xach>
Yow, 1 minute ago?
<Shinmera>
Yea, forgot to submit this morning.
<Xach>
Yes, sorry, just missed the window. But I hope not to wait until the end of december for the december update.
<Shinmera>
Great, if all goes well there'll be another by then
<Xach>
This month's problems were caused by two libraries not working well together, compounded by my build hardware crashing sporadically
<Shinmera>
Ouch
<Lycurgus>
do you have reference platorms (outside of lisp) you test on?
<Lycurgus>
(meant Xach)
<Xach>
I need to update to something way more modern
<Xach>
Lycurgus: i use linux amd64 debian 10 for testing
<Xach>
with sbcl
<Lycurgus>
is debian 10 in ga release?
<Lycurgus>
i thought 9 was latest
<Lycurgus>
see that it is
<Lycurgus>
however, they are known to break shit
xkapastel has joined #lisp
<Lycurgus>
so that, in your place, if debian is to be the reference, i'd wait a year from realease
<Lycurgus>
in spite of its slimy commercial nature, ubuntu is a better debian
<Lycurgus>
or rather because of it
smokeink has quit [Ping timeout: 265 seconds]
<Lycurgus>
*release
<Xach>
Lycurgus: i haven't noticed too much breakage.
<Lycurgus>
did you just say that sbcl is the sole implementation you work against?
<Xach>
Lycurgus: i did just so say
<Xach>
Projects that are explicitly sbcl-only are rejected, though.
<Lycurgus>
sbcl on linux, acl on dos, and ccl on mac would maybe be ideal
<Lycurgus>
ah
<Xach>
cl-test-grid did useful testing on multiple platforms
<jackdaniel>
I imagine that testing just on one platform vs one implementation vs all libraries is demanding task
<Lycurgus>
no doubt, but setting up CI and deferring all issues to the pkg owners is less so
<Lycurgus>
including the CI setup and maint
FreeBirdLjj has quit [Remote host closed the connection]
<Lycurgus>
i dont recall a ql pkg ever failing thoug
<Lycurgus>
h
<Lycurgus>
i'm pretty conservative and tend to older pkgs
<Lycurgus>
until recently I was sbcl centric too
<jackdaniel>
Lycurgus: could you set such CI for current ql distributions? I think it would be useful for package and implementation maintainers regardless (I could use some reports for ecl i.e)
<Lycurgus>
if that is not the personal third person, I should think so
<phoe>
in theory one could use Travis CI to test on win/lin/mac on different implementations
<phoe>
but we can't count on Travis for all of quicklisp
FreeBirdLjj has joined #lisp
<jackdaniel>
Lycurgus: that was directed to you, because you seem to have some expeirence with CI and you are interested in that (justifully so!)
<Lycurgus>
misperception, I personally am not interested in CI, it doesn't fit in my resource profile for the things I want to do
<Lycurgus>
but if I were concentrated on a single thing I would
<jackdaniel>
so you are rather suggesting that it would be easy to do /for someone else/?
<Lycurgus>
as far as linux, debian9/ubuntu 18.04 are my current standard
<Lycurgus>
i am suggesting that it would be good and doable, not necessarily that anyone do it
<MichaelRaskin>
I think the only claim was that keeping a CI up is not harder than the work currently done
<Lycurgus>
in practice I know that there is a rats nest of incompatiblities, strengths and weaknesses in the major implementations, and I color within those lines
<Xach>
I guess that keeping a CI up would not be (much) harder, but setting it up initially seems like a big task.
orivej has quit [Ping timeout: 240 seconds]
josemanuel has quit [Quit: leaving]
FreeBirdLjj has quit [Ping timeout: 240 seconds]
josemanuel has joined #lisp
jonatack has quit [Remote host closed the connection]
jonatack has joined #lisp
<Lycurgus>
if the resources weren't a problem it might save effort in the end if you used it just as a filter, empirical backing for the not just sbcl criterion
<Lycurgus>
i.e. not just sbcl on a latest debian
jonatack has quit [Excess Flood]
jjkola has quit [Ping timeout: 240 seconds]
nullniverse has joined #lisp
jonatack has joined #lisp
josemanuel has quit [Quit: leaving]
josemanuel has joined #lisp
jonatack has quit [Ping timeout: 265 seconds]
jonatack has joined #lisp
<MichaelRaskin>
(decided to use my already-there code to check iolib compilation on ECL; ouch it does take time)
mooch2 has joined #lisp
orivej has joined #lisp
mooch3 has quit [Ping timeout: 250 seconds]
jonatack has quit [Ping timeout: 250 seconds]
<MichaelRaskin>
(but yes, it does build eventually)
jonatack has joined #lisp
shifty has quit [Ping timeout: 240 seconds]
Kundry_Wag has joined #lisp
jonatack has quit [Ping timeout: 268 seconds]
shifty has joined #lisp
jonatack has joined #lisp
Kundry_Wag has quit [Ping timeout: 268 seconds]
* jackdaniel
(uncorks the shampaign)
libertyprime has quit [Quit: leaving]
<MichaelRaskin>
Looks like some pun on shampoo campaign
<MichaelRaskin>
But yeah, I kind of have most of the code needed to compute portability matrix for Linux+(SBCL/CCL/ECL/ABCL/CLISP), but I am not patient enough to wait until it builds
<jackdaniel>
champagne, huh ;)
<jackdaniel>
cl-test-grid is good for testing portability
<MichaelRaskin>
So we just need to talk someone into running it regularly?
<jackdaniel>
it even makes it easy to construct pivot tables for different versions of the implementation/software
jonatack has quit [Read error: Connection reset by peer]
jjkola has joined #lisp
karlosz has joined #lisp
Josh_2 has quit [Ping timeout: 268 seconds]
shifty has quit [Ping timeout: 252 seconds]
shifty has joined #lisp
Kundry_Wag has joined #lisp
kscarlet has quit [Read error: Connection reset by peer]
kscarlet has joined #lisp
Oladon has joined #lisp
jjkola has quit [Read error: Connection reset by peer]
shifty has quit [Ping timeout: 265 seconds]
orivej has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
jjkola has joined #lisp
letrec has joined #lisp
<phoe>
a perfect situation would be having access to proper hardware where we can spin up virtualized mac/win/lin boxes on demand, and run our CI on those
<phoe>
but this means expenses to set it up and expenses to maintain it
pjb has quit [Remote host closed the connection]
enrio has quit [Ping timeout: 245 seconds]
pjb has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
stepnem has quit [Ping timeout: 240 seconds]
stepnem has joined #lisp
Kevslinger has joined #lisp
orivej has joined #lisp
enrio has joined #lisp
dddddd has joined #lisp
letrec has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Ping timeout: 276 seconds]
FreeBirdLjj has joined #lisp
t3rtius has quit [Ping timeout: 276 seconds]
stepnem has quit [Ping timeout: 265 seconds]
FreeBirdLjj has quit [Ping timeout: 276 seconds]
stepnem has joined #lisp
jjkola has quit [Quit: Ex-Chat]
bitmapper has joined #lisp
Josh_2 has joined #lisp
tourjin has joined #lisp
heisig has joined #lisp
<Demosthenex>
ok, so i've in the past used R for simple graphing and stats. i recall seeing (but cant find) a post on reddit that said CL could do all the same stuff with some library. does anyone have a recommendation?
<edgar-rft>
Demosthenex: if I know this right then XLISP-STAT was one of the predecessors of R and there had been several attempts to port XLISP-STAT to Common Lisp, for example https://github.com/blindglobe/common-lisp-stat
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
jfb4 has joined #lisp
hiroaki has quit [Ping timeout: 265 seconds]
FreeBirdLjj has quit [Ping timeout: 276 seconds]
FreeBirdLjj has joined #lisp
clothespin has joined #lisp
gxt has quit [Quit: WeeChat 2.6]
Jesin has quit [Quit: Leaving]
Jesin has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
FreeBirdLjj has quit [Ping timeout: 265 seconds]
FreeBirdLjj has joined #lisp
pbgc has quit [Quit: Computer has gone to sleep.]
FreeBirdLjj has quit [Ping timeout: 250 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
clothespin has quit [Ping timeout: 252 seconds]
<no-defun-allowed>
If you are going to use jsown, I would strongly suggest you go into the sources and change every (declaim (optimize ... (safety 0) ...)) to (safety 1) at least, because you will get some very strange conditions if you make a mistake otherwise.
mooch has quit [Ping timeout: 250 seconds]
Kundry_Wag has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
<phoe>
does the standard actually guarantee that top-level DECLAIM OPTIMIZE settings do not leak out of the currently compiled file?
nowhere_man has joined #lisp
<no-defun-allowed>
"As with other defining macros, it is unspecified whether or not the compile-time side-effects of a declaim persist after the file has been compiled."
<no-defun-allowed>
I'm not good at reading CLHS-ese, but I think this means there's no guarantee.
<no-defun-allowed>
Can't say, but it's still incredibly impolite to use (SAFETY 0). I had to spend a good half hour debugging with a friend because we got memory faults by giving it the structure (:obj ((a . b) ...)) instead of (:obj (a . b) ...)
lucasb has quit [Quit: Connection closed for inactivity]
cosimone has quit [Remote host closed the connection]
<phoe>
this
cosimone has joined #lisp
<phoe>
sbcl has sb-ext:restrict-compiler-policy for that
clothespin has joined #lisp
josemanuel has quit [Quit: leaving]
xuxuru has quit [Quit: xuxuru]
<no-defun-allowed>
(EVAL-WHEN is one of the parts of CL I don't get, so I think you should wait for someone more knowledgeable to answer.)
orivej has quit [Ping timeout: 268 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
<aeth>
no-defun-allowed: yet another piece of evidence that every JSON library for CL that I've heard of is awful
libertyprime has joined #lisp
<aeth>
I really need to get around to writing one
<aeth>
For whatever reason, every JSON library looks to me like an irredeemable failure that fails to understand either CL or JSON. I've ranted about that before here, though.
FreeBirdLjj has quit [Remote host closed the connection]
<Josh_2>
Yes you have xD
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
libertyprime has quit [Ping timeout: 250 seconds]
FreeBirdLjj has joined #lisp
khisanth__ has quit [Ping timeout: 265 seconds]
cosimone has quit [Quit: Terminated!]
FreeBirdLjj has quit [Ping timeout: 246 seconds]
clothespin__ has joined #lisp
brown121407 has quit [Remote host closed the connection]
clothespin_ has quit [Ping timeout: 250 seconds]
Codaraxis has joined #lisp
khisanth__ has joined #lisp
<no-defun-allowed>
aeth: I have a *very* large JSON file I want to analyse, so I will probably have to make my own with some kind of "stream"ing.
<no-defun-allowed>
And I remember jsown didn't understand some part of the \u syntax until recently, FWIW
<jfrancis>
I got almost three years into a work project using cl-json before hitting a missing feature that forced me to jsown. That was six months ago, and I still haven't gotten around to re-writing all the cl-json stuff with jsown. I just have one single file that uses jsown instead of cl-json. Every time I look at that project and compare it with all the features I have yet to complete, it moves further and further down the list of priorities.
<jfrancis>
Which is why good software projects have project managers, to force stuff like that up to the top.
nckx has joined #lisp
rgherdt has quit [Ping timeout: 268 seconds]
<White_Flame>
of course, that's also why having application-specific functions which wrap your libraries are also good
<White_Flame>
especially if they can raise the level of abstraction to application tasks