<edgar-rft>
Another problem is that neither the book's website nor the Apress site has any useful hints what the book contains in regards to practical examples. Has any of you already read the book?
<edgar-rft>
Somehow I managed to totally miss the release of Vsevolod Domkin's book "Programming Algorithms in Lisp":
Alfr_ has joined #lisp
<beach>
edgar-rft: It was available as a public website before it was published, and I read it then. Phoe read it too.
<beach>
As I recall, it is all about practical examples, such as trees, hash tables, etc.
Alfr has quit [Ping timeout: 268 seconds]
<edgar-rft>
but what's so terribly new about trees and hash-tables?
<edgar-rft>
my problem is that the apress text gives me the impression that the book is full of useless vague blah. I'm quite sure that is not the case, but *what* exactly is the point of that book?
<beach>
Not much. But the code is in Common Lisp. And he has opinions about different ways of coding hash tables, and how they behave with respect to threads.
<beach>
Not much is new, I mean.
<edgar-rft>
ah, *threads* is an interesting word :-)
bacterio has quit [Ping timeout: 272 seconds]
<beach>
Also, don't think that everything has been said about algorithms, given that half the books written by gurus in algorithms and data structures get something simple like binary search wrong.
buffergn0me has joined #lisp
isaac_ has joined #lisp
dbotton_ has quit [Remote host closed the connection]
<beach>
Oh, and many authors still seem to believe that a memory access and a register operation have roughly the same cost. There is room for books on algorithms that take modern architectures into account.
mange has quit [Ping timeout: 246 seconds]
<edgar-rft>
Of course there are many ways to shoot yourself into the foot with wrong algorithmes on complex data structures and it's always useful to read *other* people's opinion about that, and using threads in Common Lisp is a science of its own, I think I'll order a copy of that book. Thank you :-)
<beach>
Sure.
Stanley00 has joined #lisp
judson_ has joined #lisp
cantstanya has quit [Ping timeout: 240 seconds]
cantstanya has joined #lisp
rtypo has quit [Ping timeout: 256 seconds]
goldcell has joined #lisp
tamarindo has quit [Ping timeout: 240 seconds]
buffergn0me has quit [Quit: ERC (IRC client for Emacs 26.2)]
luckless has quit [Ping timeout: 240 seconds]
flip214 has quit [Ping timeout: 240 seconds]
Fare has quit [Ping timeout: 264 seconds]
flip214 has joined #lisp
feliocrat has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
tamarindo has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
flip214 has quit [Ping timeout: 260 seconds]
renzhi has quit [Ping timeout: 272 seconds]
wxie has joined #lisp
Bhartrihari has left #lisp ["Disconnected: closed"]
luckless has joined #lisp
stoneglass has quit [Quit: stoneglass]
saganman has joined #lisp
Bhartrihari has joined #lisp
Bike has quit [Quit: Lost terminal]
judson_ has joined #lisp
mange has joined #lisp
judson_ has quit [Client Quit]
Aurora_v_kosmose has quit [Quit: Пока, мир.]
Aurora_v_kosmose has joined #lisp
gproto023 has joined #lisp
gproto23 has quit [Ping timeout: 256 seconds]
gproto023 has quit [Quit: Leaving]
flip214 has joined #lisp
mange has quit [Remote host closed the connection]
Bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
Bhartrihari has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
kiroul has quit [Ping timeout: 246 seconds]
SN_ has joined #lisp
andinus has quit [Remote host closed the connection]
andinus has joined #lisp
red-dot has quit [Ping timeout: 272 seconds]
SN_ is now known as red-dot
Kundry_Wag has joined #lisp
torbo has quit [Remote host closed the connection]
Kundry_Wag has quit [Ping timeout: 240 seconds]
mmohammadi9812 has quit [Ping timeout: 240 seconds]
shifty has quit [Ping timeout: 260 seconds]
mmohammadi9812 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
bocaneri has joined #lisp
Bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
Bhartrihari has joined #lisp
shka_ has joined #lisp
Codaraxis_ has joined #lisp
narimiran has joined #lisp
johnweldon has joined #lisp
jw4 has quit [Ping timeout: 260 seconds]
kagevf has quit [Ping timeout: 260 seconds]
kagevf has joined #lisp
Codaraxis has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
ljavorsk has joined #lisp
Kundry_Wag has quit [Ping timeout: 256 seconds]
jprajzne has joined #lisp
orivej has joined #lisp
ljavorsk has quit [Ping timeout: 256 seconds]
pankajsg has quit [Ping timeout: 240 seconds]
goldcell has left #lisp ["Konversation terminated!"]
pankajsg has joined #lisp
femi has quit [Ping timeout: 256 seconds]
femi has joined #lisp
Nilby has joined #lisp
daphnis has joined #lisp
orivej has quit [Ping timeout: 272 seconds]
random-nick has joined #lisp
Alloc has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
<daphnis>
is it possible to turn off sbcl warnings about using setq on undefined vars?
pillton has quit [Read error: Connection reset by peer]
<beach>
You wouldn't want that.
<beach>
Code that does that is not conforming.
<daphnis>
it's just that i'm reading an old book (keene) with examples like that
<beach>
Just replace it with DEFPARAMETER.
<daphnis>
i don't think defparameter returns the object. it's not a big deal, but i don't need the warnings right now
<easye>
daphnis: use ccl?
<beach>
It is interesting how our view of default behavior like that has changed over time.
<beach>
The book "The CLOS perspective" says that DEFMETHOD is the normal interface for defining a generic function, but we no longer think that is a good idea, and that instead it should warn.
<easye>
beach: common commercial practice over the last decade seems to be predominantly DEFMETHOD, though.
<beach>
That is very sad to hear.
<beach>
Not surprising though, since commercial is not necessarily good.
<easye>
Don't shoot the messenger.
<easye>
"not necessarily good": ouch.
<beach>
OK, "frequently pretty bad" then?
<easye>
I like the "tightness" of every method defined in the DEFGENERIC, but that form can grow to large lengths.
<easye>
"frequently pretty bad" other than convention, what does one lose by using DEFMETHOD.
<easye>
?
<beach>
That practice is possible only if all methods are naturally defined in the same module.
terpri has quit [Ping timeout: 264 seconds]
<beach>
easye: It won't catch typos.
<easye>
One defense of DEFMETHOD would be when I extend an existing generic method hierarcy, say in ASDF.
<beach>
As a result, you will have mysterious bugs that take time to find.
<beach>
I have nothing against defmethod. My problem is the absence of DEFGENERIC.
<easye>
s/hierarcy/hierarchy/
<beach>
The book says that DEFGENERIC is not normally used.
<easye>
"absence of DEFGENERIC" Ah, I understand and agree with that problem.
<beach>
Just like I have nothing against SETQ or SETF, just the absence of DEFVAR or DEFPARAMETER.
<easye>
Agreed.
<easye>
It certainly helps out compiler writers/maintainers.
<beach>
"It"?
<easye>
"it": declaring variables with DEF* even if you manipulate them with SET*
terpri has joined #lisp
<beach>
That's not "declaring". That's "defining".
shifty has joined #lisp
<easye>
Alright, corrected.
* easye
ponders the distinction between declaring and defining.
<easye>
Larnin' me some CONS today. Thanks!
<beach>
Pleasure.
<flip214>
beach: re declare/define: which would (makunbound '*my-var*) be? just declaring, I guess
<ck_>
or "undefining"
<flip214>
yeah, a "value" is defined - the unbound value, though
<daphnis>
is it just i or is chapter 24 in Practical suddenly very difficult
<beach>
The meaning of "declare" or "declaration" is quite clear in the standard, as I recall.
<easye>
daphnis: refresh my memory, what is the title of Chap. 24 of _PCL_?
<ck_>
parsing binary files
<beach>
"declare" to establish a declaration. See declare, declaim, or proclaim.
<easye>
Oh. That's where it got real interesting.
<beach>
flip214: makunbound is not in the list.
<easye>
I went off and implemented my own MP3 ID3 parser off of that.
liberliver has joined #lisp
tiwEllien has joined #lisp
<flip214>
beach: ah, so MAKUNBOUND is defining after all. thanks
<beach>
That I am not sure about. Common Lisp is not all about declarations and definitions.
<beach>
"defining form" a form that has the side effect of establishing a definition.
<beach>
Nothing more specific.
leo_song_ has joined #lisp
leo_song has quit [Ping timeout: 240 seconds]
daphnis has quit [Ping timeout: 258 seconds]
<lukego>
hey is there an idiom anywhere e.g. in alexandria or serapeum for having generic function versions of primitives? e.g. a version of EQUAL that can be specialized on whatever kinds of objects.
<beach>
lukego: As Pitman explains, that is not a good idea, and not possible in general.
<beach>
You would need an additional parameter, like SITUATION.
<beach>
The phone company thinks me and my wife are equal, because we have the same phone number. But social security does not.
<lukego>
yeah I suppose that I'm only really looking for a shorthand for aggregating my own equality predicts, so the implied situation is "in the context of this program I'm writing", and then it probably makes sense to define my own generic function because I wouldn't want other people's methods. thanks for the sanity-check.
<lukego>
(I'm mostly tiring of writing ":test #'foo=" types of sequences over and over)
<beach>
Sure, good luck.
<beach>
Yes, then just shadow the predicates you want to alter the behavior of.
<beach>
The names of them I mean.
<lukego>
Tricky business. what I'd really like to do is have my own generic function be the default :TEST for various library functions e.g. from alexandria and serapeum. But only for code belonging to specific packages in which this is idiomatic. So I guess I'd end up having to shadow all those alexandria/serapeum functions and that sounds like a mess.
<beach>
It does. I don't think the resulting mess would be worth the effort.
<lukego>
indeed
<lukego>
(I guess this is what parameterized modules are about in other languages)
<lukego>
(and I don't know if _that_ mess is worth it either :-))
<beach>
Yeah.
<lukego>
I always wanted parameterized modules in Erlang, until they actually added them to the language, and then I really didn't want to use them :)
<beach>
Heh.
pve has joined #lisp
<lukego>
Lisp and C feel a bit alike in this respect. There are lots of shiny things from the modern era that you can imagine adding to them. Then you see people do exactly that and you think, yeah nah, maybe it was a better idea to just keep it simple and embrace the past :)
bars0 has joined #lisp
skapata has joined #lisp
<beach>
Certainly, C++ is a good example from the C world. And the madness has not finished yet.
OlCe` has quit [Ping timeout: 246 seconds]
<shka_>
The Endless Madness
<shka_>
that's what it si
<shka_>
but in the case of C++ it is not the sheer number of features
<shka_>
but the fact that the features don't really work together well
<shka_>
that's why I personally consider CL to be a well designed language: it's features work together
aaaaaa has joined #lisp
<shka_>
for instance generic functions can be passed around just like normal functions
<shka_>
so compatibility between first order functions and generic functions is maintained
<shka_>
in
<shka_>
and macros simply make everything else in the language more useful
pankajsg has quit [Ping timeout: 260 seconds]
<shka_>
damn i like CL
chrpape` has joined #lisp
chrpape has quit [Read error: Connection reset by peer]
aaaaaa has quit [Quit: leaving]
Kundry_Wag has joined #lisp
Krystof has joined #lisp
Kundry_Wag has quit [Ping timeout: 260 seconds]
Kundry_Wag has joined #lisp
judson_ has joined #lisp
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
ljavorsk has joined #lisp
Kundry_Wag has quit [Ping timeout: 264 seconds]
<easye>
Is there a way to force the Lisp PRINT routines to output symbols with package prefixes for all symbols regardless of their presence in the current package?
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
OlCe`` has joined #lisp
daphnis has joined #lisp
frost-lab has joined #lisp
Necktwi has joined #lisp
Bourne has joined #lisp
Nilby has quit [Ping timeout: 260 seconds]
Nilby has joined #lisp
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
Bourne has quit [Ping timeout: 258 seconds]
<Posterdati>
hi
daphnis has quit [Ping timeout: 258 seconds]
<beach>
Hello Posterdati.
<phoe>
heyyyy
<Posterdati>
how are you people?
<phoe>
sleepy
<Posterdati>
:)
<phoe>
third day of intense box-packing
<Posterdati>
phoe: ?
<phoe>
like, major reorganization of space in our flat
<Posterdati>
ah
<Posterdati>
my practice in this matter is pack stuff in every empty space and let the stacks grow until there's no sunlight coming from the window, then throw entire stacks and startover...
<phoe>
in my case it is more like imagine a copying GC but you do not have enough space to make two completely distinct heaps so you need to try and move things piece by piece
<Posterdati>
ah nice
<Posterdati>
please help, is there's a way to invert bordeaux-threads:semaphore mechanism, I need something tha put threads on hold UNTIL count reaches or overflow a value... Thanks!
<cl-arthur>
phoe: alloc into the neighbour flat :)
yonkunas has quit [Ping timeout: 260 seconds]
splittist has quit [Ping timeout: 272 seconds]
<phoe>
Posterdati: how many wakeups are allowed?
RagnarDanneskjol has quit [Read error: Connection reset by peer]
mjl has quit [Read error: Connection reset by peer]
<phoe>
cl-arthur: I've tried that, I got a SIGSEGV
ffwacom has quit [Ping timeout: 260 seconds]
mgsk has quit [Ping timeout: 260 seconds]
RagnarDanneskjol has joined #lisp
yonkunas has joined #lisp
mjl has joined #lisp
mgsk has joined #lisp
<shka_>
Posterdati: isn't it simpler to just wait for every pending thread?
<shka_>
or whatever
l1x has quit [Ping timeout: 272 seconds]
Nilby has quit [Ping timeout: 256 seconds]
splittist has joined #lisp
ffwacom has joined #lisp
l1x has joined #lisp
<Posterdati>
shka_: I mapcar and reduce thread-alive-p
<cl-arthur>
phoe: *grin*
<Posterdati>
shka_: but the threads shall not exit the are basically never ending loops
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<Posterdati>
shka_: but yes it would be better to do like you said
<shka_>
well, what i usually do is to use lparallel and futures
<flip214>
Posterdati: let them sleep on a semaphore and wake all of them up at once?
<shka_>
but if you can't do this, simply use condition variables
mmohammadi9812 has quit [Ping timeout: 256 seconds]
<Posterdati>
flip214: the threads wait on a condition variable, the main threads notifies it and threads start to compute, they end at very different times
<shka_>
then you can simply notify once you finish your job
<Posterdati>
shka_: I need to wait all threads complete the jobs to startover again
<shka_>
Posterdati: sure, but why not just loop over all your CVs waiting for the task
<shka_>
once one is finished, it IS finished, right?
<shka_>
it can't become unfinished again?
<Posterdati>
no it can't restart
amb007 has quit [Read error: Connection reset by peer]
<Posterdati>
so I need to recreate the threads every time and put them on wait
amb007 has joined #lisp
<Posterdati>
then wait for them to finish
<shka_>
ok, you know what? just take lparallel:promise
<Posterdati>
shka_: what is it?
<shka_>
well, lparallel is pretty awesome lisp library for more high level multi-threading
<shka_>
has operations like pmap which is parallelized version of map
<Posterdati>
shka_: ah, ok! Thanks!
<shka_>
it also has thread pool
<shka_>
i use it a lot
<shka_>
anyway, it also offers you more sophisticated synchronization tools like futures and promises
<shka_>
so when you are sending task to your OWN thread, you can create promise, fullfill it in your thread while the waiting thread just calls FORCE
<shka_>
and force blocks until fullfill is called
<shka_>
also, i suspect that you can use lparallel instead of your own threads
<shka_>
i usually can
<shka_>
and if i can, i ALWAYS do
<shka_>
because it is that good
<Posterdati>
ok...
<shka_>
it is really nice to simply do (lparallel:future (this-function-will-take-significant-time-to-finish-so-it-is-sended-to-a-worker))
mmohammadi9812 has joined #lisp
mmohammadi9812 has quit [Read error: Connection reset by peer]
<shka_>
and just lparallel:force the resulting object to get the output
<shka_>
OH
<shka_>
and lparallel:force on object that is not promise will turn into identity
<shka_>
imagine how useful this is
<shka_>
lparallel FTW
cosimone has joined #lisp
<shka_>
but anyway, you can just use promise with your own threads
mmohammadi9812 has joined #lisp
judson_ has joined #lisp
<shka_>
or lparallel synchronized queues
<shka_>
but i urge you to learn the whole thing, it is beyond useful
OlCe`` has quit []
orivej has joined #lisp
cosimone has quit [Client Quit]
<Posterdati>
shka_: thanks for help
ldb has joined #lisp
<flip214>
Posterdati: well, how about using LPARALLEL?
<shka_>
flip214: you have some bad lags :D
<Posterdati>
flip214: I will look for it :)
<flip214>
oh, shka_ already said that.... answered before reading all of the backlog
escanda has joined #lisp
OlCe has joined #lisp
<shka_>
flip214: but that's another vote for lparallel, am i right?
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
cosimone has joined #lisp
daphnis has joined #lisp
judson_ has joined #lisp
madage has quit [Ping timeout: 240 seconds]
<mfiano>
I would like to learn more about lparallel futures/promises myself. I use lparallel a lot in a large project, but the websites gets me lost with regard to those, and I keep thinking they would help me in this complicated project if i understood them better.
madage has joined #lisp
<ldb>
?
<shka_>
mfiano: i don't get chaining either
ldb has quit [Quit: [BX] Man I'm *SLEEPY*!!!! My keyboard is slipping away!]
<mfiano>
For this project, I just use simple thread pool management, because I ran into callback hell with many levels of asynchronous tasks
<selwyn>
Gnuxie[m]: if you turn up the brightness and contrast in the gov's congratulations tweet to biden, you can find the remains of a congratulatory message to trump
<selwyn>
sorry wrong channel
<flip214>
shka_: yes, I'm using it too
<flip214>
well, pmapcar etc. has always been good enough for me ;)
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
escanda has left #lisp ["Disconnected: closed"]
<daphnis>
does there happen to be a noun such that x is a <noun> of y iff y is a member of x?
aaaaaa has joined #lisp
treflip has joined #lisp
Kundry_Wag has joined #lisp
<phoe>
daphnis: you mean a set theory noun?
<phoe>
then X is a subset of Y if Y is also a set, or X contains Y if Y is an element of that set
<beach>
phoe: I am thinking "container" rather.
<beach>
Y is not a set, but X is.
<daphnis>
phoe: yes
<daphnis>
thanks
<daphnis>
yes, container was what i thought, but i thought there also might be something better or more idiomatic
Kundry_Wag has quit [Ping timeout: 260 seconds]
seok has joined #lisp
imode has quit [Ping timeout: 240 seconds]
kreyren has joined #lisp
<kreyren>
can i use asdf to handle CXX project?
* kreyren
is annoyed with cmake and meson using scripting language to make people suffer
<jackdaniel>
kreyren: yes, but it will be up to you to provide necessary asdf method specializations
<kreyren>
jackdaniel, eh?
<jackdaniel>
asdf has multiple methods responsible for compilation, loading, building etc
<kreyren>
i would prefer some already written backend tbh because that's adding maintainance..
<jackdaniel>
these methods operate on "component types", by default asdf recognizes "module", "file" (common lisp) and a "static-file" (I think that there are a few more)
<kreyren>
x.x
<jackdaniel>
it is possible to extend the set of existing components (and there are libraries that do exactly that) -- adding "c file compilation" is not hard if you know the underlying abstraction
<jackdaniel>
but yes, there is no out-of-the-shelf solution
<kreyren>
>.>
<kreyren>
going to research then
Stanley00 has quit [Remote host closed the connection]
treflip has quit [Quit: WeeChat 2.6]
Mandus has quit [Quit: Changing server]
<jackdaniel>
if you buy into mindset, that for compiling "hello world" program you use some heavy infrastructure that requires >8gb of ram, then you could use bazel, fare who was asdf maintainer endorsed this piece of software in the past as "the right thing"
daphnis has quit [Ping timeout: 256 seconds]
kaftejiman has joined #lisp
<jackdaniel>
I think that the system cffi-grovel extends asdf in a way that requires compiling C files, so that could be your rod
Mandus has joined #lisp
<Shinmera>
kreyren: don't bother, asdf is not made for stuff like C toolchains.
<kreyren>
:C
<kreyren>
nothing is made for C/CXX toolchains!
<kreyren>
other then sucky mini-languages >.>
<Shinmera>
the effort required to bend asdf is way larger than to just use cmake.
<phoe>
a bold statement, especially since it's made for ones of the most famous programming languages in the world that have over a dozen of distinct build systems
gareppa has joined #lisp
daphnis has joined #lisp
shifty has quit [Ping timeout: 256 seconds]
cl-arthur has quit [Ping timeout: 240 seconds]
bars0 has quit [Quit: leaving]
cl-arthur has joined #lisp
<kreyren>
Shinmera, tbh it's more pleasable to rewrite asdf then handle strings for everything like cmake
<Shinmera>
if you think you have an easier time with asdf your c project is trivial and you could just as well just use a makefile.
<Shinmera>
reproducing the actual work and knowledge tools like cmake have for you takes a huge amount of effort.
<kreyren>
this is CXX and it's currently just creating statically or dynamically linked program with options
<kreyren>
Shinmera, ^
<Shinmera>
What do you want me to say
<kreyren>
so basically thing that executes `g++ ...`
<phoe>
this is a very simple project then and standard utilities like make will do just fine - unless you have tens of differently configurable options
<phoe>
still, that's already a #lispcafe kind of discussion since it has nothing to do with Lisp and very little to do with ASDF itself
pankajsg has joined #lisp
<kreyren>
phoe, it has lots of configuration options >.>
<jackdaniel>
this advice may sound silly at first, but hear me out -- rewrite these files to common lisp :-)
isaac_ has quit [Ping timeout: 265 seconds]
<phoe>
kreyren: how many of those options? tens? hundreds? thousands?
<kreyren>
jackdaniel, that's in plan.. the end-goal is to compile this (with lots of changes) depending on benchmarks
<kreyren>
phoe, currently tens expecting <50
<kreyren>
over time possibly more
cmatei has quit [Remote host closed the connection]
EvW has joined #lisp
semz has quit [Quit: Leaving]
aaaaaa has quit [Read error: Connection reset by peer]
aaaaaa has joined #lisp
kaftejiman_ has joined #lisp
cmatei has joined #lisp
kaftejiman has quit [Ping timeout: 260 seconds]
frost-lab has quit [Quit: Connection closed]
Kundry_Wag has joined #lisp
EvW has quit [Ping timeout: 244 seconds]
Bike has joined #lisp
rtypo has joined #lisp
Lycurgus has joined #lisp
escanda has joined #lisp
dbotton has joined #lisp
Bourne has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
daphnis has quit [Ping timeout: 256 seconds]
escanda has left #lisp [#lisp]
Lycurgus has quit [Quit: Exeunt]
ljavorsk has quit [Ping timeout: 260 seconds]
dbotton_ has joined #lisp
dbotton has quit [Ping timeout: 240 seconds]
Gerula has quit [Quit: Leaving]
Gerula has joined #lisp
cosimone has quit [Quit: cosimone]
bitmapper has quit [Quit: Connection closed for inactivity]
rwcom60280385034 has joined #lisp
renzhi has joined #lisp
ex_nihilo has joined #lisp
kiroul has joined #lisp
Stanley00 has joined #lisp
kir0ul_ has joined #lisp
wsinatra has joined #lisp
kiroul has quit [Ping timeout: 258 seconds]
Stanley00 has quit [Ping timeout: 265 seconds]
Fare has joined #lisp
igemnace has joined #lisp
TwoNotes has joined #lisp
aindilis has quit [Ping timeout: 256 seconds]
TwoNotes has quit [Client Quit]
eliocrat has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
tamarindo has quit [Remote host closed the connection]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
gareppa has quit [Read error: Connection reset by peer]
wsinatra has quit [Read error: Connection reset by peer]
tamarindo has joined #lisp
Bourne has quit [Read error: Connection reset by peer]
judson_ has joined #lisp
feliocrat has quit [Quit: Leaving]
eliocrat has quit [Quit: Leaving]
feliocrat has joined #lisp
kiroul has joined #lisp
kir0ul_ has quit [Ping timeout: 264 seconds]
igemnace has quit [Remote host closed the connection]
sjl_ has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
igemnace has joined #lisp
<eta>
how does one read from raw memory in SBCL?
<phoe>
eta: cffi:mem-ref
<eta>
phoe: cheers!
* eta
is exploring the idea of writing a self-hosting common lisp implementation, with a Cranelift backend
<phoe>
as in, it turns Rust code into some kind of IR?
<jackdaniel>
so you plan to combine the common lisp type safety with rust's speed of compilation?
<eta>
no, it turns some kind of IR into machine code
<eta>
and is written in Rust
<phoe>
oooh, okay
<eta>
the plan is to write a CL->IR thing in CL
<eta>
compile cranelift to a massive .a, use CL to mmap that and execute it
<eta>
and thus avoid any kind of glibc or C dependency
<eta>
(if I wanted a C dependency I could use LLVM, but that makes things like 10 times more annoying)
<phoe>
the first step is kind of a solved problem, many Common Lisp compilers have this kind of CL-to-IR step
<phoe>
the question is how the IR generated by those maps to the IR accepted by cranelift
<eta>
well I'm doing this from scratch as a complete dunce, partially because it'll be fun (he hopes)
<phoe>
and how easy and safe is it going to be to call cranelift from Lisp and then load the resulting binary code back into the image
chour has joined #lisp
<eta>
indeed
<eta>
well I'm working on that latter part now
<phoe>
and which Common Lisp implementation you are going to use as your test bed for gutting out its native code generator
<phoe>
because I don't think you'll want to reimplement LOOP, FORMAT, CLOS, the condition system and what not
<eta>
well all of those parts are pure CL, right?
<eta>
so in theory that's just a solved problem and you copy-paste liberally
<phoe>
copy-paste from code that is already customized by almost every implementation in question
<phoe>
hence my question, which impl you're going to use
eliocrat has joined #lisp
Bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
Bhartrihari has joined #lisp
<phoe>
which flavor of Common Lisp you're going to fork from
<eta>
my answer right now is "no idea, I'll cross that bridge once I have the absolute basics of a Lisp working"
chour has left #lisp ["WeeChat 2.9"]
<phoe>
what do you mean by these absolute basics?
<eta>
good question :p
<jackdaniel>
start with eval ,-)
<eta>
well, yeah, cdr/car/eval/cond and friends
<eta>
but yeah, I will probably need to define that more narrowly
<eta>
phoe, I mean you have your portable condition system, but looking at that, it looks like it needs CLOS
herlocksholmes has joined #lisp
<eta>
looks like I probably want to extract PCL from something
Bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
Bhartrihari has joined #lisp
<Shinmera>
it looks like every year someone comes in here thinking making another implementation is an easy job of just copying some lisp parts once you have a runtime :)
daphnis has joined #lisp
<jackdaniel>
npm import common-lisp-runtime
<jackdaniel>
voila
<eta>
Shinmera, that's a worrying statement :p
<eta>
I mean the runtime is the fun part
* eta
isn't too bothered about getting 100% coverage of the common lisp spec
<eta>
also wow, reading ELF files from scratch is a huge pain in the arse
<Shinmera>
If I remember correctly it took drmeister years to get clasp up and running well, even after copying most of the code from ECL.
<shka_>
well, on the other hand the mad lad actually managed to pull it off
<Shinmera>
Against all odds, sure. But those are some very big odds.
<shka_>
imagine doing the same for some other programming languages :-)
<Shinmera>
I can think of a couple other projects that did not manage it.
<eta>
*years*?!
<eta>
oh balls
<shka_>
eta: yeah, drmeister is hardcore
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jackdaniel>
hard problems are easy given enough time ,-)
<eta>
eh, I mean I've at least got one year of not very challenging university course to fill with something
<Shinmera>
Plenty of other ways to fill that time :)
<eta>
this seems fun though
<shka_>
well, maybe you want to help beach with SICL?
<eta>
disclaimer: my opinion will probably change swiftly
<shka_>
if you are that interested in CL implementations
<beach>
I am taking help only from a selected few at this point.
<shka_>
oh, ok, i wasn't aware of that
<shka_>
sorry
<eta>
I mean it's more that I'm interested in compilers but haven't really had any experience
<shka_>
still, if you wanna see some slick implementation attempt i guess SICL is still something to study
<eta>
Lisp seems like a nice thing to start with
<eta>
shka_, ack, thanks for the pointer
<jackdaniel>
then writing common lisp from scratch is quite bold move ,)
<jackdaniel>
if you have no experience
<jackdaniel>
minion: tell eta about LiSP
<minion>
eta: please look at LiSP: "Lisp in Small Pieces". This book covers Lisp, Scheme and other related dialects, their interpretation, semantics and compilation. To sum it up in a few figures: 500 pages, 11 chapters, 11 interpreters and 2 compilers. <http://pagesperso-systeme.lip6.fr/Christian.Queinnec/WWW/LiSP.html>
<eta>
nifty
<shka_>
eta: thing is that CL is pretty big language
<beach>
eta: Did you at least watch my first parts of the online Lisp meeting series "Creating a Common Lisp implementation"?
<shka_>
maybe something closer to LISP1.5 would be easier
<eta>
shka_, probably! I'm not dead set on doing the whole of CL
<eta>
beach, I did not, but I will now :)
<beach>
eta: They tell you what kind of trouble you would run into when choosing the strategy you just described.
<eta>
oh great
<beach>
The next part will be about the problem you run into if you bolt on CLOS at the end.
<Posterdati>
shka_, flip214: lparallel is GREAT! Thanks for suggesting it!
<shka_>
Posterdati: cheers!
<shka_>
and yes, it really, really is
Bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
Bhartrihari has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
<Posterdati>
shka_, flip214, please a question, does receive-result wait for task completion?
<shka_>
hm, i think so, but let me check, ok?
<Posterdati>
shka_: where I can paste my whole little test project, so you can see that?
<Posterdati>
shka_: receive-result is what I was looking for!
<shka_>
actually, i think that there is pretty good example somewhere in the manual, just let me find it
<shka_>
i usually use futures
<Posterdati>
shka_: no! Where I can paste my project to show it to you?
<shka_>
IIRC recieve-results blocks until result can be obtained
<shka_>
most likely it does what you want
<Posterdati>
I created a channel per task (2 tasks)
<shka_>
and just one result?
<shka_>
get your code on pastebin
Bhartrihari has left #lisp ["Disconnected: closed"]
Bhartrihari has joined #lisp
<Posterdati>
shka_: no I looped over the channels ang receive-result for every one
<shka_>
ok
aaaaaa has quit [Ping timeout: 272 seconds]
Bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
Bhartrihari has joined #lisp
EvW has joined #lisp
<shka_>
well, i would simply would first map-into futures and then loop over them and force but obviously what you are doing works as well
niceplace has quit [Ping timeout: 264 seconds]
<shka_>
so cheers
ex_nihilo has quit [Remote host closed the connection]
Bhartrihari has left #lisp ["Disconnected: closed"]
Bhartrihari has joined #lisp
ex_nihilo has joined #lisp
<Posterdati>
shka_: what if I create one channel, submit one task and then loop over results from that channel?
wsinatra has joined #lisp
<eta>
beach, I posit that some of the complications you describe can be avoided by making your implementation self-hosting; for example, you can use the bootstrap implementation's macroexpander
<shka_>
Posterdati: you want to read more then you sent?
<shka_>
that's what you are discussing?
<beach>
eta: The "macroexpander"? That's just the macro function for each macro. Do you mean using the host macros? Have you looked at the expansion of some macros, say DEFUN, in, say SBCL?
<beach>
They are quite implementation specific.
<eta>
beach: well, I mean you could do something like what macroexpand-dammit does
<beach>
eta: I look forward to your progress reports.
<beach>
eta: I am not entirely sure what you have in mind, so I can't criticize too much.
<beach>
eta: If you are on to something, more power to you.
<Bike>
the first line of the readme on macroexpand-dammit says "I do not generally recommend this library, either the original version or this version, because both contain bugs."
<Bike>
guicho's version, anyway, and guicho does all kinds of compilery junk so i believe them
<beach>
eta: I also don't know the meaning of "self hosting" in this context.
<eta>
beach: i.e. never writing any C
hendursaga has joined #lisp
<beach>
Ah, OK.
<eta>
the compiler would be written entirely in CL (apart from cranelift)
<eta>
like Rust
<beach>
eta: It sounds like you are interested in doing this partly to learn about compilation and such. If that hadn't been the case, I would recommend you use the Cleavir implementation-independent compiler framework.
Stanley00 has joined #lisp
<eta>
beach: thanks for the pointer; I might well end up taking a look at that if I get stuck or give up with doing my own crazy thing
<Posterdati>
shka_: no
<Bike>
not like cleavir is remotely complete. you could probably learn plenty. doesn't really have its own backend, tho.
<shka_>
Posterdati: then i don't get
<Posterdati>
shka_: I did the magic with one channel and multiple tasks :)
<shka_>
well, channel will block until something arrives so this will work either way
<Posterdati>
shka_: I created one channel, submitted two tasks, then collect their results, then start over if they all completed
<shka_>
just remember that if worker crashes you will never get your results and you will be hanging on the channel
<shka_>
instead you can define call-thread-function function or something
<shka_>
would be more elegant imho
<shka_>
or just stick it in the line 78
<shka_>
sorry for formatting
<shka_>
you are using tabs
galex-713 has quit [Ping timeout: 246 seconds]
edgar-rft has quit [Read error: Connection reset by peer]
edgar-rft has joined #lisp
Bhartrihari has left #lisp ["Disconnected: Replaced by new connection"]
Bhartrihari has joined #lisp
PetitOrion has joined #lisp
<Posterdati>
shka_: what is "force"?
seok has quit [Remote host closed the connection]
<jmercouris>
m*a?
<phoe>
Posterdati: it is a function that forces a promise; either it returns the promise's returned value, or it blocks until the promise resolves
<phoe>
so, basically, "block until this promise is resolved, and return its value"
<Posterdati>
phoe: ah ok, is what I need
hendursaga has quit [Remote host closed the connection]
hendursaga has joined #lisp
galex-713 has joined #lisp
torbo has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
drl has quit [Quit: Leaving]
camlriot42 has joined #lisp
Fare has quit [Ping timeout: 264 seconds]
hnOsmium0001 has joined #lisp
Fare has joined #lisp
dbotton has joined #lisp
dbotton_ has quit [Ping timeout: 246 seconds]
pankajsg has quit [Ping timeout: 246 seconds]
dbotton_ has joined #lisp
dbotton has quit [Ping timeout: 272 seconds]
dbotton has joined #lisp
dbotton_ has quit [Ping timeout: 258 seconds]
choegusung has quit [Ping timeout: 256 seconds]
ex_nihilo has quit [Quit: Leaving]
<mfiano>
how is that different from lparallel:receive-result, which also blocks until a result comes down the channel?
<Posterdati>
shka_: your code does not work :(
<shka_>
Posterdati: weird
bitmapper has joined #lisp
choegusung has joined #lisp
escanda has joined #lisp
<Posterdati>
shka_: in your example, the quicker task wins on the result, because force won't block
EvW has quit [Ping timeout: 260 seconds]
saganman has quit [Ping timeout: 264 seconds]
Stanley00 has joined #lisp
Steeve has quit [Quit: end]
Stanley00 has quit [Ping timeout: 272 seconds]
aeth has quit [Ping timeout: 264 seconds]
galex-713_ has joined #lisp
galex-713 has quit [Ping timeout: 272 seconds]
jibanes has quit [Ping timeout: 256 seconds]
aeth has joined #lisp
galex-713_ has quit [Ping timeout: 272 seconds]
jibanes has joined #lisp
<Alfr_>
Posterdati, you want to directly use promises for that, not futures, I think. If a future is not fullfilled when forced, the current thread runs body to fulfill it.
EvW has joined #lisp
galex-713 has joined #lisp
rumbler3_ has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
<Alfr_>
But for promises, you have to set a value using fulfill explicitly (possibly in an other thread), otherwise the force will simply block forever.
jibanes has quit [Ping timeout: 240 seconds]
mmohammadi9812 has quit [Quit: Quit]
jibanes has joined #lisp
asdflkj has joined #lisp
PetitOrion has left #lisp ["Quitte"]
choegusung has quit [Quit: leaving]
aaaaaa has joined #lisp
zxcvz has joined #lisp
abbe is now known as abbe__
Steeve has joined #lisp
aaaaaa has quit [Quit: leaving]
Blukunfando has quit [Ping timeout: 264 seconds]
bocaneri has quit [Remote host closed the connection]
imode has joined #lisp
rippa has joined #lisp
leo_song_ has quit [Ping timeout: 246 seconds]
liberliver has quit [Ping timeout: 240 seconds]
Stanley00 has joined #lisp
judson_ has joined #lisp
Stanley00 has quit [Ping timeout: 260 seconds]
leo_song has joined #lisp
paule32_ has joined #lisp
<paule32_>
hello, and good afternoon
<paule32_>
i have a problem with installing/starting lisp