<aeth>
There are even some alternatives to curses, such as Lisp bindings to bearlibterminal when you can get away with using a pseudoterminal. https://github.com/sjl/cl-blt
fikka has quit [Ping timeout: 246 seconds]
skidd0 has quit [Quit: WeeChat 2.2]
bradcomp has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
<asarch>
Thank you!
<asarch>
Thank you very much :-)
fikka has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
anewuser has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 240 seconds]
ealfonso has quit [Disconnected by services]
ealfonso has joined #lisp
ealfonso has quit [Disconnected by services]
ealfonso has joined #lisp
ealfonso` has joined #lisp
ealfonso has quit [Disconnected by services]
ealfonso has joined #lisp
pierpa has quit [Quit: Page closed]
ealfonso has quit [Disconnected by services]
ealfonso has joined #lisp
ealfonso has quit [Disconnected by services]
Oladon has joined #lisp
bradcomp has joined #lisp
it3ration has quit [Remote host closed the connection]
<smokeink>
is there any way to configure the printer to encode functions into their symbol names when printing?
fikka has joined #lisp
caltelt_ has quit [Ping timeout: 246 seconds]
it3ration has quit [Ping timeout: 244 seconds]
gpiero has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 252 seconds]
Inline has quit [Quit: Leaving]
<smokeink>
I have a list that contains functions like #'+ , #'- , #'* , I want to readably print it into a file
<PuercoPop>
smokeink: if you want to print symbols that is ok, but those are not functions
<PuercoPop>
symbols are bound to function objects
<PuercoPop>
which are the things that are printed unreadably. Adn as far as I know it is not possible to print them readably in a portable manner
<PuercoPop>
You may be able to create a FASL with just the functions? What do you want to do? If you want a Job queue for example the symbols would suffice provided you load the application in the image that read and executes jobs from the Queue
<LdBeth>
you print '#'+
<LdBeth>
or just '(function +)
Copenhagen_Bram has quit [Ping timeout: 246 seconds]
Copenhagen_Bram has joined #lisp
<no-defun-allowed>
apparently oclcl does run on my gpu okay
vlatkoB has joined #lisp
<smokeink>
Then I'll just switch to using '+ '- etc in my list , instead of #'+ #'-
<smokeink>
thanks
fikka has joined #lisp
umpc has quit [Ping timeout: 260 seconds]
gendl has quit [Ping timeout: 260 seconds]
Duns_Scrotus has quit [Ping timeout: 260 seconds]
les` has joined #lisp
beaky1 has joined #lisp
swflint has quit [Ping timeout: 260 seconds]
otwieracz has quit [Ping timeout: 260 seconds]
les has quit [Ping timeout: 260 seconds]
gingerale has quit [Ping timeout: 260 seconds]
beaky has quit [Ping timeout: 260 seconds]
lieven has quit [Ping timeout: 260 seconds]
swflint has joined #lisp
umpc has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
<flip214>
Xach: AeroNotix: re QL dist-update: I did this and re-ran the (ql:quickload ...) lines:
<flip214>
this way all the "old" systems are removed, so the next QL:QL needs to download the "new".
fikka has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
fikka has joined #lisp
beach has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
kristof has quit [Ping timeout: 240 seconds]
Copenhagen_Bram has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
scymtym has quit [Ping timeout: 240 seconds]
beaky1 is now known as beaky
fikka has quit [Ping timeout: 260 seconds]
pchrist has joined #lisp
fikka has joined #lisp
shrdlu68 has joined #lisp
Copenhagen_Bram has joined #lisp
dented42 has joined #lisp
orivej has joined #lisp
Lycurgus has quit [Quit: Exeunt]
rumbler31 has joined #lisp
cyraxjoe has joined #lisp
doubledup has joined #lisp
doubledup has quit [Client Quit]
rumbler31 has quit [Ping timeout: 244 seconds]
dented42 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<flip214>
--
varjag has joined #lisp
nowhere_man has joined #lisp
scymtym has joined #lisp
dirk` has joined #lisp
<flip214>
When having a *var*, every access needs to check for bindings. when using (let ((=var= ..)) (defun ...)), every access has to go via the symbol.
<flip214>
is there some way to get a global variable that's as fast as just accessing some known memory location? (sbcl, amd64)
<Shinmera>
sbcl has defglobal, if I remember correctly
dirk` is now known as Darts
Darts has quit [Quit: Work]
it3ration has joined #lisp
it3ration has quit [Ping timeout: 252 seconds]
asarch has quit [Quit: Leaving]
<trittweiler>
flip214, yeah look at sb-ext:defglobal. sbcl itself uses a naming convention of **foo** for global variables
Fare has quit [Ping timeout: 252 seconds]
shka_ has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
DataLinkDroid3 is now known as DataLinkDroid
<beach>
flip214: What do you mean by "every access has to go via the symbol"?
<beach>
flip214: Also, most of the time, even in a language like C, accessing a global variable is no longer just a matter of accessing a memory location.
<jackdaniel>
I think that what he asks for is a global binding which may be resolved at the compilation time, not at runtime (and sb-ext:defglobal gives exactly that I think)
<beach>
I still don't get the (let ((=var= ...)) (defun ...)) example.
orivej has quit [Ping timeout: 246 seconds]
<jackdaniel>
yeah, I don't get that example either
<no-defun-allowed>
hi beach
<jackdaniel>
maybe it was meant to simulate global which is bound only in the function scope - defglobal doesn't work like that though)
<jackdaniel>
s/)//
<jackdaniel>
globals are always bound
orivej has joined #lisp
Darts has joined #lisp
fikka has joined #lisp
<shka_>
hm
smokeink has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
lavaflow has quit [Ping timeout: 245 seconds]
rumbler31 has joined #lisp
azimut_ has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
azimut has quit [Ping timeout: 244 seconds]
juki has joined #lisp
tralala has joined #lisp
<ebrasca>
Is there some program to identify duplicate blocks of text within a file?
it3ration has joined #lisp
<shka_>
ebrasca: i don't know about such thing, but it should be possible
<shka_>
perhaps just like plagiarism detection algorithms
<shka_>
it can work
<shrdlu68>
ebrasca: Duplicate blocks of what length? Words?
it3ration has quit [Ping timeout: 240 seconds]
<shka_>
well, if you can hash text smartly, you can probabbly brute force your way trough most documents
<ebrasca>
I think it have 1 problem if indentation change it don't detect duplicated text.
<shka_>
ebrasca: i think that usually, such program should ignore all whitespace characters all together
Darts has quit [Ping timeout: 240 seconds]
<shka_>
if it is natual language it analyzes
<shka_>
it also should not split words
<shka_>
so in fact it would compare chains of words
<ebrasca>
I like to input common lisp code and find duplicates.
<shka_>
oh, but common lisp code is not a text!
<shka_>
ebrasca: i think that you want to compare trees
<shka_>
perhaps finding tree that occurs frequently
<ebrasca>
Is there someting like this?
MetaYan has joined #lisp
<shka_>
i don't know
<shka_>
but it is different class of problem
dddddd has joined #lisp
<Demosthenex>
i'm using dexador to make http requests, and using the example code from https://github.com/fukamachi/dexador for handling error codes is pretty straightforward with handler-case, but i'm confused over handling some conditions in my function (ie: rate limit, retry service unavailable) vs allowing the calling function to control things like 404. it looks like dexador defines a base class for generic
<Demosthenex>
"http-request-failed", and then has more specific ones under that.
<Demosthenex>
it seems simple to do "catch specific, catch specific, catch all", but i don't see a way to "catch all EXCEPT"
<Demosthenex>
should i just raise the error twice maybe?
<shka_>
handler-case accepts type specifer
<shrdlu68>
(not ...
<shka_>
so you can write (and some-error-type (not but-not-this-error-type))
<shka_>
Demosthenex: try it!
<Demosthenex>
interesting. i know conditions are confusing, i never realized you could use logic on the match :P
<Demosthenex>
i'll go tinker =]
quazimodo has quit [Ping timeout: 272 seconds]
quazimodo has joined #lisp
<Demosthenex>
ok, it may be trivial, but reloading code on the fly while in a giant job you wouldn't want to restart is so flipping cool. updating the rate limiting code and changing debug level without stopping is priceless.
<Demosthenex>
just another thumbs up for cl =]
m00natic has joined #lisp
makomo has joined #lisp
X-Scale has quit [Ping timeout: 272 seconds]
[X-Scale] has joined #lisp
[X-Scale] is now known as X-Scale
jack_rabbit has joined #lisp
razzy has quit [Ping timeout: 245 seconds]
AndreasO has joined #lisp
<dim>
eons ago I used to catch SIGUSR1 and SIGUSR2 on the services I would write and have them implement logmore and logless ;-)
<Demosthenex>
is it reasonable to assume that (sleep) is good to the hundreth of a second?
<shka_>
Demosthenex: usually it is the best to consult implementation manual
<shka_>
Demosthenex: btw, it is how type specifers in cl work
razzy has joined #lisp
<shka_>
you can do stuff like (declare (type (or null string) optional-string)
<shka_>
and depending on implementation, it can be even checked at the runtime
<shka_>
which is cool
<shka_>
obviously, to be sure, you are better of writing check-type, but even there you can write (or null string)
froggey has joined #lisp
astalla has joined #lisp
aindilis has quit [Remote host closed the connection]
joni has joined #lisp
p9fn has joined #lisp
<Demosthenex>
hrm. regarding logic on conditions, is this right? https://bpaste.net/show/9b369daad045 i just got a service unavailable, but i thought that would retry under the generic clause
azimut_ has quit [Quit: Adios]
it3ration has joined #lisp
<shka_>
Demosthenex: it looks like handler-case would be cleaner
<jackdaniel>
shka_: handler-case works different than handler-bind
<jackdaniel>
in sense that it returns where it was called, while handler-bind may be used to fix the issue without interrupting the program flow
<shka_>
ah, right
<shka_>
he is restarting
it3ration has quit [Ping timeout: 246 seconds]
<shka_>
Demosthenex: it looks like it SHOULD work to me
<shka_>
Demosthenex: maybe there is retry limit?
<shka_>
or something?
<shka_>
try to chcek if condition is launched
<shka_>
by installing break into handler
<jackdaniel>
Demosthenex: you still need to handle the condition
<jackdaniel>
handler-bind is meant to fix the issue
<jackdaniel>
from handler-bind you may invoke for instnace "retry" restart
<Demosthenex>
yeah, and i'm calling the dexador restart, or so i thought
<shka_>
Demosthenex: eh, just let me check how this works under the hood
<Demosthenex>
to be fair, i'm assuming i messed up the syntax somewhere, or don't understand conditions well enough.
<scymtym>
shka_: i think i spotted the problem, see above
<shka_>
oooh
<shka_>
ok
<shka_>
Demosthenex: examples are correct, those function calls should invoke proper restart
<shka_>
so scymtym should be correct
<shka_>
check if handler-bind lambda is called even if error type is t
lavaflow has joined #lisp
<shka_>
if yes, clearly scymtym got it right
<shka_>
*if no
<scymtym>
i guess you have to either (handler-bind ((dex:http-request-failed (dex:retry-request 5 :interval 3))) …) or (handler-bind ((dex:http-request-failed #'dex:retry-request)) …) which seems pretty weird
<shka_>
yeah
<shka_>
Shinmera will probabbly want to fix it
<Demosthenex>
wait, so i'm returning a function which is just returning his function? so i should funcall the retry with interval call?
<jackdaniel>
shka_: since when Shinmera fixes someone else's libraries?
<Demosthenex>
shka_: i'm not sure he's wrong. handler-bind wants a function to call, and if you call #'dex:retry-request its a funcion, or (dex:retry-request 5 :interval 3) makes a closure to return... that's right
<shka_>
jackdaniel: right, dexador is written by fukamachi
trittweiler has joined #lisp
<jackdaniel>
I have a few beefy requests for mcclim and ecl :-)
lavaflow has quit [Ping timeout: 244 seconds]
<scymtym>
Demosthenex: you should be able to (handler-bind ((… (lambda (c) (funcall (dex:retry-request 5) c))))), yeah. but note that the counter stored in the closure will not work since a new closure is made each time the condition is handled
<Demosthenex>
yeah. looks like its my desire to add sleeps and logging that are breaking that
SaganMan has joined #lisp
<scymtym>
Demosthenex: you could probably use something like (let* ((retry (dex:retry-request 3 :interval 10))) (handle-bind ((… (lambda (c) (sleep 120) (funcall retry c)))) …))
<jmercouris>
but it seems that local-time doesn't allow you to specify a format when parsing
<jmercouris>
seems I'll have to use encode-universal-time with chronicity or something like that
trittweiler has joined #lisp
quazimodo has quit [Ping timeout: 244 seconds]
quazimodo has joined #lisp
Bike has joined #lisp
<shrdlu68>
jmercouris: Once you get universal time, then unix time is (- universal-time (encode-universal-time 0 0 0 1 1 1970 0))
lavaflow has joined #lisp
orivej has quit [Ping timeout: 245 seconds]
rumbler31 has joined #lisp
lavaflow has quit [Ping timeout: 240 seconds]
<jmercouris>
shrdlu68: I did (chronicity:parse "date") which yields a timestamp then just used (local-time:timestamp-to-unix), but unfortunately it is off by my timezone
<jmercouris>
I wanted the dates parsed as GMT
azimut has joined #lisp
rumbler31 has quit [Ping timeout: 244 seconds]
<jmercouris>
seems I have to set *NOW* or something
<jmercouris>
ah, date time manipulation, what a joy
<shrdlu68>
I'm not sure what it means to "parse as GMT", unless you want to GMT+/-n
mindCrime has joined #lisp
eschulte has joined #lisp
<jmercouris>
that means parse a date that outputs a timestamp that assumes the date was written during GMT
<jmercouris>
anyways though, I got it, thanks :)
igemnace has joined #lisp
mindCrime has quit [Ping timeout: 272 seconds]
warweasle has joined #lisp
aindilis has joined #lisp
<phoe>
beach: yep, (:foo :bar) is not equal to (:bar :foo)
juki has quit [Quit: ERC (IRC client for Emacs 26.1)]
jkordani has joined #lisp
igemnace has quit [Read error: Connection reset by peer]
igemnace has joined #lisp
jkordani has quit [Client Quit]
jkordani has joined #lisp
JeromeLon has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<dlowe>
jmercouris: I think you have to pass in gmt to chronicity
* dlowe
<- slowpoke
zfree has quit [Quit: zfree]
<jmercouris>
dlowe: I don't believe you can
<jmercouris>
says in the readme "Unlike Chronic, Chronicity doesn't support timezones and seasons
<jmercouris>
yet. Support is planned for future releases."
Lycurgus has joined #lisp
<jmercouris>
one could set *NOW* but I didn't want to faff around with that
<shrdlu68>
In any case, "GMT" is same as "+0000"
JeromeLon has left #lisp [#lisp]
<jmercouris>
yes, sure, but what should the format of *NOW* be anyway?
<jmercouris>
who knows what it is expecting
it3ration has joined #lisp
<jmercouris>
you have to make a date time with what?
<jmercouris>
I don't know whatever, I just brute forced it lol
<jmercouris>
local-time:*default-timezone* does exist, however
<jmercouris>
and at any rate, it still suffers from the same issue
pierpal has quit [Quit: Poof]
<jmercouris>
since my code works, I shall leave it, it isn't mission critical
<jmercouris>
only gets run once per day
fikka has quit [Ping timeout: 240 seconds]
<jmercouris>
shrdlu68: thanks for the tips, they helped steer me in the right way in the end
pierpal has joined #lisp
mrcom has quit [Ping timeout: 272 seconds]
fikka has joined #lisp
<dlowe>
hm. no idea. I only did local-time not chronicity
<dlowe>
I have another time library but no actual time to work on it haha
fikka has quit [Ping timeout: 244 seconds]
fikka has joined #lisp
tralala has quit [Quit: out]
drmeister has joined #lisp
<drmeister>
Can anyone point to a good reader macro for defining hash tables on the fly? Something like Python's: food = {"ham" : "yes", "egg" : "yes", "spam" : "no" }
nika_ has joined #lisp
<dlowe>
drmeister: would using alexandria's (alist-hash-table '(("ham" . "yes") ("egg" . "yes") ("spam" . "no"))) suffice?
<dlowe>
mason: You might prefer the iterate library
<mason>
All the elegance of printf(3) :/
<dlowe>
don't look at format then :p
<mason>
heh
MetaYan has quit [Ping timeout: 246 seconds]
jochens has joined #lisp
cage_ has joined #lisp
fikka has joined #lisp
shka_ has quit [Quit: WeeChat 1.9.1]
developernotes has joined #lisp
fikka has quit [Ping timeout: 272 seconds]
<beach>
mason: LOOP is quite good for describing a large subset of the looping constructs that are normally needed.
FreeBirdLjj has joined #lisp
<mason>
beach: But it's the "and doing it all at once" that bothers me. :P
mindCrime has joined #lisp
<dlowe>
there's nothing in loop that can't be done with other constructs
<dlowe>
if you write a macro that does a better job, maybe it will achieve wide popularity
fikka has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
rumbler31 has joined #lisp
fikka has quit [Ping timeout: 246 seconds]
jmercouris has quit [Ping timeout: 244 seconds]
<beach>
mason: Sorry to hear that it bothers you.
rippa has joined #lisp
rumbler31 has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
<mason>
beach: Well. My question about prevalence is in part because I have to believe at least some population of Lisp programmers feel this way - Graham can't be alone.
<Xach>
It is true that some population feels that way.
<mason>
s/feel/&s/
<beach>
mason: Paul Graham has some other strange opinions as well.
<beach>
mason: Like not wanting to use generic functions etc.
<Xach>
But no matter how strange, the opinions certainly shared by some population
<dlowe>
The thing about CL is that like it or not, the spec changes for no-one.
<Xach>
Possibly those who learned from his book only
<p_l>
I'd say Arc shows his preference for forever-NIH scheme
<Xach>
(not exclusively those)
<jackdaniel>
mason: I'm not a big fan of LOOP and FORMAT either if that consoles you ;-)
<mason>
jackdaniel: It does. It does. :)
fikka has quit [Ping timeout: 240 seconds]
<jackdaniel>
I'm not against powerful macros, just when I see more complicated usages of both operators they turn into perl in my eyes
<jackdaniel>
and I'm not very proficient with perl
<jackdaniel>
(probably I've just self-implied that I'm not clever enough, but whatever ;)
smazga has joined #lisp
<whartung>
of course the spec not changing in 20 years is a definite reason for discussion dlowe
<beach>
whartung: Nah, that is a very good thing.
<whartung>
it’s sure suited the networking and threading camps.
<whartung>
those are ad hoc standards at best today.
<dlowe>
There is a selection effect where those who think it is a bad thing are not here :p
<AeroNotix>
With LOOP and FORMAT I just wish SLIME had far better autocomplete/minibuffer documentation
<beach>
whartung: Why do you care whether those are in the standard or not?
<dlowe>
I think there are tradeoffs that I'm comfortable with.
<AeroNotix>
whartung: the spec not changing in 20 years is a good thing
<beach>
whartung: Is there networking in the C standard for instance?
<AeroNotix>
Case in point: I'm running code last changed 17 years ago with no issues.
* mason
is an xv fan.
fikka has joined #lisp
<AeroNotix>
What's xv?
<mason>
See?
<AeroNotix>
Sorry for not knowing everything
<AeroNotix>
I'll try harder next time
<AeroNotix>
but for this time, could you just explain what xv is
<Xach>
xv is an old image viewer
<mason>
Sorry, was distracted. Yes. It was most popular in the early 90s.
<mason>
And it's still lovely today.
* Xach
used Tuebingen Mosaic but it is no longer lovely
dirk` has joined #lisp
dirk` is now known as Darts
<nirved>
used xv 20 years ago, these days gliv suits me better
<Xach>
Hmm, I am using github for some quicklisp work today, and it seems very slow.
nika_ has quit [Quit: Leaving...]
<AeroNotix>
Xach: I thought it was just me but GH has seemed very slow for the last few days
fikka has quit [Ping timeout: 244 seconds]
<Xach>
Ok.
Fare has joined #lisp
<AeroNotix>
The status page has nothing
<AeroNotix>
though I'm sure I remember a page for GH where they showed API latency. Can't remember where that's located now
<dim>
I remember using xv then switching to feh in the early enlightenment DR16 days... that's a long time ago, when I was happy with the command line, now I just C-o in dired and don't really care what program it opens ;-)
<dlowe>
I use eog these days
shrdlu68 has quit [Quit: WeeChat 2.0.1]
<razzy>
hi, how ready SICL is?
astalla has joined #lisp
<beach>
razzy: Not at all.
dale_ has joined #lisp
<beach>
I am working on the bootstrapping code, but I ran into some complications related to DEFINE-METHOD-COMBINATION, so now I am working on that for the next few days.
dale_ is now known as dale
asarch has joined #lisp
shka_ has joined #lisp
<shka_>
good evening
<beach>
Hello shka_.
<AeroNotix>
jesus it's evening already. Need to sort out my sleep schedule
<shka_>
AeroNotix: it may be not evening in your area :-)
<shka_>
but reevaluating sleep schedules periodically is a good idea nonetheless
<AeroNotix>
shka_: It's 17.30
<shka_>
oh, ok
<shka_>
in such case you are in the same time zone
<AeroNotix>
GMT+2 here
<razzy>
beach: cool just asking,.. like the ideas :]
<beach>
Thanks.
fikka has joined #lisp
<jackdaniel>
shka_: AeroNotix is from Poland and speaks the same language as you do
<razzy>
beach: i like multiple versions of package, because you would like different version of package for different architectures also
<shka_>
oh, ok
<shka_>
AeroNotix: Cześć!
<shka_>
:-)
<beach>
razzy: Yes, that's true.
<shka_>
i didn't assume that because you are not at #lisp-pl
<AeroNotix>
shka_: no, pl
<AeroNotix>
czesc
<razzy>
any candidates for #lisp-cz?
<AeroNotix>
I'm not a native pole though. My polish is like intermediate at best.
<shka_>
AeroNotix: it's ok :-)
<AeroNotix>
I'll join #lisp-pl though
<shka_>
cool!
<shka_>
razzy: i can't pretend to be Czech ;-)
<shka_>
but my advice is to go on and start it
<dlowe>
someday there will be a #lisp-jbo
<razzy>
beach and for optimization, you could have different packages for GPU architectures and CPU and change that on the fly
<shka_>
it does not cost you anything
jochens has quit []
<shka_>
razzy: mgl-mat does something like that
<AeroNotix>
dlowe: jbo?
<shka_>
but even better
jochens has joined #lisp
<beach>
razzy: I suppose so.
<shka_>
because it stores data in few formats at the same time
<shka_>
so it can run both CUDA code and good old lisp at the same time
fikka has quit [Ping timeout: 245 seconds]
<shka_>
it is quite neat!
<razzy>
shka_: what the hell? need to check it out
it3ration has joined #lisp
<shka_>
razzy: yeah, it is not perfect by any means, and author was assimilated by google so he does not work on it anymore
gpiero has quit [Remote host closed the connection]
<shka_>
razzy: honestly, i have no idea what to think about petalisp
<shka_>
or how to type τ from keyboard
bigfondue has quit [Ping timeout: 250 seconds]
<razzy>
shka_: and most joy i would have, if we canibalise mgl-mat petalisp and make proper compiler that distribute load based on AST
<shka_>
well, i think that mgl-mat cube/facets stuff would fit into any math library
<razzy>
interpreter/compiler
varjag has joined #lisp
<razzy>
sure shka_
<shka_>
petalisp is not exception
<shka_>
does petalisp author accepts merge requests?
<shka_>
how to contact him and discuss design?
fikka has joined #lisp
<razzy>
no idea
<razzy>
just read his paper
<shka_>
eh, some other time
<shka_>
i have something different to do now
<shka_>
but at this point all I really want is to have decent numpy style library
<shka_>
if petalisp can do that, I like it already
<shka_>
at this point mgl-mat was the best thing i found
jack_rabbit has quit [Ping timeout: 252 seconds]
<razzy>
petalisp optimalise all code. and will run partially on GPU
<razzy>
acording to authors
<razzy>
for huge systems
<shka_>
ok, that sounds good
<razzy>
the GPU part is work in progres
<shka_>
i seriously question non-ascii symbols
<razzy>
it assemble AST, do heuristic what to run where, and executes
fikka has quit [Ping timeout: 240 seconds]
<shka_>
but this can be solved
<shka_>
oh gosh, so it is compiler? :/
<razzy>
kind of, yes,.. imho the ussage would be something like (compute (your function)) and it will spread whatever it can to GPU and multiple CPUs
<shka_>
eh, ok
<shka_>
that's above my level
<razzy>
so far above my also
<razzy>
but the idea is nice
<razzy>
and acording the paper is working at least partially
<razzy>
afk
<Bike>
the author is on irc sometimes as heisig. don't remember if he uses this channel though.
<jackdaniel>
[he uses this channel]
<shka_>
well i will try to check article and code out
<jackdaniel>
you talk about petalisp I guess?
<shka_>
maybe there is something i can do to help
<shka_>
yes
<shka_>
i need something like this, so if i can help to make it better, it would benefit me
<shka_>
but this approach sounds rather… advance
LiamH has joined #lisp
bigfondue has joined #lisp
<razzy>
anyone know Robert Strand
<beach>
That would be me.
Kaisyu has quit [Quit: Connection closed for inactivity]
<razzy>
beach: like your git :], protest?
<beach>
I don't understand.
<shka_>
razzy: protest would be from phoe
<razzy>
i read presentation on EU lisp conference
fikka has joined #lisp
<beach>
I see, yes.
<razzy>
do i get sensation that there should be data dependent universal protocol?
<shka_>
where?
Fare has joined #lisp
pjb has joined #lisp
<razzy>
phoe: is protesting?
Fare has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 245 seconds]
nirved_ has joined #lisp
nirved has quit [Ping timeout: 240 seconds]
scymtym has quit [Remote host closed the connection]
<razzy>
beach: was your presentation about said protocol? i would like to know more
<beach>
What protocol?
<razzy>
protest protocol?
<beach>
No, I have not been working on that.
<beach>
It is the work of phoe.
<razzy>
ah, ok, misunderstanding
<pjb>
razzy: debugger protocol?
fikka has joined #lisp
<shka_>
sigh
<shka_>
ok, done
<beach>
pjb: "protest" is phoe's project.
<shka_>
i just added approximated-counts (min counting data sketch) to cl-ds
jack_rabbit has joined #lisp
<shka_>
beach: i was told you had some dope paper on debugger specification
<shka_>
for SICL i think
leastbit has joined #lisp
<shka_>
is it in the SICL repo?
<beach>
shka_: Yes, there is a specification of the Clordane debugger, and there is a specification of the support that SICL will give for debugging in the SICL specification.
<beach>
Which one do you want?
<shka_>
i don't know, but i suspect the second
<beach>
OK, hold on...
fikka has quit [Ping timeout: 252 seconds]
<makomo>
hm, does the CL spec say anything about reentracy (in general or for some function)? for example, doesn't GET-SETF-EXPANSION have to be reentrant because an expander for a place can use it to further process subforms which are places?
<shka_>
razzy: well, there seems to be something to it
Fare has joined #lisp
<razzy>
is there a bot to leave heisig message?
Khisanth has joined #lisp
<razzy>
.tell
<razzy>
.about
m00natic has quit [Remote host closed the connection]
fikka has joined #lisp
<Bike>
minion: memo for razzy: like so
<Bike>
well unless minion isn't here
<makomo>
you can also use Colleen
<makomo>
i forgot the exact syntax, but msg Colleen with "help" or random gibberish or something and you'll get a list of options
<Bike>
::notify razzy like this, i think
<Colleen>
Bike: Got it. I'll let razzy know as soon as possible.
Denommus has joined #lisp
it3ration has joined #lisp
developernotes has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<AeroNotix>
Given a function FOO and (SETF FOO), given #'FOO how can I find the (SETF FOO)?
doubledup has joined #lisp
it3ration has quit [Ping timeout: 260 seconds]
doubledup has quit [Client Quit]
developernotes has joined #lisp
<jasom>
AeroNotix: I don't think there's a portable way to do that. Obviously given 'FOO you can do it but #'FOO might no longer have a name associated with it.
<jasom>
well... you could call symbol-function on every reachable symbol and compare with #'FOO, that would work as long as #'FOO isn't from an FLET.
<AeroNotix>
jasom: with 'FOO it's possibly yeah
<kristof>
there's no way to get the function name from a function object? weird
<jasom>
kristof: there's no *portable* way
<jasom>
most implementations keey that information around as long as you're not at (debug 0)
<jasom>
s/keey/keep
<razzy>
::notify heisig razzy says: hi, i really like petalisp project, want to talk?
<Colleen>
razzy: Got it. I'll let heisig know as soon as possible.
<jasom>
If you really want it, then it's fairly easy to make a custom defun that stores the information in a hash table for later lookup
<kristof>
why are there two competing irc bots now? :P
dueyfinster has joined #lisp
<jasom>
kristof: what's the second? Minion used to be in here, but I don't see it any more
mrcom has joined #lisp
<kristof>
::notify jasom You're getting a message from the other one
<Colleen>
kristof: Got it. I'll let jasom know as soon as possible.
<dlowe>
there's three but one of them isn't in here
<dlowe>
well, two of them aren't, technically
<kristof>
"as soon as possible". Doesn't do it immediately... :P
<makomo>
especially the part when he modifies the picture of a cat :D
<razzy>
beach: only thing i am against in lispOS is completelly open pointers between software.
fikka has quit [Ping timeout: 245 seconds]
Darts has quit [Ping timeout: 240 seconds]
vultyre has joined #lisp
<jasom>
beach: FWIW, I have administrated some servers that could not work with a single address space on a mondern intel chip (256TB is the maximum that can be addressed on recent intel chips).
<razzy>
i am for that possibility. but i want to limit number of global variables in main loop (so user can inspect by hand what data is software passing between themselfs) and have very sophisticated tools to manage reuse of functions.
<jasom>
beach: the architecture allows for virtual/physical addresses up to 64/52 but 48/48 is the largest anybody has built to date (as far as I know)
<razzy>
beach: and run every piece of software in its own adress space (let)
sauvin has quit [Read error: Connection reset by peer]
<jasom>
razzy: a single address space does not harm this; you can have a single address space with zero global variables if you like.
<razzy>
if the software grow too much into system, you would never get rid of it
<razzy>
jason: i used bad term, i realised
fikka has joined #lisp
<jasom>
well a single address space *does* make it easier to use global variables, so they are not entirely unrelated
azimut has quit [Ping timeout: 240 seconds]
<razzy>
you could have multiple physical memories posed as different virtual memories
<razzy>
different set of virtual memories
<razzy>
i would hate if software called any funcion willy nilly
vultyre has quit [Remote host closed the connection]
<razzy>
but that should be user defined
<AeroNotix>
razzy: you mean just like linked libraries
Fare has quit [Ping timeout: 245 seconds]
vultyre has joined #lisp
LiamH has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 272 seconds]
<AeroNotix>
Sounds like securing something in this LispOS would be a nightmare
<kristof>
define secure
<kristof>
there are some complete paradigm shifts one must undertake to be an operator of a system like this.
<AeroNotix>
kristof: being able to access arbitrary memory locations presents more than a few security issues
<kristof>
One of them is "don't run code you don't trust from people you don't trust"
<kristof>
If you don't trust someone, at least find a way to trust the code. And if you can't read the code, how can you trust it?
<kristof>
Besides, "sandboxes" are trivial
<AeroNotix>
kristof: that implies the boundaries are fully secure
<razzy>
AeroNotix: some people are perfectly ok with their OS being ball of messy wigling functions, as long the system o what it suppose to
<razzy>
do what it suppose to
<kristof>
if you really don't trust something, run it in a virtual address space, which is what will happen to C code, anyway
<jasom>
AeroNotix: all OSes rely on boundaries being secure, this is not peculiar to the LispOS proposed by beach
<razzy>
some people would like to controll output functions
<razzy>
some people would like to controll functions operating on their data
<razzy>
i would like this system
ikki has joined #lisp
<razzy>
AeroNotix: this lisp Os would be more transparent and readable, therefore more secure, imho
<jasom>
I do think making all memory appear consistent is a recipe for disaster; as beach mentions, it's a cache, and all caches become non-transparent when ordering matters.
<jasom>
s/consistent/persistant/
LiamH has joined #lisp
<jasom>
the reason that the persistant/volatile dichotomy remains today is because non-volatile memory is much slower at random access than volatile memory, and you can end up with an unusable system if ordering on non-volatile memory is incorrect (for some hand-wavy meaning of "incorrect")
<razzy>
jasom: what you could do, is to make one "virtual memory" that use other physical memories (caches, RAM, HDDs) as needed.
<jasom>
If you mess up ordering on volatile memory, sanity is just a power-cycle away. non-volatile memory is far less forgiving
<razzy>
more forgiving
<jasom>
less
<jasom>
you can end up with a non-bootable system if you corrupt non-volatile memory
<kristof>
jasom: I've got about 16GB of volatile memory on this laptop and 1TB of secondary storage. I think this is one of those "realities" that just needs to be accepted until things change.
xaotuk has joined #lisp
<jasom>
kristof: if you could guarantee that on a system failure volatile memory got flushed to secondary storage, *and* that volatile memory never ends up in a bad state, then you could use your 16GB as only a cache for the 1TB.
vultyre has quit [Quit: Leaving]
<White_Flame>
non-volatile RAM would basically make sleep/powerloss a no-brainer, but the normal boot process would probably still want to reinitialize RAM
<kristof>
Right, but the persistence isn't why I think abstracting the difference is a good idea. You can access main memory in nanoseconds. I think SSD access time, despite there being no seek, is still around 10ms.
<razzy>
memories have many physical constrains. access speed, reliability, storage volume. data have needs: reliability, speed of acces. Solution is match data needs to physical constrains of real world
<jasom>
Now it occurs to me that if you wrote your operating system only with pure data structures, and your garbage collector ran against non-volatile storage, then the ordering problem is largely solved, but efficient garbage collection algorithms with multi-TB heaps are non-trivial
<razzy>
that is OS job,.. not programmers
<White_Flame>
jasom: basically the same as append-only filesystems
<jasom>
kristof: I can read a file from my systems disk cache really fast
<jasom>
White_Flame: correct
Darts has joined #lisp
<jasom>
White_Flame: but append-only filesystems enforce a tree-structure on the data, so GC is much simpler
<jasom>
razzy: the OS is a program
<kristof>
I plan trips much differently based on whether I can walk across the street to do my chores or if I have to take public transit. They're so quantitatively different that abstracting fails to take advantage of the differences.
fikka has joined #lisp
<White_Flame>
razzy: if you wish to actually map solutions to the physical aspects, that generally involves application programmer decision making
<razzy>
jasom: yes and? it is job better solved on OS end.
<jasom>
kristof: the relative difference between L1 and RAM is similar to RAM and SSD
<kristof>
jasom: Yeah, I was thinking about that counterpoint, and my answer is that I'm willing to ignore it for cache vs. RAM and I'm not willing to ignore it for RAM vs SSD.
<kristof>
Am I... a hypocrite? :P
<razzy>
White_Flame: yes, now it is done by programmer
<kristof>
I think I'm just blindly accepting the dichotomy that modern programming paradigms impose.
<kristof>
Excuse me - operating system paradigms.
<jasom>
~100us for an NVMe storage
<jasom>
rather 100us for SAS SSD
<White_Flame>
razzy: well, unless the OS becomes "smarter" and more correctly predictive about the nature of access patterns, it's still up to the programmer by default
MetaYan has joined #lisp
<White_Flame>
and if changing access patterns also means shuffling around your data structures, or your application deciding what to load when, and how much, well that's not the OS's domain to decide for you
vultyre has joined #lisp
<kristof>
Because of some poorly designed Linux applications I have felt, on many occasions, the pain of swapping to a hard disk drive where RAM was expected. The solution isn't to program based on HDD access speeds, it's to fit the program within the constraints of the expected RAM size.
rumbler31 has joined #lisp
<kristof>
For cache vs ram, you're far likely to cry over a mismatch (accidental cache flushes).
<White_Flame>
depends on what you're doing
<kristof>
*far less likely
<White_Flame>
but yeah, the field is much smaller
<kristof>
It does depend.
<kristof>
For numerics? You better know!
<kristof>
(And that's also why I think there should be better low level languages designed for cache manipulation for these domains.)
<razzy>
White_Flame: in my hypotetical OS you could still setup data needs (this have to have 100ns acces etc. reliable at least 2 copies at all times)
fikka has quit [Ping timeout: 260 seconds]
<razzy>
but exact execution would by on compiler/interpretter
<jasom>
really performance intensive code will do things like prefetch, and manage the data to be adjacent (or not-adjacent for parallel execution), while most code is cache oblivious. It's not hard to see a future where secondary storage is used in the same way
vlatkoB has quit [Remote host closed the connection]
<kristof>
That's not true
rumbler31 has quit [Ping timeout: 244 seconds]
<razzy>
White_Flame: and in petalisp they say they partially solved problem of managing multiple memories and CPUs for big datacluster
<White_Flame>
razzy: that's a completely different domain
makomo has quit [Ping timeout: 272 seconds]
FreeBirdLjj has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
<razzy>
White_Flame: that is same problem, different size.
<White_Flame>
general purpose computing vs data crunching loops
<razzy>
they are making general data crunching
fikka has joined #lisp
<razzy>
but i think it is still solvable for small home music playing
<White_Flame>
and does it encompass hard drive access?
<White_Flame>
and rearchitecting your data structures and disk access strategies?
<razzy>
idk, i think not
xaotuk has quit [Remote host closed the connection]
<razzy>
but i think it is possible
<White_Flame>
right, not general purpose computing, not OS-level design
<White_Flame>
it's still the aplication's control as to what to do where, and how to represent its internal structures
xaotuk has joined #lisp
Fare has joined #lisp
<White_Flame>
that all needs to be changed when implications of the underlying hardware affect its performance
vultyre has quit [Remote host closed the connection]
<razzy>
White_Flame: true
<White_Flame>
one might say that that sort of thing is fundamental to the act of programming itself
<razzy>
fundamental to managing hardware
FreeBirdLjj has quit [Ping timeout: 245 seconds]
<razzy>
not to algorithms
FreeBirdLjj has joined #lisp
<White_Flame>
translating intent into instructions to execute == programming
<phoe>
razzy: heyyy
<White_Flame>
and selecting instructions involves designing data structures and access patterns
<razzy>
heya
MetaYan has quit [Ping timeout: 246 seconds]
vultyre has joined #lisp
<phoe>
I think you were confusing a few things over there
gravicappa has joined #lisp
<phoe>
protest is a library for declaring and handling protocols and test cases, and it's mine
<phoe>
petalisp is an array computing language based on Common Lisp, and it's heisig's
<phoe>
the idea of protocols has been developed by beach based on CLIM II specification, and he wrote some words about it
<razzy>
White_Flame: ok, if you want your powertrip of micromanaging instructions,.. you are master programmer
<White_Flame>
computers can't understand or execute intent
<White_Flame>
some translation into computer-speak of some level is required
<White_Flame>
then everything else underneath is instruction->instruction transformations
<pjb>
I find it silly to optimize code for the current architecture (cache or not), given that any time, we could start using processors where ALUs are in the RAM.
<razzy>
most of people have hard time think up the algorithm, write it in precise language, manage huge amount of hardware efficiently
<pjb>
On the contrary, use lisp to write higher level code, more declarative, and let the compiler writters worry about the hardware.
<razzy>
this would make managing hardware less pein
<razzy>
pain
<White_Flame>
pjb: unless data access & I/O become a bottleneck
<razzy>
pjb: imho lisp compiler should do more
<pjb>
White_Flame: don't do I/O! Don't do data access! Write declarations! :-)
<White_Flame>
heh
<pjb>
(declarations can be ignored in CL, so 0 code generated, the fastest program even >:-} )
<pjb>
But seriously, never mix I/O with computation.
<White_Flame>
well, sometimes RAM access is noticeable I/O
FreeBirdLjj has quit [Remote host closed the connection]
<White_Flame>
and sometimes your computational structures are larger than memory (and as said above, the OS doesn't know what you're doing so general OS-level solutions will suck as badly as virtual memory)
<pjb>
Buy more RAM.
warweasle has quit [Quit: back later]
<razzy>
pjb: i was talking about lisp compiler managing HDD, RAM, caches. in one big glorious flat heap of data
<White_Flame>
I woudl personally agree, but it isn't an ultimate solution
<White_Flame>
^- to pjb
<pjb>
razzy: well, this is usually done at the OS level. But indeed, the compiler could simulate it by providing a VM and a virtual OS layer.
<pjb>
razzy: you know about KeyKOS, and EROS right?
<pjb>
Even the network is included in the flat heap of data, with 64-bit addresses.
<pjb>
( but 128-bit addresses would be better to map IPv6 :-) )
<razzy>
lisp compiler should be integrated into lispOS
<jasom>
razzy: the lisp compiler is just one service provided by the lispOS
makomo has joined #lisp
<razzy>
i wanted to express idea as quickly as possible
Darts has quit [Quit: ERC (IRC client for Emacs 26.1)]
<pjb>
razzy: It's in important architectural choice.
<razzy>
pjb: keykos gives me ghoose bumbs :] mostly in good way
vultyre has quit [Remote host closed the connection]
<pjb>
The question is whether you can better ensure the security boundaries purely with software (the compiler code; how do you protect it?), or with the help of the hardware, by the OS.
lieven has joined #lisp
<pjb>
What is easier to get? A bug in the compiler, or a bug in the hardware & OS?
<shka_>
heh
<shka_>
both are guaranteed!
fikka has quit [Ping timeout: 246 seconds]
<pjb>
How do you update the compiler, in a secure way? or the OS?, but compilers like SBCL get an update every month, while the OS is updated once every 4 or 5 years. How often do you want to be attacked?
<pjb>
See how easily some people ask for FFI in the compiler!
<drmeister>
Can I coerce a vector of double-floats into a vector of single-floats with a compact function? Or should I just write a loop?
Copenhagen_Bram has quit [Ping timeout: 244 seconds]
<pjb>
(coerce (coerce #(1.2d0 3.4d5) '(vector double-float)) '(vector single-float)) #| ERROR: 1.2D0 doesn't match array element type of #(0.0 0.0). |#
Copenhagen_Bram has joined #lisp
<pjb>
The problem is that clhs coerce specifies that for sequences, the SAME elements are in the result.
<pjb>
So it cannot convert a double-float into a single-float.
<pjb>
it can of course (coerce 1.2d3 'single-float) #| --> 1200.0 |# ; but it doesn't do it "recursively".
<pjb>
This could be a suggestion for a CL 3.0 :-)
<razzy>
pjb: you would need to make small local adresable areas with some form of encryption in said flat adress space. but it could be more transparent and optimizable/programable. imho the gains overweight looses :] if we already working on lispOS
kristof has quit [Ping timeout: 246 seconds]
<pjb>
razzy: encryption is needed when your control of the environment fails (eg. if you provide pointers or ffi).
Copenhagen_Bram has quit [Ping timeout: 272 seconds]
fikka has joined #lisp
it3ration has joined #lisp
<razzy>
pjb: i mean that you need to secure acces to denied functions when executing potentioally corrupted software, and this software could ask your system anything. so multilvl protection :]
<razzy>
not sure how to do it,..
<pjb>
razzy: either you have control of the environment, or you're fucked. See eg. the Meltdown bug. This is dire loss of control.
<razzy>
pjb: typical unix system is increasingly not transparent and more messy. therefore less secure
Copenhagen_Bram has joined #lisp
<drmeister>
Thank you
trittweiler has quit [Ping timeout: 272 seconds]
<whartung>
that symbolics video is one of the best I’ve seen, thanx for the link
fikka has quit [Ping timeout: 245 seconds]
it3ration has quit [Ping timeout: 272 seconds]
<kristof>
Who, mie?
<kristof>
*mine
<whartung>
yes
<kristof>
It's worth saving somewhere.
<razzy>
pjb: you could have reliable software build on unreliable hardware
pierpal has quit [Quit: Poof]
cage_ has quit [Quit: Leaving]
<whartung>
the only folks really coming close to what that was nowadays are the Pharo guys, at least taht I know of, that has any traction whatsoever.
pierpal has joined #lisp
<kristof>
whartung: Never heard of it. Looking at it now, it looks great.
<razzy>
whartung: thx, will check them
fikka has joined #lisp
<whartung>
yea. Every time I wanted to dabble with it, I just found that the folks working on it are making a Pharo designed to make a better Pharo, vs some other kind of programming.
<whartung>
They’re finally (I think) redoing the imaging model.
<kristof>
I think that's called dogfooding :P
<whartung>
sure, it just doesn’t make it particularly attractive to someone that wants to do something other than develop Pharo ;)
<kristof>
I prefer the function model to the message passing model. For instance, there's that great part at the beginning of the demonstration where he types a function name, and the GUI highlights all the usable arguments
jkordani_ has joined #lisp
<kristof>
It's easy to do that in that homogeneous environment because it can check the type of the function and then it can check the types of everything in the view.
shka_ has quit [Ping timeout: 245 seconds]
<kristof>
First off, that requires a notion of types at all.
fikka has quit [Ping timeout: 260 seconds]
<whartung>
the whole presenter model in the display was pretty neat.
<whartung>
tying to imagine working with 3 button chording on one hand and 4 button chording on another. Piano was never my strength
<kristof>
Second of all, the way you describe the computation is totally different in a function model that makes that work. In a Smalltalk system I assume you'd have to start with the "argument"... aka the thing of which you don't know what you want quite yet!
<kristof>
whartung: Muscle memory is amazing. People learn to do all kinds of crazy associations
<whartung>
yea, of course. “object msg” is the basic syntanx for smalltalk
<kristof>
I mean, just think about typing at all. And you already do chording with ctrl-c, etc.
<whartung>
yea, and my typing gets worse every day lol
jkordani has quit [Ping timeout: 252 seconds]
<kristof>
Have you ever operated machinery? When you operate a machine like a car, you treat it as an extension of you. You don't think about the specific motions involved, you just turn the wheel, or press the gas.
jkordani has joined #lisp
<kristof>
I'm totally unworried about a chording device. Although I think it's primitive relative to the technology today. Especially with motion tracking
azimut has joined #lisp
<razzy>
kristof: doogfooding seems like good modus operandi :]
<whartung>
I can drive. I can even use a stick shift. In fact, I can ride a motorcycle! That said, I haven’t had to learn something new like that in … 30 years.
<whartung>
I like dogfooding.
<whartung>
that’s why it can be nicer to work development for a company that’s just using the stuff internally, rather than a product for sale.
aindilis has quit [Ping timeout: 246 seconds]
jkordani_ has quit [Ping timeout: 260 seconds]
<whartung>
you write something, its “deployed” quickly, and by the afternoon, you either get flowers or angry people with pitchforks and torches at your desk
fikka has joined #lisp
skidd0 has joined #lisp
fikka has quit [Ping timeout: 245 seconds]
<razzy>
makes the job rewarding,.. nobody said what reward will be :D
<Colleen>
heisig: razzy said 2 hours, 18 minutes ago: razzy says: hi, i really like petalisp project, want to talk?
<razzy>
heisig: yop :]
fikka has joined #lisp
<razzy>
heisig: we had 3hour discusion :]
quazimodo has quit [Ping timeout: 252 seconds]
ikki has quit [Ping timeout: 260 seconds]
<heisig>
I'm catching up on the IRC log ... two things: Petalisp is intended as something superior to NumPy, but is currently mostly a tech demo.
<heisig>
My hope is to get things into reasonable shape until the end of this year.
quazimodo has joined #lisp
<heisig>
razzy: If you have interesting ideas or use cases, I'd love to hear them - either here or via mail.
fikka has quit [Ping timeout: 245 seconds]
stacksmith has quit [Remote host closed the connection]
<razzy>
heisig: will it be usable to arbitrary code?
<razzy>
heisig: how did you created 5000lines of maintainable code?
<heisig>
Yes, you can pass in arbitrary Lisp functions.
<razzy>
wunderbar
<heisig>
My secret to maintainable code is 1. I rewrite/beautify/document everything I cannot understand immediately a week after writing it 2. I try to design everything neatly around CLOS.
pierpa has joined #lisp
<razzy>
heisig: so you writen the thing by hand?
Lycurgus has quit [Ping timeout: 252 seconds]
<razzy>
i was expecting 4000 lines of machine learned rules
fikka has joined #lisp
trittweiler has joined #lisp
<heisig>
Petalisp? Yes, I wrote it by hand (= Emacs). But it usually generates many thousand lines of Lisp code per second when used.
<whartung>
5000 lines isn’t a whole lot of code IMHO.
<razzy>
heisig: so no machine gained experience? maybe 1000parameters tweaked by genetic algorithm? able to adjust to systems it is used on/
<razzy>
?
<whartung>
and whether its maintainable or not isn’t up to heisig, it’s up to the other guy that picks it up. That’s the challenge of maintainable code.
<whartung>
I should say asserting whether something is maintainable.
<heisig>
razzy: I do not use machine learning at all. I might do so one day, but it is not a priority.
<razzy>
whartung: i do not like to write much code. my bad
<White_Flame>
well, the amount of code you write ends up being necessitated by the scope of the project you're undertaking
fikka has quit [Ping timeout: 244 seconds]
<razzy>
how many lines write programmer in life
<razzy>
off topic
<whartung>
I mean, I find any time I take on a project, you know, you just get in a zone. you make progress, you debug stuff, incremental advancements each day, and then, you look back and go “Wow, I wrote that!??”
<whartung>
oh, that’s dangerous. That’s just what we need. nothing at all to filter what ends up on twitter....
<razzy>
:D :D
<heisig>
whartung: 5000 lines of code can be quite a lot if you try to be concise (which I do). My reference implementation of the Petalisp language has only 100 lines.
<whartung>
nice!
eddof13 has quit [Ping timeout: 246 seconds]
<razzy>
heisig: i must admit, petalisp idea is interesting to me
<heisig>
razzy: I must admit I have no idea whether it works well in practice. But that is the thing with research... time will tell.
dvdmuckle has quit [Quit: Bouncer Surgery]
<whartung>
my current (dormant) lisp project is about 1300 lines. Worst decision I did in there was using a list as a data structure in a couple of places. Something that started simple and just kind of metastasized. I just makes going back in to a little “what’s going on here?” I need to go clean those out.
<razzy>
heisig: can i see reference implemntation? is it like pseudocode?
<razzy>
whartung: i hate project doing that
<whartung>
well, just ties to my maxim “code has momentum”
<aeth>
As far as kLoC goes I find that my game engine is constantly around 7.
<aeth>
No matter how many features I add!
<whartung>
:)
<whartung>
that why you shouldn’t use the Window command window — it’s limited to 10,000 lines — any more than that, just get dropped. :)
dented42 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
<razzy>
aeth: maybe you make longer lines?
<whartung>
funny, I’m looking and the readme.md for Petalisp, and the note about greek letters. (And, note, this is not a criticism of them, it’s simply my personal reaction to them.)
<aeth>
razzy: Every addition seems to roughly be simultaneous with a subtraction so far. Of course, eventually I'll run out of the latter. Eventually.
<whartung>
mostly when I see greek letters I freeze up. Like in compiler books, and such. simple forumulas using greek letters, literally, are “Greek to me”. “lambda” was the biggest hurdle I had to overcome to make any progress whatsoever in lisp.
rpg has joined #lisp
<whartung>
the reason is that I always project that when there is a greek letter used, that it has some other meaning along with it. That the choice of the letter brings context that layman dunderhead me does not know, since it’s implicit in the domain that I’m not familiar.
<razzy>
aeth: ideally you write -20lines per day :]
<whartung>
doesn’t make that true, it’s just they way they make me feel. Even to this day they flumox me.
<heisig>
whartung: You concerns have been noted. I'm thinking about introducing separate package with non-greek names already.
<aeth>
whartung: (λ (β) (λ (α) (* α β)))
<whartung>
yea…O.o :)
<Bike>
separate package? seems like having alpha beta tau aliases would be pretty simple...
<heisig>
Or that, sure.
<whartung>
my biggest break through was a book, long ago, called “simply-scheme” which basically used a very light subset of the language, and its own vocabularly — that got me past “lambda”, and a big “aha” light came on.
azimut_ has joined #lisp
azimut has quit [Read error: Connection reset by peer]
<aeth>
The problem with Lisp-2s is that I can't maximally troll whartung with (λ (φ β) (λ (α) (φ α β))) because I have to make it (λ (φ β) (λ (α) (funcall φ α β)))
<whartung>
:)
<aeth>
Oh, wait, I know what to do. (setf (symbol-function 'φυνκαλλ) #'funcall)
<razzy>
heisig: what physical resources can petalisp optimize so far? multiple processors? net acces, multiple RAMs
cyraxjoe has quit [Remote host closed the connection]
<razzy>
aeth: also better programmers tend to write shorter code and left more work for machine
<heisig>
razzy: So far, only multiple cores. Right now, I'm trying to find a good way to model data locality. Once I have that, I want to add distributed parallelization over MPI.
<heisig>
razzy: More precisely, Petalisp used to run on multiple cores. Currently I am in the process of rewriting the code generator, so nothing really works :-)
<razzy>
heisig: hmm,.. how do you model multiple cores?
<razzy>
heisig: i was thinking about problem some time ago. i would model (lisp interpretter) (data storage) (data interface)
<razzy>
from those tree elements a would model hardware structure
<razzy>
than i would match software AST to this hardware structure
<razzy>
based on heuristics
<heisig>
razzy: It gets much worse. Instead of an abstract syntax tree, I'm dealing with data flow graphs whose nodes are themselves massively parallel.
rpg has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<razzy>
so you transript AST to some more fine grained data-flow graph?
<razzy>
a read your presentation again
cyraxjoe has joined #lisp
<whartung>
did you pick this up on a whim, or have you done compiler work before?
<heisig>
I did some compiler work before.
<heisig>
I have basically given up on the idea that on can just magically parallelize code written in a general purpose language.
<whartung>
yea
<whartung>
that seemed a bit of a leap to me as well
<ebrasca>
How to organize lisp code? ( Like order of functions , classes in big files )
<whartung>
wasn’t there a language for the transputers back in the day? Julia? (nah, that’s a new language — or did they reuse the name?)
<heisig>
I have to leave. Good night.
<whartung>
tt heisig
azimut_ has quit [Ping timeout: 252 seconds]
heisig has quit [Quit: Leaving]
scymtym has joined #lisp
<razzy>
i wanted to ask how he do DFG
<razzy>
next time
<razzy>
DFG is good :]
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
azimut has joined #lisp
juki has joined #lisp
azimut has quit [Ping timeout: 260 seconds]
<razzy>
afk
aindilis has joined #lisp
azimut has joined #lisp
mindCrime has quit [Ping timeout: 244 seconds]
it3ration has joined #lisp
<fourier>
ebrasca: there are different strategies, depending on the project size, but I would just have a look at the project you like and copy the style :)
<pjb>
aeth: or: (set-macro-character #\[ (lambda (s c) (declare (ignore c)) (cons 'funcall (read-delimited-list #\] s t))) nil) (set-syntax-from-char #\] #\)) ((lambda (f x) [f x]) 'sin 42)
<pjb>
Of course, you can choose other parentheses from unicode.
<pjb>
(lambda (f x) ⟮f x⟯)
rpg has quit [Remote host closed the connection]
it3ration has quit [Ping timeout: 246 seconds]
<pjb>
or perhaps (lambda (f x) ⦅f x⦆)
v0|d has quit [Ping timeout: 245 seconds]
<fouric>
not the unicode
<fouric>
please
<pjb>
Why not?
<pjb>
It's old already!
varjag has quit [Ping timeout: 244 seconds]
skidd0 has quit [Quit: WeeChat 2.2]
iskander has quit [Read error: Connection reset by peer]
it3ration has joined #lisp
rumbler31 has joined #lisp
<fouric>
because it looks weird with my comic sans terminal font
gravicappa has quit [Ping timeout: 272 seconds]
ealfonso has joined #lisp
<aeth>
Anyone who uses a lambda reader is evil
<aeth>
Just turn lambda to the Greek letter at your end, in Emacs. It won't impact the indentation at all because (lambda (x)\n is the style... unless you have (lambda (x\n