<pfdietz50>
To undo the global declaim, do (declaim (sb-ext:unmuffle-conditions sb-ext:compiler-note))
clothespin has joined #lisp
<phoe>
I think that I have asked this question before, but here goes nothing...
<phoe>
I have a list (1 2 3). I would like to remove exactly these elements from list (1 1 3 2 2 2) so I get (1 2 2) in result. The result order doesn't matter.
kajo has joined #lisp
<pfdietz50>
So, bag difference?
<phoe>
Is there a utility function for that somewhere? SET-DIFFERENCE won't get me anywhere since these aren't sets and duplicates can happen anywhere.
<phoe>
Bag difference, yes.
prumnopytis has quit [Remote host closed the connection]
prumnopytis has joined #lisp
<pfdietz50>
The :fset system has bags and a bag-difference function, but it's not operating on lists.
<phoe>
Again, I can write that myself if necessary - I just want to avoid writing my own code if a utility function exists somewhwere.
<pfdietz50>
FSET has bag-difference, and a convert function for going between bags and lists.
<pfdietz50>
So, try that.
<phoe>
OK. I'll see if I can easily use FSET in here, and read up a little bit on it.
<pfdietz50>
It's an interesting package, doing functional set data structures. It does some setf expanders functionally, which is interesting.
<pfdietz50>
The idea of a functional setf expander would be something in this spirit: (setf (car <place>) x) ==> (setf <place> (cons x (cdr <place>)))
<pfdietz50>
(although the standard expander for cdr is not functional; that is just for illustration, and ignores other details)
baby_yoda_squadr has joined #lisp
<pfdietz50>
Oh, and here's another system with bags: phoe-toolbox. Ah, what? :)
baby_yo51 has quit [Ping timeout: 258 seconds]
<LdBeth>
phoe: just #'remove the first element eql to the number
<LdBeth>
It has a :count arg specifies how many items are removed
<phoe>
LdBeth: A very naïve solution would be:
<phoe>
(defun bag-difference (bag-1 bag-2 &key (test 'eql)) (loop with result = (copy-list bag-1) for element in bag-2 if (member element result :test test) do (setf result (remove element result :test test :count 1)) finally (return result)))
<phoe>
Or even use DELETE instead of REMOVE for a bit of optimization in there.
<LdBeth>
Yes, although FSET is good if you prefer immutable
<phoe>
Yes, I am looking into it now.
Kevslinger has joined #lisp
Fucuns has joined #lisp
oni-on-ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
Lycurgus has joined #lisp
karlosz has joined #lisp
Fucuns has left #lisp [#lisp]
didi has quit [Ping timeout: 265 seconds]
oni-on-ion has quit [Ping timeout: 248 seconds]
oni-on-ion has joined #lisp
<oni-on-ion>
has anyone seen or heard of a networked/collaborative REPL ?
<prumnopytis>
I have a lousy example
<prumnopytis>
Google vomited Google Collab Jupyter notebooks out at some point
anewuser has joined #lisp
oni_on_ion has joined #lisp
oni-on-ion has quit [Ping timeout: 248 seconds]
slyrus_ has joined #lisp
slyrus has quit [Ping timeout: 258 seconds]
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 268 seconds]
brettgilio has joined #lisp
slyrus__ has joined #lisp
slyrus_ has quit [Ping timeout: 265 seconds]
prumnopytis has quit [Remote host closed the connection]
prumnopytis has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Client Quit]
<aeth>
heh, Jupyter notebooks
<aeth>
the concept is neat, but I don't like the execution
torbo has quit [Remote host closed the connection]
baby_yoda_squadr has quit [Read error: Connection reset by peer]
<aeth>
e.g. by default, they have no spellchecker even though they run in the browser and half of the cells are just text cells, so they had to actively work to prevent your browser from spellchecking the Markdown cells
<aeth>
(code spellchecking is trickier because it does need to only check the comments and strings, or at least that's what Emacs does)
baby_yo57 has joined #lisp
Lycurgus has quit [Quit: Exeunt]
<oni_on_ion>
hmm.
<pfdietz50>
I'd figured something called "Jupyter" would lack a spell checker.
<LdBeth>
aeth: markdown is a form of code thus should not be spellcheck
<LdBeth>
I guess
<aeth>
LdBeth: Well, I mean, practical Markdown is going to embed a lot of HTML if that's permitted because basic Markdown just doesn't give you enough. So that could be an issue with spellchecking. But a robust enough extended Markdown so you don't need HTML for basic things is basically just going to be words in your language mixed with symbols like *
<oni_on_ion>
pfdietz50, =) it started with python
<LdBeth>
aeth: what’s your thoughts on org-mode?
<aeth>
LdBeth: Org mode is better if your things are a list and/or a table
<aeth>
LdBeth: But otherwise it's probably not worth the incompatibility
<aeth>
What's nice about org-mode tables is that they are easy to write/edit/etc. in Emacs, but will at least be readable in other forms (like using less in the terminal)
<keja>
To undo the global declaim, do (declaim (sb-ext:unmuffle-conditions sb-ext:compiler-note))
<aeth>
LdBeth: I write a ton of LaTeX and org and Markdown because they all fill different niches. There are a few others that I know but rarely use like Mediawiki Markup (basically only used on Mediawiki/Wikipedia) and BBCode (a dying type of markup)
<Ampws>
I'd like to use emacs and atom. They're more friendlier, I think. Maybe JN introduced other languages for the so-called diversification.
baby_yo57 has quit [Ping timeout: 268 seconds]
bitmapper has quit [Ping timeout: 240 seconds]
clothespin has quit [Quit: Leaving]
Kaisyu72 has quit [Quit: ERC (IRC client for Emacs 26.3)]
Kaisyu7 has joined #lisp
clothespin has joined #lisp
Josh_2 has quit [Remote host closed the connection]
lxpnh98 has joined #lisp
black_13 has joined #lisp
<black_13>
is it appropriate to ask how lisp is built or possible internals
<johnjay>
black_13: no you are part of the rebel alliance and a traitor. To the cells!
<black_13>
lustig
<pfdietz50>
Well, you can look at sbcl's build process.
<black_13>
if you have a cons cell
orivej has quit [Ping timeout: 240 seconds]
<johnjay>
the cons cells are where invalid lambdas go
<johnjay>
aeth: if you have time could you look at this question real quick?
<ym>
Yep, I also seen it, but SBCL says there is no such a thing.
bjorkintosh has quit [Remote host closed the connection]
bjorkintosh has joined #lisp
<prumnopytis>
Interesting, what I found was that ~(setf (slot-value foo 'page) "baz")~ successfully sets my read-only value to "baz".
<prumnopytis>
In SBCL.
<prumnopytis>
And ECL. I guess I misunderstood too <_>
<prumnopytis>
**** Nope it seems to be working consistently in both sbcl and ecl. Trying to setf on a :read-only t value errors because that's not defined in both.
<prumnopytis>
Try it on a value that's not read-only.
<prumnopytis>
The symbol-vaue isn't the struct's slot's accessor.
pjb has quit [Remote host closed the connection]
<prumnopytis>
Actually, ignore me
<ym>
It works for structures, but not for classes.
<ym>
I can't even define a slot with :read-only parameter.
patlv has joined #lisp
gravicappa has joined #lisp
_whitelogger has joined #lisp
<prumnopytis>
ym: What about using :reader instead of :accessor in your class definition?
<prumnopytis>
After reading let over lambda I have grossly erred on the side of not using CLOS appropriately ;p
<prumnopytis>
It seems defstruct makes a lot of assumptions about what's happening and defclass does not (and is hence manual)
ahungry has quit [Remote host closed the connection]
<ym>
Never mind.
<oni_on_ion>
i thought that defstruct is more manual than defclass
_whitelogger has joined #lisp
patlv has joined #lisp
pat__ has joined #lisp
pat__ has quit [Client Quit]
_whitelogger has joined #lisp
orivej has joined #lisp
atgreen has quit [Ping timeout: 265 seconds]
orivej has quit [Ping timeout: 258 seconds]
whiteline has quit [Remote host closed the connection]
orivej has joined #lisp
empty-cup_ has joined #lisp
Jeanne-Kamikaze has quit [Remote host closed the connection]
empty-cup has quit [Remote host closed the connection]
empty-cup has joined #lisp
Oladon has quit [Read error: Connection reset by peer]
_whitelogger has joined #lisp
Arcaelyx has quit [Ping timeout: 240 seconds]
_whitelogger has joined #lisp
_whitelogger has joined #lisp
terpri has joined #lisp
dddddd has joined #lisp
orivej has quit [Ping timeout: 260 seconds]
quazimodo has quit [Ping timeout: 258 seconds]
smokeink has joined #lisp
quazimodo has joined #lisp
libertyprime has joined #lisp
insilications has joined #lisp
xvx has joined #lisp
_whitelogger has joined #lisp
varjag has joined #lisp
quazimod1 has joined #lisp
quazimodo has quit [Ping timeout: 268 seconds]
varjag has quit [Ping timeout: 258 seconds]
vlatkoB has joined #lisp
_whitelogger has joined #lisp
quazimod1 has quit [Ping timeout: 265 seconds]
quazimodo has joined #lisp
emaczen has joined #lisp
xvx has quit [Ping timeout: 240 seconds]
ealfonso has joined #lisp
Oladon has quit [Quit: Leaving.]
emaczen has quit [Remote host closed the connection]
zaquest has joined #lisp
_paul0 has joined #lisp
paul0 has quit [Ping timeout: 252 seconds]
enrio has quit [Read error: Connection reset by peer]
teej has quit [Quit: Connection closed for inactivity]
insilications has quit [Quit: Leaving]
<phoe>
morniiiiiiiiiiiing
<no-defun-allowed>
Good morning phoe
<beach>
Hello phoe.
xvx has joined #lisp
cosimone has joined #lisp
ym has quit [Quit: Leaving]
space_otter has quit [Remote host closed the connection]
SaganMan has quit [Read error: Connection reset by peer]
rippa has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
_whitelogger has joined #lisp
SaganMan has joined #lisp
<phoe>
Hello to you two
xvx has quit [Quit: xvx]
william1 has joined #lisp
pilne has quit [Quit: Hello, 911? Yeah, it's caught in the window this time.]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
varjag has joined #lisp
Oladon has quit [Read error: Connection reset by peer]
Oladon has joined #lisp
ealfonso has quit [Remote host closed the connection]
ealfonso has joined #lisp
Lycurgus has joined #lisp
<Lycurgus>
moin all; what was clasp gonna do that ordinary FFI doesn
<Lycurgus>
t?
jonatack has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
I would guess that most implementations can't call into C++ code, whereas Clasp can?
<Lycurgus>
well they can via FFI, no?
<Lycurgus>
how is it different from cl swig oder?
<no-defun-allowed>
Not C++. That has a different calling convention and is pretty much unportable compared to C interfacing.
<Lycurgus>
i c, that's not entirely accurate but point taken
<no-defun-allowed>
Sorry, I don't know much about C++.
<Lycurgus>
the binary interface for c++ is same as c essentially
<Lycurgus>
it's c++ to c++ that has issues or directly interfacing with c++ oop
<Lycurgus>
so yeah if it was clos to c++ that would be a thing
<Lycurgus>
a super scary thing, but awesome if pulled off right
cosimone has quit [Remote host closed the connection]
<galdor>
quick question: (read-from-string "(+ 1 2" nil) signals a END-OF-FILE condition; I find it surprising since I provided the first optional argument EOF-ERROR-P
<galdor>
am I missing something?
* Lycurgus
closure looks like
Lycurgus has quit [Quit: Exeunt]
<pjb>
galdor: read more precisely the read or read-from-string specifications about end-of-file conditions.
<pjb>
galdor: (read-from-string "\"foo" nil) #| ERROR: Unexpected end of file on #<string-input-stream :closed #x30200255EA4D> |# (read-from-string " " nil) #| --> nil ; 2 |#
Kundry_Wag has joined #lisp
<pjb>
galdor: the key word here is "unexpected". There are expected end-of-file and unexpected end-of-file.
william1 has quit [Ping timeout: 268 seconds]
atgreen has joined #lisp
<pjb>
galdor: when you want to read the representation of an object, and there's none, it's an expected end-of-file. But if you start parsing the representation of an object, it is expected the representation is complete. An end-of-file here is unexpected.
<galdor>
oh the description states a difference between eof *before* an object and *in the middle of* an object
<pjb>
galdor: yes.
<pjb>
Exceptional Situations: read signals an error of type end-of-file, regardless of eof-error-p, if the file ends in the middle of an object representation.
<galdor>
so I can actually handle both
<galdor>
I'm trying to modify sbcl to have a minimal readline-style interface in the repl
<galdor>
just having C-a, C-e, C-f and C-b would help
<galdor>
a minimal history with C-p and C-n would be even better, C-r would be so pleasant
ealfonso has quit [Ping timeout: 240 seconds]
<flip214>
when using WITH-OUTPUT-TO-STRING, can I close the stream in the W-O-T-S block and get the result?
mn3m has quit [Ping timeout: 260 seconds]
<pjb>
flip214: can't close otherwise than exiting from the scope. But you can get the result with get-output-stream-string
<galdor>
but the point is having something built in
<Xach>
ok
<galdor>
I regularly run sbcl directly just for a quick check, or to make sure a system loads without any issue
<galdor>
and when something goes wrong, it's a pita
<galdor>
of course one can use rlwrap
<galdor>
but then one has to remember always to run rlwrap
<Xach>
my solution is to always run within emacs :)
<Xach>
not always with slime - sometimes just in a *shell* buffer.
<Xach>
but that is partly because i do most things in emacs so it's always running
<MichaelRaskin>
Mine is to have a wrapper script
<MichaelRaskin>
So by default rlwrap is there
<galdor>
thinking about this, I'm starting to wonder if there is a chance this kind of patch gets accepted into sbcl
<Xach>
galdor: i think having something built-in is good! i hope it is not insurmountably difficult.
<galdor>
I just played a bit with REPL-READ-FORM-FUN
<galdor>
the annoying part is the term stuff, which I should put in a separate system, then hope it can get included as contrib, a bit like asdf
<galdor>
this way it could also be added to ccl
<Xach>
galdor: how are you doing terminal control?
<galdor>
I'm thinking about just reading the termcap database, I should not need to many control sequences
<galdor>
an alternative would be to use only basic VT100 sequences, libnoise does that for redis and it apparently works for all modern terminals
<xristos>
you could improve cl-readline, which would also work on windows
<xristos>
rather than another adhoc solution
<galdor>
cl-readline is GPLv3 which would not work either for me or for an inclusion in SBCL or CCL
<Xach>
xristos: how does cl-readline work on windows?
<Xach>
does it need readline.dll or something?
<xristos>
i don't know about cl-readline, but readline should work (supports mingw32) so i don't see why cl-readline won't
<Xach>
that sounds complicated
smokeink has quit [Ping timeout: 240 seconds]
whiteline has joined #lisp
vidak` has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
vaporatorius has joined #lisp
quazimodo has quit [Ping timeout: 268 seconds]
<phoe>
Xach: I assume that it works the same way other FFI-based libs work
<phoe>
readline has binaries for windows
<Xach>
that sounds complicated
empty-cup has quit [Quit: No Ping reply in 180 seconds.]
X-Scale has joined #lisp
empty-cup has joined #lisp
jonatack has quit [Ping timeout: 258 seconds]
je4i has joined #lisp
patlv has joined #lisp
<jackdaniel>
how about linedit?
<Xach>
jackdaniel: already considered and rejected!~!
<jackdaniel>
ah, thanks
patlv has quit [Client Quit]
wxie has joined #lisp
Lycurgus has joined #lisp
empty-cup has quit [Remote host closed the connection]
Ampws has left #lisp [#lisp]
fanta1 has joined #lisp
narimiran has joined #lisp
bitmapper has joined #lisp
lucasb has joined #lisp
LiamH has joined #lisp
Arcaelyx has joined #lisp
vidak` has quit [Read error: Connection reset by peer]
lennonwoo has joined #lisp
orivej has joined #lisp
Lord_of_Life_ has joined #lisp
wxie has quit [Ping timeout: 258 seconds]
Lord_of_Life has quit [Ping timeout: 260 seconds]
Lord_of_Life_ is now known as Lord_of_Life
fanta1 has quit [Quit: fanta1]
nika has joined #lisp
empty-cup has joined #lisp
Lycurgus has quit [Quit: Exeunt]
random-nick has joined #lisp
fivo has quit [Quit: WeeChat 1.9.1]
dale_ has joined #lisp
dale_ is now known as dale
brown121407 has quit [Ping timeout: 260 seconds]
brown121408 has joined #lisp
enrio has joined #lisp
SaganMan has quit [Quit: WeeChat 1.6]
FreeBirdLjj has joined #lisp
anewuser has joined #lisp
empty-cup has quit [Ping timeout: 240 seconds]
empty-cup has joined #lisp
clothespin has quit [Ping timeout: 268 seconds]
davisr__ has quit [Remote host closed the connection]
davisr__ has joined #lisp
atgreen has quit [Remote host closed the connection]
atgreen has joined #lisp
nika has quit [Read error: Connection reset by peer]
clothespin has joined #lisp
nika has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
Josh_2 has joined #lisp
EvW has joined #lisp
_whitelogger has joined #lisp
<phoe>
#'ASDF:TEST-SYSTEM has a keyword argument named VERBOSE. Can I somehow access the value of this argument inside :PERFORM (TEST-OP ...) ?
<phoe>
I want my test framework to be either quiet or verbose, based on that value of :VERBOSE.
<galdor>
oh I'd like this one too
<jcowan>
I think it's better for a product to have a misspelling in it to make search easier. If Jupyter were called Jupiter, teh Goog would mix it up with the planet and the god.
<jcowan>
(also much easier to trademark if you need to do that)
<pfdietz>
That's an interesting point.
Josh_2 has quit [Remote host closed the connection]
nowhere_man has joined #lisp
<beach>
I do that all the time. Cleavir, Clordane, Climacs, ..
torbo has joined #lisp
slyrus_ has joined #lisp
slyrus__ has quit [Ping timeout: 265 seconds]
<pfdietz>
phoe: create a subclass of TEST-OP, give it a slot that stores verbosity, and write a before method on OPERATE on that class that initializes the slot w. the verbose key arg.
nowhere_man has quit [Remote host closed the connection]
<pfdietz>
Or, perhaps put the slot on the component objects?
nowhere_man has joined #lisp
<p_l>
no non-FFI libs will work for readline on windows
<p_l>
Xach: jackdaniel: xristos ^
<p_l>
and readline got blood on its hands when it comes to licensing
<beach>
That's a very strange way of expressing it.
<p_l>
beach: today, after waay more scrutiny by lawyers, many times that readline was used to force a project into switching license to GPL turned out to be bluffs without legal weight
LiamH has quit [Quit: Leaving.]
<p_l>
in fact, SBCL could be considered evidence against the arguments that led to GPLing of CLISP
brettgilio has quit [Ping timeout: 260 seconds]
<p_l>
that said, no non-FFI method will work on Windows
<p_l>
because conhost.exe does *not* use terminal sequences
gabiruh has joined #lisp
johnjay has quit [Ping timeout: 265 seconds]
johnjay has joined #lisp
jonatack has joined #lisp
johnjay has quit [Remote host closed the connection]
empty-cup has quit [Ping timeout: 240 seconds]
brown121408 has quit [Read error: Connection reset by peer]
brown121407 has joined #lisp
johnjay has joined #lisp
<pjb>
p_l: what do you mean about sbcl licensing?
<pjb>
Please elaborate.
Jeanne-Kamikaze has joined #lisp
brown121407 has quit [Ping timeout: 260 seconds]
fortitude has joined #lisp
clothespin has quit [Ping timeout: 265 seconds]
brown121407 has joined #lisp
<jcowan>
p_l: URL for the readline vs. CLISP story, the new one?
pilne has joined #lisp
william1 has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
luna_is_here_ has joined #lisp
reg32 has joined #lisp
<reg32>
Hi all
<reg32>
is there a simple way to trace all execution from a given function
<reg32>
that is rather then tracing a single function
william1 has quit [Ping timeout: 240 seconds]
<reg32>
I would like to trace that function and all the functions that are called within and so on recursively
longshi has joined #lisp
oni_on_ion has quit [Remote host closed the connection]
oni_on_ion has joined #lisp
william1 has joined #lisp
niklascarlsson has joined #lisp
brettgilio has joined #lisp
<pfdietz>
SBCL has :wherein, which enables you to trace a function FOO only if the call is within a call to some other function BAR. Not quite what you asked for.
<pjb>
(defun foo (args) (trace (progn function body)))
<pfdietz>
Or that :)
<pjb>
sorry, I mean (defun foo (args) (step (progn function body)))
<pjb>
Since what you described wasn't tracing, but stepping.
ebrasca has joined #lisp
<reg32>
stepping doesn't work well on windows
<reg32>
it's a whole function step on windows
<reg32>
and unfortunately I am trying to fix a roswell bug on Windows
<reg32>
:D
<phoe>
which bug?
<reg32>
I would easily step if I were in Linux
<pjb>
Now, of course, you need a stepping function that does exactly what you want. CL:STEP behavior is implementation dependant, not all implementation have a functional stepping function. You can instead use cl-stepper, but to trace all the code called with cl-stepper, you need to compile it with cl-stepper instead of with cl.
<reg32>
ah phoe!
<reg32>
hi!
<pjb>
reg32: try cl-stepper!
<phoe>
heyyyy
<reg32>
I am fixing YOUR BUG
<phoe>
OH
<phoe>
glad to hear that~
<reg32>
I am lucaregini
<reg32>
I am looking exactly into that
fyrkrans has joined #lisp
<reg32>
also tried cl-stepper from informatimago
<reg32>
same behaviour
<reg32>
whole function stepping
<reg32>
again I am on windows
<reg32>
debugging on Windows is a nightmare
<MichaelRaskin>
Well, you could just trac eeverything then filter the traces in a text file?
<pjb>
reg32: you need to compile the function you want to step with cl-stepper instead of with cl!!!
cosimone has joined #lisp
<p_l>
jcowan: CLISP changed license to GPL over its use of GNU Readline library, which was GPLed
<pjb>
cl-stepper is not a low level stepper, it's a source-level debugging tool. It provides your sources with special operators and macros to instrument your code when compiling.
<reg32>
compile?
<pjb>
Yes, compile
<pjb>
And even, you need to PATCH the package form! since you need to replace CL by CL-STEPPER.
<jcowan>
p_l: Indeed. I was asking about the "scrutiny by lawyers" leading to the opposite conclusion, which is news to me.
<p_l>
pjb: SBCL would be an example that CLISP is not "derived software", as it would be trivial to redo REPL without readline
<reg32>
you mean run like this: (cl-stepper:step(roswell.install:install argv))
<reg32>
ah
<reg32>
ok
<reg32>
is there any documentation?
<p_l>
jcowan: the crux is in the language used by GPL - it speaks *nothing* of linking or using the code, but of "derived code"
<pjb>
p_l: unfortunately, the definition of "derived work" or "derived software" is left up to any judge judging in a specific case…
<p_l>
jcowan: armchair lawyers from the heyday of strongarming GPL disregarded that and pushed narrative that "linking" is derivation
<pjb>
p_l: this might be the main drawback of GPL, to rely in the end on people not knowing much (not anything when it was created) about software.
<pjb>
reg32: yes, but first you need to have compiled roswell.install and all its dependencies with cl-stepper instead of cl.
<p_l>
pjb: decision whether the software fulfills the standard for "derived" is up for court, but it also means that "linking" is not, in fact, an offence
<jcowan>
Yes, and there's a long-standing dispute about whether a work made by linking disparate parts is actually a joint work or more of an anthology.
<p_l>
jcowan: the current standard interpretation is whether the software will work without the code involved
<jcowan>
Larry Rosen, who is an IP lawyer specializing in FLOSS, is of the opinion that it is an anthology
<pjb>
p_l: perhaps clisp authors didn't want to do the job of compiling clisp with linedit (or it didn't exist yet).
<p_l>
pjb: I also suspect they might have felt browbeaten
<reg32>
thanks pjb
<MichaelRaskin>
There was no alternative line-editing library they considered good enough
<p_l>
pjb: it's not like brow beating someone with dubious claims is rare in US-led licensing, I'd argue that FLOSS is relatively free of it in comparison to typical "mostly illegal" EULA
<jcowan>
There was certainly no UFFI for CLISP at that point, and indeed there is still no official support. Nor did the various C readline-alikes exist, I think
<pjb>
reg32: it's not 100% sure (the sources could be uncooperative), but in general it would work.
<p_l>
jcowan: making readline optional would fulfill what is currently considered "non-derived"
<pjb>
p_l: at least, it's optional at run-time with the -i option.
* jcowan
wishes some of the Guile libs were dual-licensed under MIT, but apparently it's a religious issue
<p_l>
jcowan: religious issue says it right, IMO :(
je4i has quit [Quit: ERC (IRC client for Emacs 25.3.1)]
<jcowan>
Pure, which is a Lisp in disguise, has two top-level programs, one GPL and linked with readline, and one permissive and not linked with it. Of course they share most of their code, but the copyright owner can do that where we canot.
<pjb>
In any case, the question of the license seems to be less relevant today than the awareness about privacy problems and all the grief against Apple, Facebook, Google etc.
<p_l>
yes
* jcowan
is personally indifferent to privacy issues
luna_is_here_ has quit [Ping timeout: 260 seconds]
<MichaelRaskin>
Well, some of the Google privacy issues also are made worse because of GPL not being succesfully enforced against ODMs
<pjb>
Unfortunately, most people cannot make the logical inference and step to using linux or freebsd and to compile their software from sources, but at least a lot of developers can. The more Apple securize its systems, the more people switch to linux…
<jcowan>
The more the universe expands, the more the price of chocolate rises....
<p_l>
funnily enough, GPL when considered with "modern" reading of "derived work" is more compatible with Lisp than CDDL, which for various reasons I like in C world
<p_l>
pjb: unfortunately FSF is also not really supportive of actually open hardware :(
<pjb>
The MacPro can only use SSD that are identified and authorized (cryptographically) by Apple. This let them ensure a secure boot, but it goes very much against freedom (of developers and users).
LiamH has joined #lisp
<p_l>
pjb: it also stops you from using OS of your choice, as "normal" NVMe is not supported
<jcowan>
I don't use crypto because my life is entirely open
<p_l>
you need to authenticate yourself to the security chip
<p_l>
jcowan: my life being open has nothing on my choice of using cryptography or not - it allows me to ensure certain contractual obligations, for example
cosimone has quit [Quit: Terminated!]
<p_l>
still, I find it *ridiculous* that MS is more privacy friendly and owner friendly
<jcowan>
It's true that I know some proprietary secrets, but I manage that by (a) not talking about them (b) forgetting about them
cosimone has joined #lisp
<p_l>
present day list of hw in order of trustability: 1) TALOS2 & Blackbird 2) Stuff certified by MS for Win10 Enterprise in highest security mode 3) everything else
<p_l>
jcowan: ah, encryption in my case ensures that my *tools* can't talk about them to people who illegally gained them
narimiran has quit [Ping timeout: 240 seconds]
<jcowan>
p_l: I believe IBM mainframes are extremely trustable
* White_Flame
goes back to 6502
<p_l>
jcowan: I ranked "trust" in "can I 'own' every aspect of the device". You can't do that with most modern mainframes
<jcowan>
It's all published, I think
<p_l>
however, IBM is most floss-friendly on hw side of POWER8/POWER9
<p_l>
jcowan: not for z
<p_l>
POWER8/POWER9 is
<p_l>
that's why TALOS2/Blackbird lead my list
<p_l>
they combine the open source parts from IBM with open source design for the remaining pieces to implement
<p_l>
IBM does not provide you a complete system to use on your own, though the material from OpenPower is very close
<p_l>
you still need to design a host motherboard and implement it
<reg32>
Hi
_whitelogger has joined #lisp
<reg32>
I am still getting the same results
<reg32>
this is what i did in the following order
<reg32>
quicklisp loaded informatimago stepper
<reg32>
asdf-load-system :roswell
<phoe>
reg32: you need to shadow the symbol CL:STEP with the one provided by cl-stepper, and only then compile roswell.
<reg32>
cl-stepper:stepped into the function I want to troubleshoot
gravicappa has quit [Ping timeout: 258 seconds]
Josh_2 has joined #lisp
ebrasca has quit [Remote host closed the connection]
Oladon has joined #lisp
nika has quit []
sauvin has quit [Read error: Connection reset by peer]
srji has quit [Quit: leaving]
Jeanne-Kamikaze has quit [Remote host closed the connection]
<pjb>
I've been paid for some CL code I wrote, indeed.
<reg32>
xach the link is active
<reg32>
I can pay
vidak` has joined #lisp
<reg32>
It's 20$ at the moment
<reg32>
it will get 5 more
oni_on_ion has quit [Remote host closed the connection]
oni-on-ion has joined #lisp
Jeanne-Kamikaze has joined #lisp
scymtym has joined #lisp
brettgilio has quit [Quit: Quit]
oni-on-ion has quit [Remote host closed the connection]
brettgilio has joined #lisp
didi has joined #lisp
oni-on-ion has joined #lisp
<didi>
So (nthcdr 42 ()) => () but (subseq () 42) signals an error. I wonder if `subseq' should just return an empty sequence.
<Xach>
reg32: it says "currently in testing mode" for me.
enrio has quit [Ping timeout: 258 seconds]
cosimone has joined #lisp
<Xach>
reg32: were you able to pay?
<prumnopytis>
didi: Isn't that pointing out that (cdr nil) => nil ?
<didi>
prumnopytis: `cdr' is forgiving like that.
<prumnopytis>
I haven't read the spec, but I can imagine that "get the cdr of" and "get the subsequence starting at" should be defined differently
<reg32>
I am getting name conflicts conditions
anewuser has quit [Ping timeout: 268 seconds]
<reg32>
do I have to explicity resolve all restarts?
<prumnopytis>
didi: In fact I think mathematically it's going to turn out that if subsequences can start successfully after the end of a list, there is no end to the subseq(uence)
<reg32>
Xach Yes I payed 5$ but had to use paypal
<reg32>
the other method didn't work but I have to admit that I have a pretty strong credit card security
<reg32>
the strange thing is that the counter didn't increase
<prumnopytis>
And in fact (subseq '(1) 1) => NIL
pfdietz has joined #lisp
luna_is_here_ has joined #lisp
<reg32>
now it works!
longshi has quit [Ping timeout: 258 seconds]
<reg32>
but I had to resolve all symbol conflicts
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
jmercouris has joined #lisp
<didi>
prumnopytis: For example, in Python [1,2,3][42:] => [].
patlv has joined #lisp
<prumnopytis>
I find it bewildering how so many people feel about Python now how I felt about it as an undergraduate who moved away from the taught Matlab
<didi>
How do people feel about Python?
<jmercouris>
didi: are you organizing ELS?
<prumnopytis>
Well, it seems that you think Python's slicing behaviour is intuitive, which I don't particularly
<didi>
jmercouris: I'm not.
<didi>
prumnopytis: I find it useful.
bitmapper has quit []
<jmercouris>
prumnopytis: Python's slicing behavior is intuitive IF you understand the rationale, there's a good stack overflow answer about it here: https://stackoverflow.com/a/509297/1699398
<nirved>
didi: then what would (setf (subseq () 42) '(1 2 3)) do?
<didi>
nirved: Ah, good question.
<didi>
I dunno.
reg32 has quit [Ping timeout: 260 seconds]
clothespin_ has joined #lisp
<prumnopytis>
Contextually, I'm a Kiwi, and the current head-of-R is (being portrayed by me as being) like, "wow, what if R was more like Python you guys". And I just had a PhD student exort the manifest brilliance of Jupyter notebooks to me the other day. For me, I have been making the effort to move to lisp from C.
clothespin__ has joined #lisp
<prumnopytis>
Oops, from C to lisp.
<jmercouris>
"exort the manifest brilliance"? What does that even mean?
<prumnopytis>
That's what I was thinking while it was happening
<jmercouris>
prumnopytis: Is english your second language?
<aeth>
prumnopytis: I wonder if AI research selects for people who like Jupyter notebooks because I'm really not sure why they all love it.
<prumnopytis>
Oh come now, I missed one h
<p_l>
aeth: "AI" research selects for people who can't stand being told they do statistics
clothespin has quit [Ping timeout: 258 seconds]
<didi>
p_l: The nerve...
<jmercouris>
prumnopytis: I was being serious, I just have no idea what you are saying
<aeth>
p_l: they don't do statistics, the AI does
<p_l>
aeth: they string together bits of stuff in ways that would make physicists writing Fortran give sermons about clean code
<prumnopytis>
Argue in favour of the great utility of jupyter notebooks, which are a cell based code snippet runner
reg32 has joined #lisp
<jmercouris>
Like that, what does that sentence even mean?
<jmercouris>
Can you start a sentence like that?
<aeth>
p_l: I mean, yes, Jupyter notebook is kinda like if I turned in my SLIME REPL log modified to print graphs as an actual program.
clothespin_ has quit [Ping timeout: 258 seconds]
<nirved>
jupyter notebooks look like a Open Genera
<p_l>
nirved: nope
<p_l>
not close at all
<p_l>
they are a bit worse org-mode
<p_l>
that happened to evolve out of an extended Python REPL
<prumnopytis>
That's what springs to my mind p_1, and I don't particularly like org-mode for mixing programs together
<nirved>
well, looks like inspired by genera
<didi>
OK, I am not the only one that doesn't see the appeal of Jupyter notebooks. Cool.
<p_l>
nirved: the people involved never encountered Genera
<aeth>
Does running code in org-mode get you in an indeterminate state a lot of the time, too? I've never actually run code snippits in org-mode before, I just have them there.
<p_l>
aeth: Org-Mode has clear ways to get into determinate state even if you can break it
<aeth>
<sTAB
<aeth>
I do that so often in org-mode and I've never executed that code
<jmercouris>
So the thing that differentiates literate and org-mode is the way code is actually run
<aeth>
In fact, it rarely is enough of a snippit to actually execute
<prumnopytis>
Hm? I found it works alright, it's just adding another technology in exchange for very little
<p_l>
most importantly, it's much harder to have circular effects by chance
<jmercouris>
basically each org mode snippet has to more or less stand on its own
<jmercouris>
whereas in jupyter, its like a long program with giant comments in between, and state is often shared between snippets
<p_l>
you can use sessions, but they are explicit
<jmercouris>
I'm not saying it is impossible to do in org, just laborious as compared to jupter
<p_l>
yeah
<jmercouris>
jupyter*
<aeth>
jmercouris: ah, so org doesn't share state implicitly
<jmercouris>
not usually, no
<prumnopytis>
I kind of think that's an advantage
<prumnopytis>
But I am arguing against using org-mode, not for it sorry ;p
<aeth>
I don't think Jupyter is necessarily a bad thing, I just think that to do it right it should basically just be a presentation layer. Graphs and charts and stuff. Anything non-trivial clearly (imo) doesn't belong in it.
<aeth>
Honestly, I kinda want to plug it into CL and use it for some graphs. But only graphs.
<jmercouris>
think of Jupyter as a story telling tool
<jmercouris>
You could definitely pipe things from CL into gnuplot and have them show up in org mode
<didi>
I do it with graphviz. It's nice.
<prumnopytis>
aeth: in my experience, I have vastly preferred org-mode and still use it for showing-other-people-things, and I have (had to) use both variously
<aeth>
didi: Thanks for reminding me that I need to write my own .dot generator in CL.
<prumnopytis>
There's already a kind of fine one or couple, I think.
<didi>
aeth: Everyone should. ;-)
<aeth>
prumnopytis: org-mode is good for my own things, but it's not good for things that I share with other people. You can't really beat a web browser (or a LaTeX-generated PDF if non-interactive) for that.
<jmercouris>
aeth: someone made jupyter like notebooks for next
<prumnopytis>
Jumping around places, trivially executing stuff live and having pictures pop up, dumb elisp automating of step by step processes - I found this worked well for me for presentations. I wouldn't use it for programming, in the way someone might try and use jupyter notebooks for Apache Spark.
LiamH has quit [Quit: Leaving.]
longshi has joined #lisp
<didi>
nirved: An answer for (setf (subseq () 42) '(1 2 3)): nothing changes at (), because (subseq () 42) => () is shorter than '(1 2 3).
<didi>
As in `substitute'.
<didi>
Eer, not `substitute', but another function that I'm not remembering right now.
<didi>
`replace'.
vaporatorius has quit [Quit: Leaving]
vaporatorius has joined #lisp
vaporatorius has joined #lisp
vaporatorius has quit [Changing host]
<p_l>
there's cl support for jupyter, made by people behind Clasp
ealfonso has joined #lisp
<jmercouris>
so, dr meister?
<ealfonso>
is there a way to list only "orphaned" commits not contained in any branch? is there a way to run git gc in --dry-run mode?
<ealfonso>
oops
<ealfonso>
wrong channel, sorry
<prumnopytis>
git prune?
reg32 has quit [Remote host closed the connection]
<p_l>
jmercouris: yep
bitmapper has joined #lisp
jmercouris has quit [Remote host closed the connection]
<fiddlerwoaroof_>
Xach: I'm getting a lot of timeouts from quicklis
<p_l>
hmm, that's on S3 with CDN enabled, it shouldn't fail that bad
<fiddlerwoaroof_>
(although, I'm no longer able to reproduce, maybe it was a AWS hiccup)
EvW has quit [Ping timeout: 260 seconds]
ealfonso has quit [Ping timeout: 240 seconds]
<aeth>
drmeister: people are talking about you here as "dr meister" so you didn't get pinged.
<drmeister>
I prefer Mister Professor Schafmeister. That's what I tell my daughter's boyfriend.
<drmeister>
aeth: Thank you by the way. What's up? Reading...
<p_l>
drmeister: is professor a rank assigned directly to you or to position you hold? Asking out of curiosity, I've encountered both systems
<aeth>
drmeister: mostly a discussion of jupyter notebooks and org-mode
<drmeister>
What's 'next' in "someone made jupyter like notebooks for next" ?
brown121407 has quit [Read error: Connection reset by peer]
<aeth>
p_l: personally, I just assume everyone with a PhD in academia uses the title 'professor' because if they're not a professor then it's flattery, but if they are and I don't say so then it's insulting.
<p_l>
I supect it meant next-browser?
<p_l>
aeth: it can have *legal* meaning in places
<drmeister>
Yes - what is the next-browser?
brown121407 has joined #lisp
<prumnopytis>
aeth: that's not right in most places, is it?
<drmeister>
Googling.
<aeth>
prumnopytis: no, it's not. I think 'professor' is usually a rank that's earned
<p_l>
drmeister: ah, next-browser is webkit wrapped in CL with CL api and CL doing GUI other than the webkit render
<p_l>
aeth: in Poland you have "extraordinary" and "ordinary" professor, and the latter is legally protected title that involves officially getting it from the president of Poland
<aeth>
p_l: I think in the US, the lower rank is usually something like 'associate professor'
<p_l>
"extraordinary" is valid only within one university that gave you that title and the extraordinary refers to the fact that you're not "ordinarily" considered one
<drmeister>
Professor is a rank that one earns. You start out as an "Assistant Professor" when you get a faculty position in a University and then go through a process to become "Associate Professor" and then another to become "Full Professor". "Professor" is used to describe all three stages.
<Shinmera>
in German we use "ordentlich" (proper) for that designation.
<p_l>
you also need to have a doctorate with an extra called "habilitation" before you're considered for professor in Poland
Kevslinger has quit [Quit: Connection closed for inactivity]
ym has joined #lisp
Oladon has quit [Quit: Leaving.]
cosimone has quit [Quit: Quit.]
didi has quit [Remote host closed the connection]
vidak` has quit [Ping timeout: 258 seconds]
oxum has quit [Remote host closed the connection]
vidak` has joined #lisp
fortitude has joined #lisp
wxie has joined #lisp
quazimodo has joined #lisp
random-nick has quit [Ping timeout: 260 seconds]
oni-on-ion has quit [Ping timeout: 248 seconds]
jealousmonk has joined #lisp
Jeanne-Kamikaze has quit [Remote host closed the connection]