<PuercoPop>
pjb: Or too few. I'm politically inclined to prefer Mastodon. A few Lispers are already there.
<aeth>
pjb: The problem with Twitter is that it doesn't have Circles (R.I.P, Google+) so you go to some Lisper's Twitter expecting Lisp and get politics.
<aeth>
Twitter's broadcast (not friend) oriented, but that just means that there could be subpages or something
<pjb>
yes. Or you have to open several accounts, but switching accounts is bothering.
<aeth>
hmm I still have the G+ application and I haven't opened it in years
<aeth>
let's see what happens
<aeth>
a message that says it's no longer available
caltelt_ has joined #lisp
smasta has joined #lisp
libertyprime has quit [Ping timeout: 255 seconds]
libertyprime has joined #lisp
* p_l
is sad about G+ passing
<loke>
p_l: Me too. But it has taught me to never trust that Google will consistently provide a service anymore. I'm in the progress of moving my personal domain off of gmail.
libertyprime has quit [Ping timeout: 246 seconds]
<p_l>
Free services can disappear
<p_l>
I need to setup infrastructure for moving in general
Fare has quit [Ping timeout: 246 seconds]
libertyprime has joined #lisp
<loke>
p_l: sure, they can. But Google is worse than most when it comes to killing services.
<p_l>
Not really
<p_l>
They just pissed off a really loud segment once
<aeth>
loke: Google+ taught me never to trust that Google will consistently provide a service anymore... when they cancelled Google Reader and a bunch of other popular projects in an attempt to push people to Google+
<loke>
Reader was a particularly impressive level of fuck you
<loke>
Remember google talk? It had XMPP support
<loke>
I really liked Google Squared
torbo has quit [Remote host closed the connection]
akater has quit [Remote host closed the connection]
<aeth>
Google Talk was the last IM that I ever used. When they no longer supported XMPP, I basically stopped using IM
akater has joined #lisp
emaczen has joined #lisp
<loke>
Google Wave was cool too
<loke>
I started with Wave, then they killed it and I moved to Buzz, writing an Android client for it, and then when they killed _that_ I moved to G+, patiently waiting for an API.
<loke>
And the rest is history.
<p_l>
GReader honestly wasn't that much of a fuck you when looking from corporate PoV
<p_l>
They could have kept it, yes
<loke>
p_l: it was a fuck to to users.
<p_l>
loke: of whom there weren't as many, and RSS was fscking dying
<aeth>
other way around. RSS died because Google Reader was RSS
<p_l>
It still is dying
<loke>
p_l: I'm still using RSS for all the feeds I read daily. I don't see how it's dying any more than iut ever was.
<emaczen>
When you load CFFI what determines which C functions/data are accessible?
<loke>
emaczen: You
<p_l>
aeth: do you know that was the official reason for shuttering GReader?
<loke>
(assuming you are the developer)
<p_l>
Anti-monopoly
<loke>
p_l: I don't think there was one.
<pjb>
Nobody used it.
<aeth>
p_l: Google wanted to focus on fewer products
<emaczen>
loke: Is it just system calls that are available?
dale has quit [Quit: dale]
<LdBeth>
symbol space from C library
<emaczen>
LdBeth: From what C library?
patrixl has joined #lisp
<LdBeth>
From the library you want CFFI to load
<p_l>
loke: 1) reader had not as many users as we like to think 2) Google was doing a cleanup of projects 3) There was actual GReader monopoly 4) RSS was loosing to social media *hard*
<emaczen>
LdBeth: I understand cffi:define-foreign-library and cffi:load-foreign-library
<p_l>
All of those were not nice thing, but none of them made it a fuck you decision
rumbler31 has quit [Remote host closed the connection]
<emaczen>
But we never have to load system calls etc, so what other class of functions/data are implicitly given to us?
FreeBirdLjj has quit [Remote host closed the connection]
<LdBeth>
No, nothing else will be load
<p_l>
emaczen: the available names are the symbols available to dynamic link facility of the system
<p_l>
The names are taken from symbol table of the library you opened with CFFI
<p_l>
(which is part of the file)
<emaczen>
p_l: Yes, but what about before I define and load a foreign library?
<emaczen>
For example, if I just (asdf:load-system :cffi)
<p_l>
Then nothing is available
<p_l>
*except* for files already loaded
<emaczen>
I can then immediately proceed to use read(2) and write(2)
<loke>
p_l: I think you exactly describe a fuck you descition. You said that the only reason they shut it down was because they didn't have so many users. If that isn't a fuck you to the users they did have, I don't know what is.
<p_l>
loke: it's called business
<emaczen>
does CFFI load some system call shared object for us by default?
<LdBeth>
N9
<loke>
p_l: I don't see how that changes anything.
<loke>
But, let's just agree to disagree.
<LdBeth>
emaczen: are you sure u are calling read and write of C lib, cause Common Lisp has read and write
<emaczen>
Another way to phrase my question is, how does CFFI know about read(2)
<p_l>
emaczen: on Linux/glibc, CFFI ultimately calls to dlsym()
<aeth>
p_l: ironically, I wouldn't be surprised if Reader had more readers than Google+ did after the first few hype months
<p_l>
emaczen: dlsym will by default consult a global list of all loaded external/shared symbols of all objects
<aeth>
emaczen: does your code work?
<emaczen>
Okay, somewhere in CFFI during load, these "standard" system calls and C functions in "standard" header files are loaded via dlsym
<emaczen>
aeth: Of course haha!
<aeth>
emaczen: okay so you're only question is how
<p_l>
emaczen: So since libc.so is loaded already, its read function is on the list, and when you define C-read it gets picked up and its address loaded with dlsym
<p_l>
emaczen: no header files involved
<emaczen>
p_l: When/where is libc.so loaded?
<seok>
How do I create a pointer to an object without using a symbol?
<seok>
Is it possible?
<emaczen>
p_l: And more along the lines of precisely where, but I don't need extreme precise knowledge.
<pjb>
The object itself is a "pointer" to the object.
<pjb>
seok: there's actually no such notion of pointer in lisp.
<seok>
Ok, maybe I should get my terminology fixed
<p_l>
emaczen: since code on sbcl even abused that list by patching the entry to thread-related functions and ensuring some work was done so that SBCL kept control over signals
<pjb>
(loop with table = (make-hash-table) for key below 3 for object = (create-object) do (setf (gethash key table) object) collect object into list finally (return (values list table))) #| --> ("" "" "") ; #<hash-table :test eql size 3/60 #x30200472C59D> |#
<seok>
If I want to call these objects agaib, what do I do?
<jackdaniel>
speaking of, only 5 more open tickets before ECL release 16.2.0 (two of them are extensive tests)
angavrilov has joined #lisp
<no-defun-allowed>
fantastic
hhdave has joined #lisp
techquila has quit [Ping timeout: 250 seconds]
libertyprime has quit [Ping timeout: 246 seconds]
m00natic has joined #lisp
seok has quit [Quit: Connection closed for inactivity]
smasta has joined #lisp
smasta has quit [Ping timeout: 245 seconds]
libertyprime has joined #lisp
<phoe>
<3
glv has joined #lisp
pankajgodbole has joined #lisp
MightyJoe has joined #lisp
cyraxjoe has quit [Ping timeout: 245 seconds]
dtornabene has joined #lisp
smasta has joined #lisp
smasta has quit [Ping timeout: 255 seconds]
dtornabene has quit [Remote host closed the connection]
spoeplau has joined #lisp
pillton has quit [Ping timeout: 264 seconds]
jmercouris has joined #lisp
jmercouris has quit [Remote host closed the connection]
Achylles has joined #lisp
Zaab1t has joined #lisp
Zaab1t has quit [Client Quit]
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
m00natic has quit [Ping timeout: 245 seconds]
h11 has joined #lisp
Essadon has joined #lisp
scymtym has quit [Ping timeout: 250 seconds]
rumbler31 has joined #lisp
__jrjsmrtn__ has joined #lisp
amerlyq has joined #lisp
m00natic has joined #lisp
esrse has quit [Ping timeout: 246 seconds]
akssri has joined #lisp
smasta has joined #lisp
lucasb has joined #lisp
smasta has quit [Ping timeout: 250 seconds]
zooey has quit [Ping timeout: 256 seconds]
zooey has joined #lisp
dddddd has joined #lisp
milanj has joined #lisp
Bike has joined #lisp
Lord_of_Life_ has joined #lisp
emacsomancer has quit [Remote host closed the connection]
Lord_of_Life has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
gravicappa has joined #lisp
anewuser has joined #lisp
aeth has quit [Ping timeout: 250 seconds]
aeth has joined #lisp
igemnace has quit [Quit: WeeChat 2.4]
libertyprime has quit [Ping timeout: 268 seconds]
anewuser has quit [Ping timeout: 246 seconds]
warweasle has joined #lisp
LiamH has joined #lisp
<hjudt_>
ok, so i have an update-thread that calls some long-running functions that update data. to protect against data-losses on exit, i thought about adding an exit hook to sb-ext:*exit-hooks*, causing it to set a special var *shutdown-request* and having those long-running functions `signal' a condition when they detect it has been set to t. do you think this would be a good way to shutdown cleanly?
<shka__>
uhm?
<shka__>
hjudt_: sounds like overly complex solution
<shka__>
does this problem requires solution at all?
<pjb>
If you have a long-running function, you should design it so it saves intermediate snapshot of its work. So if it is killed, you can resume it from a saved snapshot.
<pjb>
One way you could do that is by saving a lisp image, but if you use threads, it may be inconvenient.
<hjudt_>
yes. i need to prevent data loss. the program runs in a container, which can be restarted any times. there are several functions that update data from different places. i need to be sure that i catch the exit signal (hence exit-hooks), then abort all updates (they are distributed in various functions because there are various sources to update from), then prevent saving incomplete data, also prevent saving
<hjudt_>
because the container and the lisp process can get killed meanwhile due to timeout.
<hjudt_>
saving happens after new data has been fetched, so it is easy to skip that.
<pjb>
Another way to do it, is to save the global state, and then to save state changes. You can save the global state periodically. Then when you want to restart, you just have to replay the state changes.
<hjudt_>
i thought about signaling because i could then install a handler in a single place (or maybe two) and would not have to check before every function call that might still happen.
<pjb>
You cannot count on unwind-protect or on sb-ext:*exit-hooks* because nothing guarantees that they will be run.
<pjb>
Eg. a meteorite could drop on the computer.
<pjb>
If you haven't saved snapshots before this occurs, you lose.
<pjb>
saving state changes is quite easy and sturdy a solution.
<hjudt_>
it is very unlikely a meteorite would drop on the computer. but it is not unlikely the container is rebooted and updates are aborted in a timely manner. that is because one can control the timeout.
<hjudt_>
however, a timeout of 5 minutes or more waiting for completion is too much.
<hjudt_>
your suggestion about using snapshots is reasonable. i could do this, but i would still need to do small updates because the snapshots take too long. so my problem would still exist to a lesser degree.
patrixl has joined #lisp
<hjudt_>
btw: if a meteorite drops on the computer, i'd have other problems besides not having saved snapshots ;-)
<hjudt_>
but let's tackle it from a different point of view. if my goal is simply to tell a function (e.g. a download) to interrupt work and return, could my complex solution work?
Achylles has quit [Ping timeout: 252 seconds]
<grewal>
It should work. In other languages, I've made shutdown functions that gracefully exit on SIGTERM. But you do have to worry about more severe ways of killing like SIGKILL or simply pulling the plug
gareppa has joined #lisp
<grewal>
And most people expect programs to shut down quickly
<grewal>
If there's an error when shutting down, you're out of luck.
Achylles has joined #lisp
gareppa has quit [Remote host closed the connection]
<hjudt_>
grewal: i am aware of that. thanks. doing without snapshots is not my final solution, but i also have to implement a fast and more reliable shutdown for my use-case. it also does not seem too complex for me, in fact i cannot think of something easier that also works fast.
<hjudt_>
gladly, the snapshotting should be quite easy to accomplish in common lisp because of overlaying bindings.
<hjudt_>
in fact i am already using this for my unit tests
<hjudt_>
thanks to all for your help and input
<pjb>
hjudt_: stay at a reasonable distance from your computers, use the network, exactly to avoid personal problems when meteorites drop on your computers!
<pjb>
Of course, nowadays with laptops and handhelds we have to be extra careful…
<hjudt_>
yes. i guess that is how the dinosaurs became extinct.
<pjb>
Actually, writing programs so you don't have to save explicitely and you can quit the program just by powering the computer down at anytime simplifies the work greately.
<pjb>
Since now you don't have to write loading and saving data, but only restoring the state from snapshots+logs, and snving snapshots and logs during work.
<pjb>
hjudt_: to short arms!
<pjb>
too
dale_ has joined #lisp
dale_ is now known as dale
fortitude_ has joined #lisp
rumbler31 has quit [Remote host closed the connection]
milanj has quit [Read error: Connection reset by peer]
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.2)]
pankajgodbole has quit [Quit: ERC (IRC client for Emacs 25.1.1)]
pankajgodbole has joined #lisp
buhman has quit [Ping timeout: 255 seconds]
kajo has quit [Ping timeout: 258 seconds]
akssri has quit [Read error: Connection reset by peer]
t58 has joined #lisp
<easye>
~.
<easye>
Pardon.
aeth has quit [Ping timeout: 245 seconds]
aeth has joined #lisp
shka_ has joined #lisp
rippa has joined #lisp
jprajzne has quit [Quit: Leaving.]
buhman has joined #lisp
Ukari has quit [Quit: Leaving.]
Ukari has joined #lisp
spoeplau has quit [Remote host closed the connection]
rumbler31 has quit [Remote host closed the connection]
scymtym has joined #lisp
igemnace has joined #lisp
milanj has joined #lisp
rumbler31 has joined #lisp
lumm has joined #lisp
hhdave has quit [Ping timeout: 245 seconds]
ebrasca has joined #lisp
ravenousmoose has joined #lisp
amerlyq has quit [Quit: amerlyq]
amerlyq has joined #lisp
amerlyq has quit [Client Quit]
amerlyq has joined #lisp
rumbler31 has quit [Remote host closed the connection]
jmercouris has joined #lisp
<jmercouris>
I'm trying to write an article titled "Why Lisp?" to explain why we use Lisp at work
<jmercouris>
I'm trying to think of some of the simpler concepts to explain to the average person such that they can understand the value
<jmercouris>
so far I have come up with "future-proof", the language syntax grows and change via the usage of macros
<jmercouris>
interactivity: the language enables you to compile on the fly in a running image, make changes and try again
<jmercouris>
beyond that, I'm out of relatable ideas
rumbler31 has joined #lisp
<jmercouris>
I could start talking about homiconicity, but I think I will lose the interest of the reader
<jmercouris>
any suggestions are welcome, thanks
<jmercouris>
when I say average person, I mean average algol language programmer
rumbler31 has quit [Ping timeout: 250 seconds]
<jmercouris>
nobody has any ideas whatsoever?
<sjas>
ask yourself 'if you would have to choose today between mainstream langs and lisp, how would you decide and why'
<grewal>
Debugging is easier
<moldybits>
jmercouris: i think the homiconicity is the most interesting part of the language
<sjas>
stay pragmatic, nothing else counts
<jmercouris>
moldybits: yeah, me too, but to explain why that is important to a JS programmer is a monumental challenge
<sjas>
!
<jmercouris>
sjas: the thing is, I know things that the average person does not, and I am having trouble putting myself into the shoes of who I used to be
<grewal>
But you're going to have to talk about homoiconicity (at least implicitly) when you mention macros
<jmercouris>
I don't know what would compel me to choose lisp
<jmercouris>
I will not go deeply into the technical reasons macros are possible or how they are implemented, I will just talk about them in a vague sense as to what they can do
karlosz has joined #lisp
<jmercouris>
I chose lisp, for what many may consider a foolish reason, I trusted my undergraduate unversity professor, and I wanted to know what he was on about
<dlowe>
jmercouris: js and python often use high level bits of glue to put together low-level components written in C. In CL, we use the same language.
<jmercouris>
however, that's not a compelling argument in a paper
<jmercouris>
dlowe: that's a good one, performance!
<sjas>
then write these things you know down so others learn. gather interest (why does it help), show its easy ('so this is actually feasible'), then hint on the horizon in what other ways it enables you
<sjas>
(thats my idea of how to tackle that)
<moldybits>
jmercouris: suppose you have a very large code base that you wish to operate on programmatically. in other languages you'd need to find, pick and learn how to use some complicated parser, and traverse the tree in some unintuitive way. in lisp you just read and use the same functions you use for your data.
<dlowe>
jmercouris: I was thinking more of flexibility
<jmercouris>
dlowe: you mean the wide range of flexibilty you have in going up/down the abstraction tree?
<dlowe>
jmercouris: the CLOS object model is very different and offers many advantages over the usual OOP
<dlowe>
jmercouris: right
<jmercouris>
e.g. you can operate on octets, with the same ease as objects
<jgkamat>
having tools like paredit for editing on an AST level instead of a text level is reason enough imo
<jmercouris>
AST level? it is only an AST after it has been compiled
<dlowe>
jmercouris: also, many languages will use a different language for metaprogramming
<jmercouris>
I think you mean the SEXP level
<dlowe>
jmercouris: and code generation
<sjas>
most programmers dont even know what an AST is
<jmercouris>
dlowe: right, like python's @ symbol
<dlowe>
jmercouris: again, we just use the same lisp to do so
<jmercouris>
I forget what those are called, iti always eludes me
<jmercouris>
decorators
<jmercouris>
and they have a very strange syntax and behavior
<dlowe>
I made an implementation of decorators for CL one time. It took about 10 minutes.
gareppa has joined #lisp
<jmercouris>
ok so I have the following list: interactivity in debugging/coding, flexibility in the abstraction tree, performance, clos
<jmercouris>
I think that is a good list no?
<jmercouris>
long enough?
<jmercouris>
too long?
techquila has joined #lisp
<sjas>
one argument i'd use is the longevity of what you write: old code runs against current language implementation, imagine that in ANY other language
<dlowe>
language stability
<dlowe>
hah
gareppa has quit [Remote host closed the connection]
<jmercouris>
language stability, yes
<sjas>
cough python cough any other web lang
<jmercouris>
I have already a section called "what does it mean to be "future proof"?
<moldybits>
jmercouris: why not describing a realistic scenario in another language, and what you might realistically do to solve it. then describe what you'd do in lisp.
<jmercouris>
moldybits: a very good idea, could be a follow-up article
<dlowe>
moldybits: that always sounds strawman-y no matter how earnest you are
<jmercouris>
also a good point..
<grewal>
sjas: I can still run K&R style C code and fortran70 code without issue :P
<jmercouris>
now I'Mm torn lol
<jmercouris>
you can always contrive an example to make language A look better than langauge B
<sjas>
grewal so you never converted python2?
<dlowe>
The internet will always summon forth defenders to point out that you were doing it all wrong in the other language
<moldybits>
dlowe: not if you base it on actual experience?
MichaelRaskin has joined #lisp
igemnace has quit [Quit: WeeChat 2.4]
<moldybits>
i think it'll work if it's a simple thing that makes sense even to a lisp beginner
<dlowe>
moldybits: "I wrote this in X and succeeded, and then for no conceivable reason I thought, I should do this in lisp instead"
<grewal>
sjas: Fortunately no, I started learning python when python3 started taking over.
<dlowe>
"and I'll hit myself on the head so I won't suffer from learning bias"
<jgkamat>
they're already starting to discuss python4 so you might get to experience it for yourself in about 2-3 years
<jmercouris>
I just love backwards incompatible changes
<sjas>
exactly my longevity point
<jmercouris>
Think about the millions of hours of wasted developer time just so that print would be syntactically a function
<jmercouris>
python3 has what benefits exactly? default unicode strings???
<jmercouris>
WOW! totally worth it!
<jgkamat>
that's not a good argument, that's easily automated. Most of the time is wasted in other aspects of the migration
<dlowe>
anyhoo, about lisp
<jmercouris>
python2-3 was a mess of a job, and stupid at that
<jmercouris>
python3 could have easily been implemented as extensions to python2
<jmercouris>
again, this is a lisp channel, so I don't want to get into a rant
<warweasle>
In s-expressions, no one can hear you say </rant>.
<sjas>
any lang ecosystem + documentation + community is a prefabricated toolbox. how'd you sell any one to buy into specifically this one?
<dlowe>
give them money :)
<dlowe>
that's how I started
<dlowe>
that's why most people learn a language
<sjas>
was that how clojure went off?
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jgkamat>
does anyone know if there's a nice way to generate js from cl? I guess I could look into closurescript but I would prefer cl
<dlowe>
jgkamat: readable js or any js?
<jgkamat>
ideally readable, but I don't think it matters
<jgkamat>
I want to make a script to generate greasemonkey scripts
<dlowe>
ah, so webasm isn't going to work for that
<jgkamat>
yah, it would need to be real js
<dlowe>
I don't think there's such a thing
<grewal>
Parenscript?
<dlowe>
parenscript isn't CL, but it's popular in lisp webdev
<jmercouris>
parenscript does implement a lot of the important parts to write lispy JS
<jgkamat>
that might work, thanks for the tip. I'm trying to dynamically generate the actual js based on an input, so I could probably use some cl to generate parenscript which gets converted to js
<jmercouris>
you can view a lot of parenscript generation in Next browser
<jmercouris>
however that project is an absolute joke and a hack, so I wouldn't even bother looking at the source
<jgkamat>
indeed, I am trying to avoid XSS, that's one of the things that would be a dealbreaker for me
<jmercouris>
there's no XSS in Next, it is however written by a bunch of amateurs with a terrible design
<jmercouris>
someone as talented as yourself should be able to easily improve upon it
<jmercouris>
despite knowing absolutely no common lisp, I'm sure you can clear the hurdle
nowhere_man has joined #lisp
knicklux has joined #lisp
ravenousmoose has joined #lisp
__jrjsmrtn__ has quit [Read error: Connection reset by peer]
m00natic has quit [Ping timeout: 245 seconds]
buhman has quit [Ping timeout: 250 seconds]
khisanth_ has quit [Ping timeout: 255 seconds]
nirved is now known as Guest40990
Guest40990 has quit [Killed (sinisalo.freenode.net (Nickname regained by services))]
nirved has joined #lisp
<jmercouris>
dlow: so, CL, the previous Lisp implementations, what kind of backwards breaking changes did they make?
<jmercouris>
dlowe: so, CL, the previous Lisp implementations, what kind of backwards breaking changes did they make?
<jmercouris>
I understand make hash table couldn't have the same argument order in every single Lisp, so what exactly broke?
pankajgodbole has quit [Ping timeout: 245 seconds]
<jmercouris>
is there a list somewhere?
zotan has quit [Ping timeout: 250 seconds]
karlosz has quit [Quit: karlosz]
zotan has joined #lisp
<mgsk>
Is there a function that will read user input into a string until e.g. the user hits Ctrl-d?
<Xach>
mgsk: read-line
<mgsk>
That just reads a single line and discards the rest?
<jackdaniel>
mgsk: you call read-line until you hit eof (which is what C-d gives you)
<Xach>
mgsk: You want to loop and read lines until there is an empty line?
<Xach>
if you call (read-line) and then type "foobar<Ctrl-D>" it will return "foobar", which is what I thought initially.
<Xach>
Anyway, a loop around (read-line stream nil) and checking for nil is one option.
<Xach>
There are many others.
<Xach>
if you want to accumulate, there are likewise many options. with-output-to-string is an easy one.
<LdBeth>
read-line is slow, if u are concerned with performance there’s a equivalent version using read-sequence instead
<Xach>
yes, the user might type so fast that the bottleneck is read-line's processing.
xkapastel has joined #lisp
<jmercouris>
Lol, the mafia strikes again
<jackdaniel>
I usually loop over (read-line stream nil :eof) and checking for eql :eof
<jmercouris>
I do the same as jackdaniel, its a clean approach
<aeth>
You can also just read a character at a time, but then you have to write your own abstractions because that's pretty low level (not the lowest possible level, though).
<aeth>
(You still have characters.)
* jackdaniel
parses electrons
<jmercouris>
jackdaniel: is that full ascension?
<jackdaniel>
and some abstraction on top of it. 0 = invalid, 0.4-0.8 = 0, 1.2-2.4 = 1
lucasb has quit [Quit: Connection closed for inactivity]
<jmercouris>
I think that issue is only a problem with magnetized platters
<jackdaniel>
(voltage ↑)
<jmercouris>
shouldn't be an issue with any type of solid state memory
khisanth_ has joined #lisp
<jackdaniel>
memory? you may be a receiving end of a communication with another device
<dlowe>
I usually (loop for line = (read-line stream nil) while line do ...)
<Xach>
dlowe: same
<jmercouris>
jackdaniel: a foolish assumption of mine to assume the device...
<jmercouris>
however, I may go a step further and say it was foolish to assume we'd be dealing with electrons
<jmercouris>
what if it is a mechanical computer?
<LdBeth>
U know, atoms are bonded by electrons.
* jackdaniel
regrets he has decided to joke and takes it back. let's talk about lisp!
<LdBeth>
GG
<aeth>
jackdaniel: what I mean is the lowest level available to CL afaik would be reading bytes and applying your own encoding, perhaps with babel
<LdBeth>
Is stream a buffer?
<aeth>
I guess non-standardly you could CFFI
<aeth>
LdBeth: probably, I don't think it's specified
<jackdaniel>
LdBeth: it is not. you may open a special file
<jackdaniel>
you may even define your own stream
<jackdaniel>
there are broadcast streams, echo streams and such as well
notzmv has quit [Ping timeout: 244 seconds]
<LdBeth>
More specifically, is a stream associated with stdin a buffer?
<aeth>
you can rebind *standard-input* and most people do use the rebound-via-SLIME stdin, stdout, etc., far more than their implementation's original
milanj has quit [Quit: This computer has gone to sleep]
<jmercouris>
aeth: but what about picolisp? isn't there something lower?
<aeth>
jmercouris: plancklisp is the smallest theoretically possible lisp
<aeth>
jmercouris: however, CERN rejected my proposal to look for it so I'm not sure how we're going to find it
ebrasca has quit [Read error: Connection reset by peer]
ebrasca has joined #lisp
<jmercouris>
aeth: :) I know you are joking, but I always dreamed as a child of working at Argonne
<jmercouris>
we went on a school trip at a young age, and I got to see all of the scientists working there, and I always wanted to be one, I'm a computer scientist, but that hardly counts
<dlowe>
Have you applied?
ravenousmoose has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<jmercouris>
I haven't applied no, my life circumstances at the moment prohibit it, but I would like to apply in the future, though I am afraid I will not be considered since I do not have a PHD
<dlowe>
I've worked at places among phds because they couldn't code themselves out of a wet paper bag
<dlowe>
it was a different time, though, so I'm not giving advice
<p_l>
Also, don't many research institutes have options of at least cooperating with PhD process?
sauvin has quit [Ping timeout: 246 seconds]
<aeth>
dlowe: to be fair, I couldn't code myself out of one, either, unless computer vision libraries have gotten really good
<aeth>
jmercouris: you never know if you don't try
<jmercouris>
that is true, I will try!
<jmercouris>
maybe I'll even go for a PHD as well, I love doing research, would be fun
ym555 has joined #lisp
nowhereman has joined #lisp
nowhere_man has quit [Ping timeout: 268 seconds]
kajo has joined #lisp
<jmercouris>
outside of allegrodb, does anyone know of any database implementations written in Common Lisp?
<jmercouris>
can be ORM, OGM, doesn't matter
<dlowe>
So there's rucksack and elephantdb
<jmercouris>
s/orm/relational s/ogm/graph
<dlowe>
Rucksack was a cool PoC that was dropped. Elephantdb is, as far as I know, also abandoned
<dlowe>
Rucksack is great until the heap gets corrupted, and then there's no recovery.
<dlowe>
So no. Use postmodern and postgresql. They're great.
<jmercouris>
I'm currently using postgresql
<jmercouris>
I'm right there with you
<jmercouris>
what confuses me about elephant db, looking at the page "Elephant is split between a common API and several data stores. Berkeley DB, CLSQL and postmodern interfaces are provided. Elephant inherits the ACID properties of these stores and all database operations are thread-safe by design."
<jmercouris>
yet it calls itself a database
<jmercouris>
it uses another database as a backend for its own database implementation???
<dlowe>
Huh, I thought it was a prevalent db
<aeth>
jmercouris: This is absolutely not what you're looking for, but I am approaching my ECS (entity-component-system, a trendy new way to structure the internals of a game engine) design sort of like an in-memory database.
<dlowe>
I think it was, at one point
<jmercouris>
well, the first line clearly implies that "Elephant is a persistent object database for Common Lisp with full transaction semantics. A persistent metaprotocol overrides class creation and slot accesses, making slot values automatically persistent."
<dlowe>
I used Rucksack for a game and since have regretted it.
<dlowe>
The db files are super easy to corrupt with a signal in the wrong place. If I had time I would try and fix it up
<jmercouris>
writing a DB is quite hard I guess :D
<jmercouris>
who would have thought :D
<dlowe>
There's a neat writeup on how the dev did it.
<dlowe>
It worked really, really well with changing class definitions
<jmercouris>
didn't require migrations?
<jmercouris>
or they were just as easy as C-c C-c on a class form?
<jmercouris>
s/class/defclass
<dlowe>
because the metaclass would version the schema on the file, so if you loaded an older version of an object with a newer class, it could use update-instance-for-different-class
<jmercouris>
that is pretty magical
<jmercouris>
I think Mito does something similar
<jmercouris>
you can load data from the database even when the columns do not match (for example, there is a new slot that does not exist in the DB), and it will behave just fine
<jmercouris>
however the mechanics of that may be *very* different
<dlowe>
there's the talk
<jmercouris>
thanks for the link
<jmercouris>
I never realized how hard it would be to serialize a hash table
<jmercouris>
so basically any time this guy writes a serialization method for some class, he has to consider all the salient state specific things of that class
<jmercouris>
like what type of equality operator the hash table uses
<jmercouris>
I would have done the much more naieve spitting out of key/values and called it a day
<jmercouris>
very interesting
<jmercouris>
there is something that he said that confuses me
<jmercouris>
"structs cannot be serialized portably"
<jmercouris>
why is that?
<dlowe>
No way to get slots for structs, I think
<jmercouris>
really? that seems like a huge oversight
<jmercouris>
your conclusion does make sense though, because in the next paragraph he starts talking about MOP and iterating over the slots
<jmercouris>
however, he could have implemented a struct class that comes with Rucksack and overrides (defstruct ...)
<jmercouris>
or is there some reason he couldn't have done that?
<dlowe>
it wouldn't work on existing structs
Achylles has joined #lisp
igemnace has joined #lisp
<jmercouris>
dlowe: can you elaborate on that please?
<jmercouris>
it wouldn't work on existing structs in a running image?
<jmercouris>
that is for sure, but I don't see why it wouldn't work on structs if in your asd file you have a dependency on rucksack which introduces a new macro or something
<dlowe>
what about a library that returns a struct?
gravicappa has quit [Ping timeout: 246 seconds]
<jmercouris>
ah... yes
<dlowe>
also, we already have things that are like structs but with lots of cool features.
<jmercouris>
you are going to mention classes?
<Bike>
are there any implementations that have MOP but not for structure-classes
<dlowe>
Bike: since he was aiming for pure portable CL, it doesn't matter
<jmercouris>
apparently there must be, since the author said it would be non-portable
<Bike>
there's a difference between standard and portable
<jmercouris>
well, ASDF is not part of CL, yet we consider code that uses ASDF as portable
<Bike>
and MOP support is too variable to be a standard anyway, womp womp
<dlowe>
only because asdf is itself portable
<jmercouris>
there must be a way...
<jmercouris>
though I'm sure the author thought a long time about this
<jmercouris>
it seems too unbelievable
<Bike>
it's just hard for me to imagine someone building an implementation and then not even keeping that bit of mop for structure classes.
<Bike>
practically speaking.
<jmercouris>
anyways, dlowe very interesting read, thanks for sharing
<dlowe>
structure-class is not standard-class
<jmercouris>
I learned a lot about databases actually
<Bike>
yeah it's not, it's structure-class.
<jmercouris>
but why isn't it standard-class?
<jmercouris>
is it for performance reasons?
<Bike>
pretty much.
<dlowe>
because the spec said so :)
<Bike>
structure-classes have a more restricted feature set. mostly the redefinition business.
<dlowe>
I'm not sure if it was performance or compatibility
<Bike>
eh.
<jmercouris>
that's what I want to know as well
<dlowe>
I suspect defstruct of being on one of the ancestor lisps
<Bike>
defstruct is the older one.
<jmercouris>
hence my question above "what compromises were made in CL in favor of compatibility with existing Lisps"
<Bike>
defstruct is definitely a remnant.
<jmercouris>
I actually enjoy using defstruct
<dlowe>
well, we have rplaca
<jmercouris>
though I wish it didn't automatically name my accessors
<Bike>
personally, i'd like if you could just (defclass ... (:metaclass structure-class)) if you wanted the performance stuff
<dlowe>
You'll enjoy it up to the point where you want to add a slot to a running image
<Bike>
it gets a little weird with the redefinition even then though
<jmercouris>
okay, so what if you always loaded rucksack first
<jmercouris>
nvm, that wouldn't fix it
<Bike>
for this "redefine destruct" idea?
<dlowe>
this isn't an interesting problem to me
<dlowe>
I pretty much never use structures
<Bike>
you'd have to redefine cl:defstruct, which is definitely undefined.
<jmercouris>
yes the redefine defstruct idea
<Bike>
and like, an actual problem to do
<jmercouris>
I'm sure the compiler would complain
<Bike>
just trust your implementation to be sensible enough to have MOP for structure-classes
rumbler31 has joined #lisp
<Bike>
also you can serialize structs as text, that's built into the language. not much help if you want some other format, of course.
<jmercouris>
so what's the big drawback of making it non-portable if all lisp implementations support basic MOP operations for structure-class?
<jmercouris>
I feel like he could have at least provided it as an optional for implementations that *do* support it
<jmercouris>
and signal a condition when an implementation does not support it
buhman has joined #lisp
<dlowe>
the code is there for you to edit
<jmercouris>
but still provide the rest of the functionality
<dlowe>
you can even pick it up and claim ownership
<jmercouris>
maybe one day, I'm not very interested in writing a DB
<jmercouris>
I would like to have one as rucksack is described, very intriguing
ebrasca has quit [Read error: Connection reset by peer]
<jmercouris>
but all of my time goes to Next
<jmercouris>
and a few other companion libs, but maybe one day, and with a name that I don't dislike
ebrasca has joined #lisp
<jmercouris>
I would call it "Mnemosyne"
vlatkoB has quit [Remote host closed the connection]
akoana has joined #lisp
rumbler31 has quit [Ping timeout: 250 seconds]
Josh_2 has quit [Quit: ERC (IRC client for Emacs 26.1)]
specbot has quit [Ping timeout: 250 seconds]
minion has quit [Ping timeout: 255 seconds]
minion has joined #lisp
specbot has joined #lisp
libertyprime has joined #lisp
nowhereman has quit [Ping timeout: 245 seconds]
jmercouris has quit [Remote host closed the connection]
libertyprime has quit [Ping timeout: 244 seconds]
glv has quit [Quit: Leaving]
scymtym has quit [Ping timeout: 250 seconds]
emaczen has joined #lisp
ym555 has quit [Ping timeout: 245 seconds]
libertyprime has joined #lisp
shka_ has quit [Ping timeout: 244 seconds]
xkapastel has quit [Quit: Connection closed for inactivity]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
Achylles has quit [Ping timeout: 240 seconds]
ym555 has joined #lisp
smasta has joined #lisp
hiroaki has joined #lisp
tyler569 has joined #lisp
anewuser has joined #lisp
scymtym has joined #lisp
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
ltriant has joined #lisp
smasta has quit [Ping timeout: 245 seconds]
patlv has joined #lisp
hiroaki has quit [Ping timeout: 258 seconds]
anewuser has quit [Ping timeout: 246 seconds]
angavrilov has quit [Remote host closed the connection]
anewuser has joined #lisp
frodef has quit [Ping timeout: 246 seconds]
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 250 seconds]
patlv has quit [Quit: patlv]
ebrasca has quit [Read error: Connection reset by peer]
moei has quit [Quit: Leaving...]
amerlyq has quit [Quit: amerlyq]
Josh_2 has joined #lisp
patlv has joined #lisp
milanj has joined #lisp
Achylles has joined #lisp
smasta has joined #lisp
nanoz has joined #lisp
<vsync>
wow, huge scrollback that ties into my interests and immediate needs actually
<vsync>
Rucksack is nice; I've used it
<vsync>
and literally as I came to my desk I was envisioning it for some prototyping I'm doing and see what happens next
<vsync>
suppose I should skim this first though :_)
orivej has quit [Ping timeout: 245 seconds]
milanj has quit [Ping timeout: 268 seconds]
smasta has quit [Ping timeout: 246 seconds]
<vsync>
hmm... just realized the thing I'm working on (spooling, broadly speaking) could be envisioned as streams; refresh my memory, where is best e.g. Gray streams guidebook etc?
<gilberth>
But that is no guide either but a spec.
LiamH has quit [Quit: Leaving.]
anewuser has quit [Quit: anewuser]
Bike has quit []
karlosz has joined #lisp
smasta has quit [Ping timeout: 246 seconds]
<gilberth>
BTW that website is illegal now in the EU since I have no upload filter.
* vsync
gasps
<gilberth>
You could annotate "Mehr Licht" and that would infringe the copyright of Goethe.
karlosz has quit [Quit: karlosz]
<gilberth>
I am supposed to have a software to catch that and kill annotations, which would infringe somebodies copyright. Yeah! Where is the up to date database of all written works?
* gilberth
does not care, sue me if you want.
<Josh_2>
oof gilberth xD
<Josh_2>
off to gulag
<gilberth>
Josh_2: Sure. It's not _that_ bad around here. Not yet.
<vsync>
opinions on tools for (CLOS) protocol definition/management?
<Josh_2>
The book AMOP
<Josh_2>
that's a good tool :P
<vsync>
thank you; I own it
<Josh_2>
Me 3, not read it yet tho
<vsync>
opinions on automated tools for (CLOS) protocol definition/management?
<gilberth>
Read the book?
* vsync
remembers hearing about some libs/frameworks with macros and so forth or could imagine everything all the way to GUI stuff
rumbler31 has joined #lisp
<vsync>
gilberth: I have read it, thank you
<Josh_2>
Was it a thrilling read?
<gilberth>
A little boring at places.
<gilberth>
Josh_2: Are you talking about "protocols" like CLIM tries to define them?
<Josh_2>
Me?
<gilberth>
Sorry. It's late.
<Josh_2>
Hecking yeh
<gilberth>
vsync: Are you ...
<vsync>
just trying to avoid reinventing the wheel man
<vsync>
using AMOP stuff as foundational concepts of course
<Josh_2>
What are you trying to do?
<edgar-rft>
gilberth: you could make it like Johannes Kreidler who registered his 30-second song at the GEMA using 70200 paper forms, as requird by the copyright law. More details see http://kreidler-net.de/productplacements-e.html
<gilberth>
edgar-rft: Sure. And how would that save me? You can annotate the clim spec that I host as you wish. You could paste copyrighted material if you wish and I supposed to pre-filter that.
rumbler31 has quit [Ping timeout: 268 seconds]
<Josh_2>
Just host website outside EU :P
<vsync>
Josh_2: me?
<Josh_2>
Well I asked u what you are trying to make :P
<vsync>
gilberth: ah yes CLIMesque protocols
<Josh_2>
but gilberth should host outside EU
<gilberth>
Josh_2: I still am an EU-citizen. Hosting outside would not change a thing.
<vsync>
Josh_2: something else, but I need to spec/impl/doc protocols for it and wondered what the current fashion is
<vsync>
if any
<gilberth>
vsync: In my CLIM, I have a macro which is called DEFINE-PROTOCOL-GENERIC-FUNCTION which is like DEFGENERIC. You could specialize the arguments and this is remembered. Later I have a tool that checks, that for every subclass of the given class there is an applicable method using the MOP. No idea, if this what you are aiming for.
lumm has quit [Read error: Connection reset by peer]
nanoz has quit [Ping timeout: 244 seconds]
Bike has joined #lisp
<vsync>
gilberth: one you made or one you use?
<vsync>
and yes that is in the vein of what I'm thinking
<PuercoPop>
memo for jmercouris: ASDF is not portable. At least not in the sense that the document appears to be is using it. Look up portable in the CLHS glossary
<PuercoPop>
minion: memo for jmercouris: ASDF is not portable. At least not in the sense that the document appears to be is using it. Look up portable in the CLHS glossary
<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
<gilberth>
vsync: I made that.
<PuercoPop>
minion: memo for jmercouris: speaking of databases in CL. Have you seen? I haven't used it but from skimming the code it seems at least like a serious effort. https://github.com/kraison/vivace-graph-v3
<minion>
Remembered. I'll tell jmercouris when he/she/it next speaks.
<gilberth>
vsync: Start reading at the check-protocols function.
pyc has quit [Ping timeout: 264 seconds]
pyc has joined #lisp
patrixl has quit [Read error: Connection reset by peer]
<grewal>
/scrollback goto -100
<gilberth>
?
* no-defun-allowed
gives grewal a "you tried" sticker
<grewal>
Sorry, didn't mean to send that
<grewal>
:(
<gilberth>
:)
ym555 has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
turn that frown upside down
<gilberth>
So then after all our parens match. I am tempted to send a ":)", but that would make them to unmatch again.
ym555 has joined #lisp
<t58>
):
<no-defun-allowed>
) can't occur directly after a :
<gilberth>
(-: (-: just to match :), who's next?
<_death>
(set-syntax-from-char #\) #\a) :)
<gilberth>
We still miss two "("s. This channel has to be balanced, don't you think?
<no-defun-allowed>
( ; there all done
<gilberth>
Fine!
* gilberth
wonders what a scrollback of 20 years of #lisp would yield.
wxie has joined #lisp
<wrycode>
"So then after all our parens match. I am tempted to send a ":)", but that would make them to unmatch again." <-- I read that as parents the first time around
karlosz has joined #lisp
<no-defun-allowed>
can you use method combinations to change how methods are selected in generic functions?
Essadon has quit [Quit: Qutting]
<no-defun-allowed>
(or in other words: can we somehow create other types of specializers?)