<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
akoana has joined #lisp
<Josh_2>
Is there a way to get ecl to compile for a different platform than the one being developed on?
ntqz has quit []
libertyprime has joined #lisp
Oladon has joined #lisp
lxbarbosa has quit [Remote host closed the connection]
bitmappe_ has quit [Ping timeout: 240 seconds]
Josh_2 has quit [Ping timeout: 240 seconds]
lxbarbosa has joined #lisp
khisanth_ has quit [Ping timeout: 240 seconds]
trocado has quit [Read error: Connection reset by peer]
semz has quit [Ping timeout: 264 seconds]
khisanth_ has joined #lisp
libertyprime has quit [Ping timeout: 245 seconds]
libertyprime has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
techquila has joined #lisp
pjb` has joined #lisp
pjb` has quit [Remote host closed the connection]
mindthelion has quit [Ping timeout: 240 seconds]
pjb` has joined #lisp
pjb` has quit [Remote host closed the connection]
pjb` has joined #lisp
pjb is now known as Guest57288
pjb` has quit [Client Quit]
Guest57288 has quit [Ping timeout: 276 seconds]
pjb` has joined #lisp
pjb` has quit [Remote host closed the connection]
pjb` has joined #lisp
libertyprime has quit [Ping timeout: 245 seconds]
pjb` has quit [Client Quit]
frgo has quit [Remote host closed the connection]
ogamita has joined #lisp
frgo has joined #lisp
ogamita has quit [Remote host closed the connection]
pjb has joined #lisp
libertyprime has joined #lisp
karlosz has joined #lisp
toorevitimirp has joined #lisp
toorevitimirp has quit [Ping timeout: 265 seconds]
orivej has joined #lisp
libertyprime has quit [Ping timeout: 240 seconds]
slyrus has joined #lisp
libertyprime has joined #lisp
<beach>
Good morning everyone!
slyrus_ has quit [Ping timeout: 276 seconds]
libertyprime has quit [Ping timeout: 240 seconds]
libertyprime has joined #lisp
jeosol94 has joined #lisp
<LdBeth>
Hello beach
asarch has joined #lisp
<asarch>
One very very very stupid question: as you know, you can "dump" the current core actually runnin in SBCL into an "executable" file, so, is there any way to "strip" this new core file in order that it could only have the essential to work?
<beach>
asarch: The problem is in the definition of "essential".
<asarch>
Bingo!
<asarch>
That's the reason of my question
<beach>
Unfortunately, only you, the end user, knows what is essential.
<LdBeth>
Like most lisps SBCL has to parts: lisp kernel and heap image
<LdBeth>
The heap image is the “essential”
<LdBeth>
And the kernel can be reused
<asarch>
It happens I am learning Assembly Language and I was wondering what would be the "essential" of a binary file of SBCL, the smallest thing possible so a binary could work
<White_Flame>
I believe the term "tree shaker" relates to trimming down an image to only what's directly referenced. some other lisps have that
<asarch>
Kernel?
<White_Flame>
( or some other CL implementations)
<LdBeth>
If you’re talking about making a minimal distribution of your app, then just ignore what I’ve said and contacts people at LispWorks
<White_Flame>
the only thing a binary needs is a main that immediately exist and doesn't do anything
<White_Flame>
*exits
<White_Flame>
as far as the OS considers it to be runnable
<LdBeth>
White_Flame: you can no op and the OS will segfault your program :)
<mfiano2>
Hi everyone. If anyone is interested, I recently launched a Mattermost instance at https://chat.lisp.cl to provide a free chat platform for Lisp developers, due to some concerns some people had about IRC and Discord where most of the live discussions reside. Anyone is free to join and use it as they wish (for example, you can create and manage your own team and sets of channels for collaborative works), or just use the default one.
asarch has quit [Remote host closed the connection]
<Ober>
free?
<no-defun-allowed>
Should do.
<no-defun-allowed>
Hm, mlep seems to be incapable of creating Markov chains with somewhat large sizes (926 symbols, order 3) because it uses an array which is huge but sparse. Are there any libraries for sparse arrays I could hack in?
<beach>
You can try using a hash table.
<no-defun-allowed>
I suppose I could.
nullniverse has joined #lisp
nullniverse has quit [Changing host]
nullniverse has joined #lisp
karlosz has quit [Quit: karlosz]
mindthelion has joined #lisp
<no-defun-allowed>
Oh, it uses displacement too. Still possible though to replace.
<no-defun-allowed>
Pretty sure s-l-a-d performs a GC before it dumps, too.
libertyprime has quit [Ping timeout: 240 seconds]
libertyprime has joined #lisp
<beach>
It probably won't address the question that asarch had anyway.
<no-defun-allowed>
Well, the "essential" of a Common Lisp implementation is a bit fuzzy to me. There are legitimate uses for the compiler at runtime (COMPILE) and it may or may not be useful to keep debugging information around.
dddddd has quit [Remote host closed the connection]
<beach>
Exactly.
<aeth>
It's a hard problem that will eventually be solved, but probably only after there are enough applications first
<no-defun-allowed>
(I think I got this from LiSP) And it is not trivial to determine whether some code will use these features or not. I can compile with (funcall (find-symbol (read-from-string)) nil '(lambda ...)) for example, but it is not likely the tree shaker would know that.
<no-defun-allowed>
read-from-string -> read-line
<aeth>
I think resource sharing in a desktop environment where you could have half a dozen running CL applications is more important than treeshaking to make one binary smaller.
<no-defun-allowed>
If you pick a subset of CL to run with, that would work, but then you limit the libraries you can use.
<aeth>
Well, yeah, what you'd probably have is a situation where you need to use a subset or else essentially nothing gets treeshaken
<beach>
no-defun-allowed: It is known as an "undecidable" problem.
<no-defun-allowed>
That's the word, thanks.
<beach>
So it won't ever be "solved".
<aeth>
beach: Well, it could simply disable the treeshaker when certain things like read-from-string are used.
<aeth>
assuming the list isn't too long
<no-defun-allowed>
I recall talk on #sicl about someone who was deciding what to put in a subset of CL called CL-R -- maybe that is useful.
libertyprime has quit [Ping timeout: 245 seconds]
<aeth>
no-defun-allowed: well, a subset is more of a whitelist than a blacklist, you'd ideally want the latter in a treeshaker
ebzzry has quit [Ping timeout: 268 seconds]
<aeth>
although idk maybe there's something that makes it impossible
<pjb>
beach: no, but it's the best that can be done with the existing.
<pjb>
also, we could add a (mapc 'delete-package (copy-list (list-all-packages))) before the gc, if we keep a reference to the main function.
ggole has joined #lisp
libertyprime has joined #lisp
vlatkoB has joined #lisp
hiroaki has quit [Ping timeout: 240 seconds]
superkumasan has quit [Ping timeout: 240 seconds]
|3b| has quit [Remote host closed the connection]
dale has quit [Quit: My computer has gone to sleep]
v0|d has quit [Ping timeout: 276 seconds]
gravicappa has joined #lisp
Fare has joined #lisp
lemoinem has quit [Ping timeout: 240 seconds]
lemoinem has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
sauvin has joined #lisp
DGASAU has joined #lisp
rixard has joined #lisp
libertyprime has quit [Ping timeout: 264 seconds]
duuqnd has quit [Ping timeout: 240 seconds]
zaquest has quit [Quit: Leaving]
ebzzry has joined #lisp
JohnMS_WORK has joined #lisp
Fare has quit [Ping timeout: 245 seconds]
zaquest has joined #lisp
makomo has quit [Ping timeout: 265 seconds]
varjag has joined #lisp
igemnace has joined #lisp
PuercoPope has joined #lisp
raghavgururajan has quit [Remote host closed the connection]
exit70 has joined #lisp
shrdlu68 has joined #lisp
raghavgururajan has joined #lisp
superkumasan has joined #lisp
DGASAU has quit [Ping timeout: 240 seconds]
DGASAU has joined #lisp
exit70 has quit [Remote host closed the connection]
schweers has joined #lisp
vlatkoB_ has joined #lisp
vlatkoB has quit [Ping timeout: 246 seconds]
elderK has joined #lisp
jprajzne has joined #lisp
<thijso>
minion memo for Josh_2: Yes, you can cross compile for a different target with ECL. Take a look at the examples in ecl, EQL and/or EQL5-android. Or my work in progress: https://github.com/thijs/android-ecl-bootstrap which builds arm64 Android apps on amd64 (or whatever) Ubuntu
<thijso>
hmmm... minion memo doesn't work like that?
enrio has joined #lisp
Codaraxis__ has joined #lisp
Codaraxis_ has quit [Ping timeout: 265 seconds]
<jackdaniel>
minion: memo for thijso: you forgot the colon
<minion>
Remembered. I'll tell thijso when he/she/it next speaks.
<jackdaniel>
thijso: ^
<thijso>
Ah, thanks, jackdaniel
<minion>
thijso, memo from jackdaniel: you forgot the colon
<thijso>
minion: memo for Josh_2: Yes, you can cross compile for a different target with ECL. Take a look at the examples in ecl, EQL and/or EQL5-android. Or my work in progress: https://github.com/thijs/android-ecl-bootstrap which builds arm64 Android apps on amd64 (or whatever) Ubuntu
<minion>
Remembered. I'll tell Josh_2 when he/she/it next speaks.
flazh has quit [Quit: flazh]
flazh has joined #lisp
akoana has left #lisp ["Leaving"]
lemoinem has quit [Ping timeout: 250 seconds]
lemoinem has joined #lisp
hhdave has joined #lisp
sarna has joined #lisp
scymtym has joined #lisp
gareppa has joined #lisp
igemnace has quit [Ping timeout: 276 seconds]
gareppa has quit [Remote host closed the connection]
gareppa has joined #lisp
gareppa has quit [Quit: Leaving]
gareppa has joined #lisp
igemnace has joined #lisp
ljavorsk has joined #lisp
gareppa has quit [Quit: Leaving]
gareppa has joined #lisp
Cymew has quit [Read error: Connection reset by peer]
Cymew has joined #lisp
dilated_dinosaur has quit [Remote host closed the connection]
zymurgy has quit [Quit: WeeChat 1.4]
rixard has quit [Quit: A fine is a tax for doing wrong. A tax is a fine for doing well.]
jonatack has quit [Ping timeout: 264 seconds]
rixard has joined #lisp
datajerk has quit [Ping timeout: 240 seconds]
datajerk has joined #lisp
ym has joined #lisp
mingus has joined #lisp
<mingus>
join #clim
gareppa has quit [Quit: Leaving]
ym has quit [Ping timeout: 252 seconds]
shrdlu68 has quit [Read error: No route to host]
Codaraxis_ has joined #lisp
superkumasan has quit [Ping timeout: 252 seconds]
gravicappa has quit [Ping timeout: 265 seconds]
Codaraxis__ has quit [Ping timeout: 240 seconds]
superkumasan has joined #lisp
X-Scale` has joined #lisp
X-Scale has quit [Ping timeout: 240 seconds]
jonatack has joined #lisp
X-Scale` is now known as X-Scale
varjagg has joined #lisp
varjag has quit [Remote host closed the connection]
sarna has quit [Ping timeout: 240 seconds]
gxt has quit [Ping timeout: 260 seconds]
amerlyq has joined #lisp
varjagg has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
cosimone has joined #lisp
Necktwi has joined #lisp
orivej has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
gxt has joined #lisp
bitmapper has joined #lisp
<lxbarbosa>
boy, why are most languages so "minimal" in conditionals... no: when, unless, when-if, cond...
<lxbarbosa>
at most a if-else and a switch
<bitmapper>
i find that's generally just C family languages
Necktwi has quit [Remote host closed the connection]
mingus has quit [Remote host closed the connection]
jgkamat has quit [Ping timeout: 240 seconds]
Fare has joined #lisp
<lxbarbosa>
bitmapper: most languages are c-like...
<bitmapper>
not really
<bitmapper>
there's so many non algol family languages out there
<lxbarbosa>
yeah, and most projects just ignore those :D
<bitmapper>
never really stopped me
t3rtius has joined #lisp
<lxbarbosa>
what are those languages? can't remind
<bitmapper>
ocaml, haskell, standard ml, (lisp, of course), idris, Shen, etc
<ggole>
Prolog
<Shinmera>
[your obscure language here]
<bitmapper>
ocaml and haskell aren't really obscure
Fare has quit [Ping timeout: 265 seconds]
<Shinmera>
good thing I didn't say so then
<flip214>
what's "when-if"? I know WHEN and IF, but as one (language) keyword?
<flip214>
lxbarbosa: IF-ELSE is enough to build all others (which becomes much easier if you have macros, of course ;)
<bitmapper>
i mean, lambda is enough to build all the others ;)
<lxbarbosa>
flip214: indeed, still, all those "if" are so cryptic.
<lxbarbosa>
while on lisp, its easier to know what it is doing...
<flip214>
bitmapper: LAMBDA won't give you an conditional
<bitmapper>
i mean, you can though
<Shinmera>
flip214: it does by way of apply and optional arg.
<Shinmera>
err wait, that won't work right, nevermind
gareppa has joined #lisp
<flip214>
Shinmera: you can get by via a conditional move (CMOV), but that's a conditional in the CPU
<flip214>
wait, there was a transpiler using only MOVs as well... how did that work for conditionals, again?
gareppa has quit [Remote host closed the connection]
<_death>
you can represent a boolean as two functions.. so (> 1 2) would return the function that chooses the false function and (< 1 2) would return the function that chooses the true function
jonatack has quit [Read error: Connection reset by peer]
warweasle has joined #lisp
enrioog has joined #lisp
rixard has joined #lisp
enrio has quit [Ping timeout: 276 seconds]
dddddd has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
Hofpfister has quit [Ping timeout: 246 seconds]
Fare has quit [Ping timeout: 265 seconds]
DGASAU has joined #lisp
Hofpfister has joined #lisp
flubberhead has quit [Ping timeout: 240 seconds]
Kevslinger has joined #lisp
retropikzel has joined #lisp
clothespin has quit [Ping timeout: 245 seconds]
rixard has quit [Remote host closed the connection]
zxcvz has joined #lisp
rixard has joined #lisp
rixard has quit [Ping timeout: 240 seconds]
cosimone has joined #lisp
Fare has joined #lisp
scymtym has quit [Ping timeout: 245 seconds]
EvW has quit [Ping timeout: 264 seconds]
jprajzne has quit [Quit: Leaving.]
nadare has quit [Ping timeout: 264 seconds]
nadare has joined #lisp
dale_ has joined #lisp
dale_ is now known as dale
bitmapper has quit [Ping timeout: 268 seconds]
pfdietz has joined #lisp
gareppa has joined #lisp
Fare has quit [Ping timeout: 265 seconds]
Fare has joined #lisp
makomo has joined #lisp
cosimone has quit [Quit: Terminated!]
rixard has joined #lisp
cosimone has joined #lisp
igemnace has quit [Ping timeout: 246 seconds]
Fare has quit [Ping timeout: 264 seconds]
rixard has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 268 seconds]
smazga has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
Hofpfister has quit [Ping timeout: 264 seconds]
FreeBirdLjj has joined #lisp
ljavorsk has quit [Ping timeout: 246 seconds]
schweers has quit [Ping timeout: 245 seconds]
bitmapper has joined #lisp
sjl_ has quit [Ping timeout: 264 seconds]
gravicappa has joined #lisp
rixard has joined #lisp
bitmapper has quit [Read error: Connection reset by peer]
rixard has quit [Ping timeout: 268 seconds]
bitmapper has joined #lisp
raghavgururajan has quit [Read error: Connection reset by peer]
shifty has quit [Ping timeout: 268 seconds]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
stepnem has quit [Ping timeout: 264 seconds]
stepnem_ has joined #lisp
gareppa has quit [Quit: Leaving]
Inline has joined #lisp
EvW has joined #lisp
shka_ has joined #lisp
t3rtius has quit [Quit: ERC has quit.]
rippa has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
clothespin has joined #lisp
sjl_ has joined #lisp
rixard has joined #lisp
FreeBirdLjj has quit [Ping timeout: 250 seconds]
anewuser has joined #lisp
xuxuru has joined #lisp
enrioog has quit [Ping timeout: 240 seconds]
<thijso>
Does anybody have any pointers for me where to start looking when I get the error: C-INLINE: Variable code exceeds number of arguments ??
<thijso>
This is indeed a function that does (c-inline ...), but looking at my code (and examples of other working code already there) I don't really see what the error could be...
slyrus_ has joined #lisp
<Shinmera>
sounds like very specifically ECL stuff
slyrus has quit [Ping timeout: 240 seconds]
hhdave has quit [Quit: hhdave]
gareppa has joined #lisp
skidd0 has joined #lisp
enrio has joined #lisp
cosimone has quit [Quit: Terminated!]
jonatack has joined #lisp
gxt has quit [Ping timeout: 260 seconds]
sjl_ has quit [Ping timeout: 250 seconds]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
varjag has joined #lisp
<thijso>
Yeah, it's ECL... I'll ask there
nowhere_man has joined #lisp
Lycurgus has quit [Quit: Exeunt]
ggole has quit [Remote host closed the connection]
Lycurgus has joined #lisp
ggole has joined #lisp
v0|d has joined #lisp
slyrus__ has joined #lisp
stepnem_ has quit [Read error: Connection reset by peer]
stepnem has joined #lisp
slyrus_ has quit [Ping timeout: 240 seconds]
LiamH has quit [Ping timeout: 265 seconds]
_paul0 has quit [Read error: Connection reset by peer]
<markasoftware>
How is (set) a function and not a macro? Won't its argument evaluate to its value?
<markasoftware>
eg, (setq foo "bar") followed by (set foo "lipsum") ... doesn't the second one simplify to (set "bar" "lipsum") ?
<Xach>
markasoftware: yes. which is invalid.
_paul0 has joined #lisp
<Xach>
markasoftware: the first argument must evaluate to a symbol, not a string.
<markasoftware>
oh, so (set 'foo "lipsum") is correct?
<markasoftware>
thanks!
<Xach>
markasoftware: yes
slyrus_ has joined #lisp
gabiruh has joined #lisp
slyrus__ has quit [Ping timeout: 268 seconds]
xuxuru has quit [Quit: xuxuru]
LiamH has joined #lisp
cosimone has joined #lisp
gravicappa has quit [Ping timeout: 240 seconds]
Lycurgus has quit [Quit: Exeunt]
superkumasan has quit [Ping timeout: 265 seconds]
anewuser has quit [Quit: anewuser]
gravicappa has joined #lisp
cosimone has quit [Quit: Terminated!]
gareppa has quit [Quit: Leaving]
<_death>
also note that defvar/defparameter usefully return the variable name, so if you got the value wrong, you can (set * new-form)
dongcarl has joined #lisp
makomo has quit [Ping timeout: 240 seconds]
<Xach>
I don't think I've ever used set in a real thing.
<_death>
Naggum lamented that SETF wasn't renamed SET.. cost of backwards compatibility
hiroaki has joined #lisp
Codaraxis has joined #lisp
Codaraxis__ has quit [Ping timeout: 268 seconds]
Codaraxis_ has joined #lisp
superkumasan has joined #lisp
Codaraxis has quit [Ping timeout: 265 seconds]
nowhere_man has quit [Ping timeout: 264 seconds]
enrio has quit [Ping timeout: 246 seconds]
vhost- has quit [Quit: WeeChat 2.6]
sjl_ has joined #lisp
cosimone has joined #lisp
vhost- has joined #lisp
vhost- has quit [Changing host]
vhost- has joined #lisp
vh0st- has joined #lisp
vhost- has quit [Read error: Connection reset by peer]
vh0st- has quit [Read error: Connection reset by peer]
vhost- has joined #lisp
vhost- has joined #lisp
vhost- has quit [Changing host]
<pjb>
markasoftware: (set 'foo x) = set quote foo x = (setq foo x)
<pjb>
a place is a form, so set form (car x) y) = (setf (car x) y)
<pjb>
notice that (setf foo x) is compiled as (setq foo x), and if foo is a symbol macro, (setq foo x) is compiled as (setf the-expansion-of-foo x).
<pjb>
also, it's nice that set is a function: (mapc 'set '(*a* *b* *c*) '
<pjb>
(1 2 3))
sauvin has quit [Read error: Connection reset by peer]
<_death>
there also used to be a SETQQ operator.. so you could (setqq foo bar) instead of (setq foo 'bar)
bitmapper has quit [Remote host closed the connection]
bitmapper has joined #lisp
<fe[nl]ix>
also SETQCAR so you could (setqcar foo bar) instead of (setq foo (car bar))
<fe[nl]ix>
and so on
<Xach>
no
<_death>
guessing that was a joke :).. but setqq was real
<pjb>
_death: indeed, setqcar is rplaca
vlatkoB_ has quit [Remote host closed the connection]
<_death>
pjb: that would be setcar (elisp)
<_death>
setqq was in BBN Lisp.. which also had PROG2 take only two forms, and described PROGN as an extension to it...
dnn2da11 has joined #lisp
dnn2da11 has left #lisp [#lisp]
gabiruh has quit [Quit: ZNC - 1.6.0 - http://znc.in]
orivej has joined #lisp
gabiruh has joined #lisp
akkad has joined #lisp
igemnace has joined #lisp
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
EvW has quit [Ping timeout: 250 seconds]
cosimone has quit [Quit: Terminated!]
matijja has joined #lisp
bitmapper has quit [Ping timeout: 265 seconds]
retropikzel has quit [Remote host closed the connection]
smazga has quit [Ping timeout: 276 seconds]
smazga has joined #lisp
<aeth>
set might be taken, but set! is still available as a name
EvW1 has joined #lisp
flubberhead has joined #lisp
flubberhead has quit [Remote host closed the connection]
gxt has joined #lisp
Codaraxis_ has quit [Ping timeout: 245 seconds]
scymtym has joined #lisp
gxt has quit [Ping timeout: 260 seconds]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
cosimone has joined #lisp
lxbarbosa has joined #lisp
gravicappa has quit [Ping timeout: 240 seconds]
synaps3 has joined #lisp
<matijja>
Hello!
cosimone has quit [Quit: Quit.]
<matijja>
Is there any way to redirect *query-io* into a file? (in bash script)
cosimone has joined #lisp
<phoe>
matijja: you want to read input from a file or output queries into a file? *QUERY-IO* is a bidirectional stream
shka_ has quit [Ping timeout: 264 seconds]
<matijja>
I want redirect *query-io* output into a file. Like this: sbcl --eval '(format *query-io* "foo")' &> /tmp/foo
<matijja>
With which descriptor is represented *query-io*? I know stdout and stderr, but never heard for "queryout"...
<phoe>
matijja: none, *query-io* has no unix analog
<phoe>
analogue*
<phoe>
you will need to create a new bidirectional stream that dumps output into a file and bind *query-io* to it
<matijja>
I dont understand, how text written in *query-io* come into my terminal which works in unix way.
<phoe>
if you run your Lisp implementation in a terminal, then
<phoe>
the Lisp implementation binds it to either stdout or stderr
<phoe>
but the value of query-io can be any bidirectional Lisp stream in general.
<p_l>
*query-io* is linked to standard output, because unix has no query channel
<p_l>
but some systems *do* have one
<matijja>
Yes. And I want redirect both (stdout and stderr) into a file. But doesn't works. Is there any other unix descriptor in unix?
<scymtym>
if SBCL is running in a terminal (emulator), *QUERY-IO* is connected to the (pseudo) terminal device. that's why it is not affected by the redirection
<p_l>
you can also rebind it in code
<matijja>
So, it writes directly to /dev/tty* device.
zotan has quit [Quit: ZNC 1.6.5+deb1+deb9u2 - http://znc.in]
<aeth>
Oh, unrelated mystery solved. So I launch applications from a terminal and some of them are very poorly written so I &> /dev/null instead of > /dev/null to capture stderr. But one of them is so poorly written that even that sometimes doesn't work. I guess that's why.
<matijja>
p_l: Do you know any system which have query channel?
<aeth>
I think that might be all you need. heh. Written in Python.
<_death>
the cool thing about deepspeech is that they released the model (2 gigs.. the initial version at least)
Fare has joined #lisp
<_death>
this mycroft page has it in collaborations.. so maybe it uses their model
<_death>
ah, there's a Data section
<aeth>
There's nothing stopping a Common Lisp initiative in this area.
<_death>
if CL had an open state-of-the-art NLP package..
matijja has quit [Ping timeout: 252 seconds]
<p_l>
a lot of the work isn't in NLP, or at least speech processing doesn't really fall there
<_death>
sure.. I suppose everything is nowadays reduced to neural network weights
<p_l>
I mean that speech processing doesn't really do much to understand the language, it's the next layer that does
<p_l>
and even then it's not really necessary to have very complex one
<p_l>
n.b. the first version of Google Translate had, afaik, no NLP except basic ngram generation
cosimone has quit [Quit: Quit.]
cosimone has joined #lisp
<_death>
yeah.. and if the domain is constrained it's also easy (I'm reminded of that CD track selection parser in PAIP)
<p_l>
_death: PAIP had a parser for elementary school level math assignments
<_death>
the ngram stuff is just feature engineering
<_death>
p_l: yeah, STUDENT.. but that was mostly simple pattern matching
<_death>
the CD track selection defined a grammar
smazga has quit [Quit: leaving]
<_death>
a python gensim library for CL could be cool.. I'm guessing grammarly, ravenpack etc. have tons of stuff like that.. proprietary
<p_l>
quite probable
<p_l>
also, for anyone interested in using TensorFlow from CL - the C api is pretty simple, but is directed only at *running* models, not creating them. And interfacing with the C++ API... I actually haven't managed to make it link with C++ code yet
<_death>
recently they killed keras.. and now it's tf.keras.. I was reminded of the old lispm jokes.. As of next Tuesday, KERAS will be replaced by TF.KERAS. Please update your programs.
<no-defun-allowed>
Welcome to Python-land.
<no-defun-allowed>
aeth: I have "an OpenCL backend for Petalisp" on my to-do list, which is probably an important component of artificial guesswork systems.
<no-defun-allowed>
*artificial gut-feeling is the technical term, sorry.
amerlyq has quit [Quit: amerlyq]
bitmapper has joined #lisp
<no-defun-allowed>
But I also have "don't fail exams" and other things on that list, which has set me back a bit.
Codaraxis has joined #lisp
<no-defun-allowed>
Then, looking at the Keras documentation, it shouldn't be hard to recreate the layers and all that.
<no-defun-allowed>
Quite a few boil down to (α #'some-function the-last-layer).
<aeth>
no-defun-allowed: well, I'm going to be writing a to-SPIRV compiler with Vulkan shaders in mind at some point (maybe 3 years from now?) but I think OpenCL uses SPIRV now, too...
<no-defun-allowed>
I'm too stupid, I just use oclcl and some templates to compile Petalisp IR.
cosimone has quit [Quit: Quit.]
<aeth>
Well, my approach is probably very different than most for GPU compute so I think I can get something done in a reasonable amount of time. I wouldn't mind directly coding in essentially just an IR, leaving a more Lispy language as someone else's problem to figure out.
<aeth>
And I haven't looked into it yet, but afaik, just the way GPU APIs work, the best you can kind of do is a statically typed language with type inference (i.e. no need for type declarations most of the time), rather than a truly dynamically typed language, so no matter what you're going to get some different code on CPU vs. on GPU.
<no-defun-allowed>
Yeah, running arbitrary CL functions on the GPU is going to be annoying. I'm just sticking to floats for now.
<no-defun-allowed>
And, well, functions that only have number functions, LET and DO pretty much.
<aeth>
I mean, you could probably find a way to get a "true" Lisp (maybe not a full CL) on a GPU, but why?
<aeth>
There's only a very limited set of things that make sense to do efficiently on one.
<aeth>
And personally, I don't care about having the code look identically on both CPU and GPU because the platforms are very different, so there'd have to be too much magic and potential inefficiency on one of the two
<p_l>
you might get a reasonable *Lisp on one
<no-defun-allowed>
Indeed. And those are usually things with floats and mapping (α) and reduction (β)
<p_l>
and of course, it's kinda the same thing as using the DSP package on TI Explorer;)
<aeth>
p_l: I'm not sure about the details of *Lisp, but it's possible that a high-end CPU is a better fit for the semantics of a highly-parallel Lisp like that, especially since you can get 64+64 cores this year for servers (or 64 cores in HEDT, perhaps early next year) from AMD
<aeth>
GPUs are a very specific kind of parallel
<aeth>
although I mostly know the graphics pipeline, so idk how much has been turned into general purpose with GPGPU compute
<p_l>
aeth: *Lisp ran on similar kind of parallel - very dumb "processors" running in arrays
<aeth>
Makes sense, then. Linear algebra isn't new.
<aeth>
We are kind of in an era where applying linear algebra is the hottest thing, though.
<LdBeth>
aeth: star lisp views tensor as a special data structure that can be operated within lisp
<p_l>
aeth: more "throwing data at randomly wired neural network" and using resulting predictive algorithm, without considering what data went in
<p_l>
I've heard of targeting algorithms that were ridiculously untrained on negative results
<aeth>
p_l: no, it's not just ML... pretty much every hot field (e.g. graphics) is all about applied linear algebra... and it's mostly because of GPGPU, but also almost every "recent" extension to CPUs (e.g. AVX) is similar in scope, too.
<aeth>
(I mean, everything but the web, I guess... but even in the web you have WebGL etc.)
<p_l>
aeth: graphics were always linear algebra heavy. Can't call it "new" when it's what, 40 years by now?
<p_l>
and vector extensions on CPUs go back to 1960s
<aeth>
p_l: nothing is really new if you go back far enough... but things come and go and right now applied linear algebra in general is very hot
<aeth>
I guess combined with statistics.
<p_l>
having them in small form factor isn't new either, it's just that it's pretty easy way to put more speed by requiring explicit parallel code at instruction level
<p_l>
we have a case of glut of data and people wanting to use it
<p_l>
GDPR started to make it slightly different
Codaraxis has quit [Ping timeout: 240 seconds]
<p_l>
by turning certain kinds of data into radioactive waste
<aeth>
p_l: On the whole explicit parallel thing... it's just that in the 80s and early 90s, you only went ultra-parallel for supercomputers. Now everyone has hit that wall that supercomputers hit earlier.
<p_l>
aeth: vector extensions on desktop CPUs are mid 1990s, with important source of the push being MPEG-1/2 encoding/decoding
<p_l>
el-cheapo PCs are 1997 for vector units
<aeth>
p_l: and it's a trend that has continued, most recently with AVX-512 slowly entering the mainstream (not quite there yet... maybe in 3 years or so)
<p_l>
aeth: important function of AVX-512 is market segmentation
<aeth>
p_l: It's not that linear algebra hardware is new, it's that linear algebra hardware continues to improve, unlike the rest
<_death>
there's also the HPC community, which apparently is at a bit of disconnect from the "big data" communities.. there was, e.g., this rant https://www.dursi.ca/post/hpc-is-dying-and-mpi-is-killing-it.html .. that cray language Chapel took ideas from *Lisp.. maybe it's worth stealing some back
<aeth>
p_l: barring a revolutionary change, perhaps via a switch away from silicon, we're increasingly using what are basically just parallel linear algebra machines.
<p_l>
_death: a lot of "big data" is... much less capable than HPC community, thus the disconnect
<p_l>
also, "big data" has more in common with IBM SORT programming than anything else
<_death>
p_l: that link considers this.. it's written by an HPC guy
<p_l>
_death: yeah. And probably that's why he is a bit too competent to see how incompetent big data is ;)
<_death>
p_l: his conclusion is that both communities have something to learn
<p_l>
and ultimately he points at HPC-specific stuff (Chapel), and that certain succesful tools are things that make it harder to get better
<p_l>
which happens in big data too
<_death>
yeah.. but why isn't Chapel a Lisp?
EvW1 has quit [Ping timeout: 246 seconds]
<p_l>
because the people who are the target feel unsafe without FORTRAN
<_death>
I mean, it doesn't look like very much like Fortran or C..
<_death>
and for C there's that Unified Parallel C
<p_l>
_death: the gateway drug to other languages was Python because someone compiled all the not really understood fortran code into numpy
<_death>
I remember there are also some Lisp HPC guys
sjl_ has quit [Ping timeout: 276 seconds]
<_death>
there's also ftl :)
<_death>
may need an update for more recent fortran
<_death>
and then there are new libraries like MAGICL
clothespin_ has joined #lisp
lalakis has joined #lisp
lalakis has left #lisp [#lisp]
clothespin has quit [Ping timeout: 252 seconds]
clothespin_ has quit [Ping timeout: 264 seconds]
<skidd0>
is using an early return in a function a code smell
<LdBeth>
No
Codaraxis has joined #lisp
<skidd0>
thanks
synaps3 has quit [Remote host closed the connection]
|3b| has joined #lisp
varjag has quit [Ping timeout: 240 seconds]
kapitanfind-us has joined #lisp
kapitanfind-us has quit [Remote host closed the connection]
skidd0 has quit [Quit: WeeChat 2.6]
kapitanfind-us has joined #lisp
Codaraxis has quit [Ping timeout: 265 seconds]
khisanth_ has quit [Ping timeout: 240 seconds]
Codaraxis has joined #lisp
vaporatorius has quit [Read error: No route to host]
khisanth_ has joined #lisp
slyrus__ has joined #lisp
anewuser has joined #lisp
makomo has joined #lisp
slyrus_ has quit [Ping timeout: 268 seconds]
Finnfinn has quit [Quit: The humanity!]
lxbarbosa has quit [Ping timeout: 276 seconds]
Oladon has joined #lisp
flubberhead has joined #lisp
<mfiano2>
You might want to use an explicit RETURN-FROM depending on how it's going to be used. Returning from NIL is sometimes ambiguous when user code is involved
<flubberhead>
hello, I have written a small function for an assignment to print odd numbers less than the input in a triangle. Input needs to be an odd integer. I have tried to make test cases to cover even numbers, or strings and tat one works. However, my integer condition crashes the function instead of printing an error message. Here is a paste to the function: https://pastebin.com/L7cnKd4L