<skeuomorf>
PuercoPop: Is there currently support for relative links?
kmurphy4 has joined #lisp
<skeuomorf>
PuercoPop: It would be cool if the links to CSS files, images, ...etc are relative to the root instead of being tied directly to the domain
d4ryus1 has joined #lisp
d4ryus has quit [Ping timeout: 252 seconds]
octobanana has quit [Read error: Connection reset by peer]
17SAACD3U has quit [Quit: 17SAACD3U]
Guest46344 has quit [Changing host]
Guest46344 has joined #lisp
Guest46344 has joined #lisp
Guest46344 is now known as billstclair
fikka has joined #lisp
emacsoma` has quit [Ping timeout: 252 seconds]
innovati has quit [Quit: My MacBook Air has gone to sleep. ZZZzzz…]
EvW has quit [Ping timeout: 245 seconds]
fikka has quit [Ping timeout: 240 seconds]
pierpa has quit [Quit: Page closed]
Kundry_Wag has joined #lisp
fikka has joined #lisp
jason_m has joined #lisp
<PuercoPop>
skeuomorf: You mean CSS in the themes?
<PuercoPop>
skeuomorf: The themes are hardcoding the ${config.domain} as the prefix. You could set the domain in the .coleslawrc as the root URL of your blog
fikka has quit [Ping timeout: 252 seconds]
<skeuomorf>
PuercoPop: That's what I do, but it makes all the links tied to my domain name
al-damiri has quit [Quit: Connection closed for inactivity]
Fare has quit [Ping timeout: 252 seconds]
<skeuomorf>
PuercoPop: put another way, given index, I want to be able to navigate to everywhere else from it without being tied to the domain name, so that all the URLs are relative to index
eli_oat has joined #lisp
Guest69418 has joined #lisp
octobanana has quit [Read error: Connection reset by peer]
Guest69418 has quit [Quit: WeeChat 1.9.1]
<jason_m>
Hello, I recently discovered snooze (https://github.com/joaotavora/snooze). This is a small issue, but the defroute indentation does not work for me as shown in the readme. Can I change how that works? (emacs / slime)
<PuercoPop>
For the posts content you can use the relative URL, or are you asking for something else?
karlosz has quit [Quit: karlosz]
<jason_m>
The body forms are being lined up under the route name.
<skeuomorf>
PuercoPop: let me give an example
<PuercoPop>
skeuomorf: I'm guessing the the easiest way is to just copy the theme to a new dir a modify the templates directly. I know there is PAGE-URL but I'm not seeing a way to achieve what you want easily. Then again I haven't read the codebase in quite a while. I still have to incorporate the docs on using Roswell
<skeuomorf>
PuercoPop: say I have a .coleslawrc with domain name as "http://example.com", and I have 2 posts, post1.md and post2.md, when I open index.html locally and try to navigate to post1, i get redirected to "example.com/post1" instead of "/root/post1"
<skeuomorf>
PuercoPop: I have a custom theme already, but this behavior is the same across my theme and hyde
<skeuomorf>
PuercoPop: I think this last example should make it clear
innovati has joined #lisp
xh4_ has joined #lisp
<PuercoPop>
COMPUTE-URL is a function unfortunately. Maybe if we change it to a generic function you could specialize the method according the 'content-type' you wish?
<skeuomorf>
PuercoPop: Sorry, I don't think I understand what this has to do with content types
xh4 has quit [Ping timeout: 245 seconds]
SenasOzys__ has quit [Remote host closed the connection]
fikka has joined #lisp
<PuercoPop>
skeuomorf: If I'm understanding you correctly you want to change the URL of Posts. Or do you want to change the URL of Post in a particular page?
Cymew has joined #lisp
smurfrobot has joined #lisp
<PuercoPop>
So URLs belong to the content itself and they are determined by COMPUTE-URL :after initializing the instance of the content (tag/post/etc). So you'd have to modify that if you want to change the URL of a content-type, like POSTS.
<PuercoPop>
Sorry if I'm being thick and misunderstanding your goals
<skeuomorf>
PuercoPop: No no, I think I maybe miscommunicating :)
<skeuomorf>
PuercoPop: Have you read the first paragraph here?
<skeuomorf>
PuercoPop: I think this is the simplest way to illustrate what I mean
fikka has quit [Ping timeout: 245 seconds]
fisxoj has quit [Quit: fisxoj]
Cymew has quit [Ping timeout: 252 seconds]
<PuercoPop>
skeuomorf: Ah ok. Yeah no, that is not something that Coleslaw can easily do. URLs are property of the content itself not something that is dynamically computed in relation to the 'current' content
<skeuomorf>
PuercoPop: I see, what would need to be done to make this work?
fikka has joined #lisp
pierpal has joined #lisp
wxie has joined #lisp
Cymew has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
<PuercoPop>
skeuomorf: I don't really have a good answer short of come up with a 'URL protocol' similar to the 'Document Protocol' and replace the URL reader of content with it? The post templates are receive the currently post as an argument so in theory you should be able to to use that as the current 'context/base'
Cymew has quit [Ping timeout: 252 seconds]
<skeuomorf>
PuercoPop: Hmm, seems complicated, will probably revisit this later
<skeuomorf>
PuercoPop: I have more questions though :D
<skeuomorf>
PuercoPop: The gh-pages plugin doesn't seem to work, neither when using (gh-pages :cname t) nor (gh-pages :cname "http://example.com")
Cymew has joined #lisp
Kevslinger has joined #lisp
fikka has joined #lisp
<skeuomorf>
It errors out on me "Not a valid CNAME: ~A"
himmAllRight has joined #lisp
Cymew has quit [Ping timeout: 252 seconds]
nickenchuggets has quit [Quit: Leaving]
fikka has quit [Ping timeout: 240 seconds]
<PuercoPop>
skeuomorf: Weird the last one should work. In fact Im not sure how the otherwise clause should be reachable because t should catch everything. Including nil
Cymew has joined #lisp
Naergon has quit [Ping timeout: 245 seconds]
<skeuomorf>
PuercoPop: Feels like I am the only one who tried using the plugin :)
<PuercoPop>
skeuomorf: Yeah, and it was written before the 'new gh-pages'. Let me try to run use it locally
<skeuomorf>
PuercoPop: great, tyt
fikka has joined #lisp
<PuercoPop>
(compiling the plugin warns that the otherwise is unreachable code as expected)
himmAllRight has quit [Ping timeout: 245 seconds]
Cymew has quit [Ping timeout: 245 seconds]
<skeuomorf>
PuercoPop: cool, what about using it via .coleslawrc? did it work for you?
iqubic has joined #lisp
himmAllRight has joined #lisp
beizhia has joined #lisp
nirved has quit [Ping timeout: 245 seconds]
<PuercoPop>
skeuomorf: it does, after I remove the truename call in the initial (let ((blog (truename ..)))
wxie has quit [Quit: Bye.]
slyrus_ has quit [Remote host closed the connection]
<PuercoPop>
with my RC file having :plugins ((gh-pages :cname t))
Oladon has quit [Quit: Leaving.]
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
smurfrobot has quit [Remote host closed the connection]
Kundry_Wag has joined #lisp
<skeuomorf>
PuercoPop: Awesome, trying to find out where quicklisp installs packages so that I can edit my Coleslaw and not have to wait for a release :)
<PuercoPop>
skeuomorf: just clone coleslaw in ~/quicklisp/local-projects/
<PuercoPop>
you can always ask with (ql:where-is "coleslaw")
<PuercoPop>
But it looks like the otherwise clause should instead be a wrapping unless
<skeuomorf>
PuercoPop: Nice on the `where-is`, it's actually `where-is-system`, still new to Common Lisp
<skeuomorf>
PuercoPop: What did you replace the truename call with?
<PuercoPop>
skeuomorf: just remove it
<skeuomorf>
aight
Kundry_Wag has quit [Ping timeout: 252 seconds]
<skeuomorf>
PuercoPop: and leave the (rel-path ...) stuff?
<PuercoPop>
yeah
<skeuomorf>
awesome, thanks
<PuercoPop>
np. Let me know if it works out (and don't forget to add your blog to the wiki)
nickenchuggets has quit [Read error: Connection reset by peer]
nirved has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has joined #lisp
nickenchuggets has quit [Changing host]
chens has quit [Remote host closed the connection]
chens has joined #lisp
<skeuomorf>
Cool cool
<skeuomorf>
PuercoPop: Do I need to do anything after editing the file other than reloading coleslaw?
<PuercoPop>
skeuomorf: no, you don't even need to reload coleslaw, just C-c C-c over the function to compile it again
<skeuomorf>
PuercoPop: pfft, same error
<PuercoPop>
skeuomorf: what is your (domain *config*)
<PuercoPop>
and what is the result of (parse-uri (domain *config*))
<skeuomorf>
sorry, hold on a sec. I think I made a mistake
<skeuomorf>
yupe, made a mistake, removed ".curr" when I was removing truename
<skeuomorf>
Works now!
<skeuomorf>
Thank you
<skeuomorf>
What is the 1.html file that gets generated?
Oladon has joined #lisp
xh4_ has quit [Remote host closed the connection]
<skeuomorf>
I know it's a link to index.html, but why?
xh4 has joined #lisp
schoppenhauer has quit [Ping timeout: 260 seconds]
xh4_ has quit [Read error: Connection reset by peer]
<skeuomorf>
hehe
<skeuomorf>
PuercoPop: What does it need to be fixed?
xh4 has joined #lisp
<skeuomorf>
I noticed that a user had sent a patch but you objected to it for some reason, do you have an idea of how we can fix it properly?
<skeuomorf>
a sitemap is kinda essential for SEO purposes
vtomole has joined #lisp
EvW1 has quit [Ping timeout: 245 seconds]
<PuercoPop>
skeuomorf: do you have the link handy? I only remember rejecting the djula plugin but only because I could come up with a way to handle both the render from the 'outside to the inside' of closure-templates and djul'as from the 'inside to the outside'
smurfrobot has quit [Remote host closed the connection]
milanj has quit [Quit: This computer has gone to sleep]
Kundry_Wag has quit [Ping timeout: 248 seconds]
mange has quit [Remote host closed the connection]
dddddd has joined #lisp
scymtym has quit [Remote host closed the connection]
panji has joined #lisp
sellout has joined #lisp
scymtym has joined #lisp
xh4 has joined #lisp
xh4_ has quit [Read error: Connection reset by peer]
Fare has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 268 seconds]
bbobb has joined #lisp
smurfrobot has joined #lisp
hhdave has joined #lisp
smurfrobot has quit [Ping timeout: 245 seconds]
pierpal has joined #lisp
pierpal has quit [Client Quit]
pierpal has joined #lisp
smurfrobot has joined #lisp
RebelCoderRU has quit [Ping timeout: 245 seconds]
hhdave has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 268 seconds]
igemnace has joined #lisp
igemnace has quit [Quit: WeeChat 2.1]
igemnace has joined #lisp
igemnace has quit [Client Quit]
igemnace has joined #lisp
_cosmonaut_ has joined #lisp
m00natic has joined #lisp
Kuloto has joined #lisp
Kuloto has quit [Quit: Leaving.]
Kuloto has joined #lisp
Kuloto has left #lisp [#lisp]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
Kuloto has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
panji has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Ping timeout: 252 seconds]
<dim>
I think I solved my SBCL heap exhausted problem... I'm now using CCL
<dim>
it's a very good trick that I recommend
<beach>
Heh.
pierpal has joined #lisp
<dim>
sometimes I wish I had the time and skills to have a look at the SBCL GC, more often I'm just so grateful that we have CCL around
earl-ducaine has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
drot has quit [Quit: Quit.]
drot has joined #lisp
<shka>
i have absolutly no idea why sbcl's GC is subpar
<jackdaniel>
it might be very well allocation technique which requires cleverer gc, or sbcl simply allocates more (in order to have faster code for example) etc etc
<beach>
shka: I suppose it was written a few decades ago, and then it has been patched to allow for non-moving objects and such.
igemnace has quit [Quit: WeeChat 2.1]
<shka>
it all may be very well true, i guess
<beach>
shka: For one thing, it requires a fixed-size heap that can't be expanded as needed.
Guest4215 has quit [Ping timeout: 252 seconds]
<fe[nl]ix>
dim: you can start SBCL with a 512G heap like CCL does
<shka>
i tried to do that
<shka>
but i got heap corruption
<beach>
shka: I would like to turn your remark around like this: There is no reason to believe that ANY free Common Lisp implementation uses modern GC technology, simply because they were all initially created several decades ago.
<dim>
fe[nl]ix: I can always try, but well, SBCL actually uses way more memory than CCL at the same task with pgloader
<shka>
beach: well, that's sad
<dim>
beach: is there some theory behind precise vs generational GC that might explain?
energizer has quit [Ping timeout: 264 seconds]
<beach>
shka: On the contrary, I make my living because of this situation. :)
<beach>
dim: Yes, I can do that.
<beach>
Actually, those two are orthogonal concepts.
<beach>
There is a distinction between "precise" and "conservative".
skeuomorf has quit [Ping timeout: 240 seconds]
<beach>
A precise collector requires help from the compiler to know what is in all registers and stack locations in every stack frame.
<beach>
One way to make sure that is trues, is to divide the registers into two sets, registers containing Common Lisp objects and registers that contain binary stuff not to be traced.
pierpal has quit [Quit: Poof]
<beach>
On x86-64 that leaves to few registers for either purpose.
pierpal has joined #lisp
<beach>
So SBCL doesn't do that.
<beach>
Another way is to make sure the compiler emits information for each value of the program counter, stating what register contains what.
<beach>
SBCL doesn't do that either.
<beach>
So SBCL scans the stack conservatively.
<beach>
Anything that looks like a pointer is assumed to be one.
<beach>
But, this technique has some restrictions. You can't move objects around arbitrarily, because if was really a raw integer, you will modify it, violating the semantics of your code.
<beach>
dim: Makes sense?
<dim>
also let's note that SBCL is *way* faster than CCL, but only until it crashes because of heap exhaustion
<beach>
Sure.
<dim>
makes sense
<beach>
dim: Generational collectors depend on the generational hypothesis: Most objects die young, and the longer an object is live, the more likely it is to stay that way.
<dim>
thanks for the explaining
<dim>
we have a buffer eviction policy done that way in PostgreSQL, with a kind of a generation increment from 1 to 5, and 5 means forever, basically
<beach>
dim: So objects are divided into generations. It is typically done by splitting the heap into independent generations, but there are other techniques.
<beach>
Objects that have been live for a long time are promoted to an older generation.
<dim>
as a mere CL programmer/user, how can you hint SBCL GC into doing a better job? or as a general approach, how to track what conses and how to cons less?
<beach>
Typically, the age is measured by the fact that they survived a collection of their generation.
<dim>
sometimes I'm thinking I should get myself a personal training on CL consing avoidance techniques which would include a review and improvement of the pgloader code
<beach>
dim: That's to SBCL-specific for me to know. Maybe #sbcl would be a better place for that question.
<dim>
well consing in general I'm quite sure you know lots about it
<dim>
but it might be too general to address in a chat that way
<beach>
dim: It is not clear that avoiding consing is going to make performance better, nor is it clear that it will solve the heap-exhaustion problem.
Fare has joined #lisp
<beach>
dim: Just to give you some idea of how complex this stuff is:...
<beach>
If you reuse CONS cells, you might create pointers from older objects to younger objects. Then the memory manager may have to record those pointers specially when a GC of a young generation is performed.
<dim>
that would explain why I can't seem to be able to fix that problem, no matter how much time and energy I've spent on trying to have pgloader cons less
<beach>
Such pointers are assumed to be rare, and of you have a lot of them, performance may suffer.
python476 has joined #lisp
<beach>
Yeah, it is not that simple.
<dim>
I don't think I'm reusing cons cells much in pgloader
<beach>
I am just telling you one particular issue.
iqubic` has joined #lisp
<beach>
Just so you know that you need to know the details of the GC in order to know how to optimize for it.
<dim>
the main thing I do is receive bytes from the network (typically a database driver gets that for me), then I push the data (vector of strings) into a lparallel queue (pointers, no copy), then another thread pops from the queue and transform the data into another vector of (unsigned-byte 8) this time (utf-8 representation ready for pg copy protocol), and then we send that up the network again to pg
iqubic has quit [Ping timeout: 276 seconds]
<dim>
I also have a “batch” notion that happens after the transform and before pushing in the network to pg, where I keep around everything that is going to be sent in vectors of 25000 elements, so that in case of error I can replay the vector and skip erroneous lines
<beach>
dim: Maybe the SBCL maintainers can draw some conclusion from that use case. I certainly can't.
<dim>
without having to transform again, to keep replay not too costly
<dim>
beach: fair enough
<dim>
just though being too generic wouldn't help much ;-)
<beach>
That's true too. :)
<beach>
Anyway, lunch time.
<beach>
I'll be back later.
<dim>
have a good break!
mingus has quit [Read error: Connection reset by peer]
schoppenhauer has quit [Ping timeout: 240 seconds]
mingus has joined #lisp
kajo has quit [Ping timeout: 245 seconds]
milanj has joined #lisp
<nirved>
dim: does (sb-ext:gc :full t) help?
kajo has joined #lisp
Kuloto has left #lisp [#lisp]
<xificurC>
we're trying out ABCL in a java app, planning to use it as a scripting language. My problem is with multithreading. If 2 threads are creating a new package will they clobber each other or can I ensure thread safety for them
Fare has quit [Ping timeout: 245 seconds]
<dim>
nirved: I do that after each batch, and it doesn't in that case, no
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
pierpal has quit [Ping timeout: 268 seconds]
Kaisyu has quit [Quit: Connection closed for inactivity]
schweers has joined #lisp
wigust has joined #lisp
Fare has joined #lisp
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
hhdave has joined #lisp
Younder has joined #lisp
pierpal has joined #lisp
fikka has joined #lisp
Cymew has joined #lisp
Fare has quit [Remote host closed the connection]
schoppenhauer has joined #lisp
zooey has quit [Ping timeout: 250 seconds]
EvW has joined #lisp
eli_oat has joined #lisp
Kevslinger has joined #lisp
zooey has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
eli_oat has quit [Ping timeout: 252 seconds]
mingus` has joined #lisp
xh4_ has joined #lisp
mingus has quit [Ping timeout: 245 seconds]
xh4 has quit [Read error: Connection reset by peer]
himmAllRight has quit [Quit: WeeChat 2.0.1]
markong has joined #lisp
octobanana has quit [Read error: Connection reset by peer]
EvW has quit [Ping timeout: 276 seconds]
EvW1 has joined #lisp
eli_oat has joined #lisp
eli_oat has quit [Client Quit]
milanj has quit [Quit: This computer has gone to sleep]
schweers has quit [Remote host closed the connection]
xh4 has joined #lisp
TCZ has joined #lisp
jgoss has joined #lisp
xh4_ has quit [Ping timeout: 264 seconds]
warweasle has joined #lisp
FreeBirdLjj has joined #lisp
jgoss has quit [Quit: Leaving]
FreeBirdLjj has quit [Ping timeout: 248 seconds]
xh4 has quit [Read error: Connection reset by peer]
xh4 has joined #lisp
oleo has joined #lisp
margeas has joined #lisp
milanj has joined #lisp
markong has quit [Ping timeout: 260 seconds]
FreeBirdLjj has joined #lisp
eschatologist has quit [Ping timeout: 276 seconds]
<xificurC>
anyone knows an equivalent of `dirname $0`? I.e. finding the directory of the lisp file that is being loaded
<flip214>
xificurC: you're welcome... I hope that helps a bit
myrkraverk has quit [Ping timeout: 252 seconds]
ebrasca has quit [Read error: Connection reset by peer]
markong has joined #lisp
margeas has quit [Ping timeout: 256 seconds]
eschatologist has quit [Ping timeout: 252 seconds]
mingus`` has joined #lisp
Kundry_Wag has joined #lisp
quazimodo has quit [Remote host closed the connection]
mingus` has quit [Ping timeout: 264 seconds]
quazimodo has joined #lisp
quazimod1 has joined #lisp
Bike has joined #lisp
quazimodo has quit [Client Quit]
quazimod1 has quit [Client Quit]
jgoss has joined #lisp
myrkraverk has joined #lisp
Kundry_Wag has quit [Ping timeout: 245 seconds]
EvW1 has quit [Remote host closed the connection]
EvW has joined #lisp
LiamH has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
margeas has joined #lisp
Seamsot has joined #lisp
markong has quit [Ping timeout: 260 seconds]
Seamsot has left #lisp [#lisp]
hhdave has quit [Quit: hhdave]
kmurphy4 has joined #lisp
gigetoo has quit [Read error: No route to host]
gigetoo has joined #lisp
sjl_ has joined #lisp
jason_m has quit [Ping timeout: 260 seconds]
eschatologist has joined #lisp
sjl has quit [Quit: WeeChat 2.1]
AntiSpamMeta has quit [Quit: Automatic restart triggered due to persistent lag.]
AntiSpamMeta has joined #lisp
rippa has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
klm2is has joined #lisp
igemnace has joined #lisp
random-nick has joined #lisp
klm2is has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Kundry_Wag has quit [Ping timeout: 260 seconds]
mindCrime has joined #lisp
JuanDaugherty has quit [Quit: Exeunt]
schweers has joined #lisp
TCZ has quit [Quit: Leaving]
Kundry_Wag has joined #lisp
pierpal has joined #lisp
mingus``` has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
mingus`` has quit [Ping timeout: 245 seconds]
klm2is has joined #lisp
milanj has joined #lisp
iqubic` has left #lisp ["ERC (IRC client for Emacs 25.3.1)"]
kmurphy4 has quit [Quit: kmurphy4]
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
_cosmonaut_ has quit [Ping timeout: 260 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<klm2is>
When I define a method in allegro cl with (defmethod foo ((x string)) (declare (ignore x)) (values)), I get a compiler warning for the variable x being used although it was declared ignored. Is this true of other implementations? Should it work this way?
<beach>
Yes, it is used in the dispatch.
kmurphy4 has joined #lisp
<Bike>
"The expansion of the defmethod macro ``refers to'' each specialized parameter (see the description of ignore within the description of declare)." says clhs defmethod
<klm2is>
Makes sense. I was trying out cl-mustache and noticed that it has code like this in some places. I didn't know if that was an implementation thing.
__rumbler31 has joined #lisp
<klm2is>
Thank you both.
<beach>
Anytime.
<klm2is>
@Bike I read that, but I didn't know whether it's then required for the implementation to provide a warning.
FreeBirdLjj has quit [Remote host closed the connection]
<sjl_>
SBCL doesn't have that behavior
sjl_ is now known as sjl
<Bike>
it's not required to, but it's certainly allowed to, which is what you're concerned with, no?
Cymew has quit [Remote host closed the connection]
<dlowe>
klm2is: use "ignorable" instead of "ignore" and you won't get the warning
Cymew has joined #lisp
<klm2is>
Thanks
fikka has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 256 seconds]
kmurphy4 has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
EvW has quit [Ping timeout: 245 seconds]
_cosmonaut_ has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
EvW1 has joined #lisp
__rumbler31 has quit [Ping timeout: 268 seconds]
fikka has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
karlosz has joined #lisp
python476 has quit [Ping timeout: 252 seconds]
Cymew has joined #lisp
karlosz has quit [Client Quit]
orivej has joined #lisp
karlosz has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
igemnace has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 252 seconds]
fikka has joined #lisp
__rumbler31 has joined #lisp
Cymew has joined #lisp
varjag has joined #lisp
Cymew has quit [Ping timeout: 245 seconds]
smurfrobot has quit [Remote host closed the connection]
FreeBirdLjj has joined #lisp
xh4_ has joined #lisp
smurfrobot has joined #lisp
xh4 has quit [Ping timeout: 264 seconds]
FreeBirdLjj has quit [Ping timeout: 265 seconds]
BitPuffin has joined #lisp
margeas is now known as markong
LiamH has quit [Read error: Connection reset by peer]
python47` has joined #lisp
__rumbler31 has quit [Ping timeout: 245 seconds]
python47` has quit [Read error: Connection reset by peer]
xaxaac has joined #lisp
LiamH has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<araly>
hey everyone, I have a question, if I have a function like (parse-integer) which returns two values, the number parsed and the size of the string understood, how can I use both ?
<sjl>
(nth-value 1 ...) (1 because the values are numbered 0, 1, ...)
<araly>
oh nice, that's what I was searching for thanks
Cymew has quit [Ping timeout: 256 seconds]
<aeth>
I usually use (multiple-value-bind (foo bar) (whatever) (declare (ignore foo)) ...)
<aeth>
Verbose but very explicit.
<aeth>
If I used nth-value I'd probably wrap it in a trivial function just to make it more readable.
<araly>
how does that work ?
rumbler31 has quit [Ping timeout: 268 seconds]
<aeth>
I bind all of the values and then discard the one(s) I don't use. Ideally, the compiler will optimize it to be the same as nth-value
Cymew has joined #lisp
<araly>
so where would I put my function that returns two values, at the place of "whatever" ?
karlosz has quit [Ping timeout: 265 seconds]
<aeth>
yes
<araly>
okay
<aeth>
It depends on what you're going for, though. If it's common enough just defining a trivial function is probably the way to go. e.g. (defun hash-table-value-exists-p (key hash-table) (nth-value 1 (gethash key hash-table)))
<aeth>
That's common enough that it's probably best as its own function.
scymtym has joined #lisp
<aeth>
In fact, I should probably use that in my own code.
<aeth>
But imo you should either do a function wrapping nth-value or a multiple-value-bind that ignores the values you don't need because either will be more self-documenting than just using nth-value.
Cymew has quit [Ping timeout: 245 seconds]
skeuomorf has quit [Remote host closed the connection]
<araly>
okay
<araly>
well for this time I'm just using the second value of a function once, but I will turn it into a function if it turns out I use it again after
<aeth>
Seems reasonable.
karlosz has joined #lisp
<aeth>
For very trivial functions that are small and probably will never change, you can declare them inline above the function definition, e.g.: (declaim (inline hash-table-value-exists-p))\n(defun hash-table-value-exists-p (key hash-table)\n...
<aeth>
So there's basically no reason not to use trivial functions when it makes the code better. It's very idiomatic.
Guest95467 is now known as mrSpec
Bike has quit [Ping timeout: 260 seconds]
rumbler31 has joined #lisp
mindCrime has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
xh4_ has joined #lisp
xh4 has quit [Read error: Connection reset by peer]
nirved has quit [Quit: Leaving]
rumbler31 has joined #lisp
rumbler31 has quit [Remote host closed the connection]
shka_ has quit [Ping timeout: 252 seconds]
<stylewarning>
Has anybody worked on or thought about being able to write small snippets of inline C code in Lisp?
fikka has joined #lisp
<stylewarning>
That's friendly with the build process?
<oleo>
you mean as a templating engine ?
<oleo>
so you don't compile C in lisp, just use it to generate your C code ?
<oleo>
i think that can be done yes
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 252 seconds]
nirved has joined #lisp
Kundry_Wag has quit [Remote host closed the connection]
<MichaelRaskin>
Cmera (or how is it even written) would even allow you to generate C from Lispy syntax
ted_wroclaw has joined #lisp
Quetzal2 has quit [Quit: ?? Bye!]
Kundry_Wag has joined #lisp
<aeth>
I generate a limited subset of GLSL from s-expressions. Nothing really stops me from finishing GLSL and then also adding what syntax C has on top of that.
<aeth>
going s-expressions->strings isn't too challenging of a task
<aeth>
The strings can even be made at compile time from the expressions. It would greatly complicate your build process, though.
Folkol has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
xrash has joined #lisp
<aeth>
It wouldn't be truly "inline" because the C compiler wouldn't be cooperating, unless you built the C compiler yourself, which is totally doable non-portably in SBCL.
<stylewarning>
I mean, sometimes it's annoying to write Lisp code that looks identical to C, except it's 10x more verbose and still less performant.
fisxoj has joined #lisp
<stylewarning>
Maybe it would be nice to just compile a C function to some anonymous library and dynamically load it or something, I don't know.
<aeth>
Are the internals exposed by SBCL (e.g. define-vop) sufficient to write a C compiler with?
<stylewarning>
Almost surely.
rumbler31 has joined #lisp
<aeth>
That would be an interesting alternative to relying on foreign C, although it wouldn't be portable.
bbobb has quit [Ping timeout: 245 seconds]
Blkt has quit [Remote host closed the connection]
fe[nl]ix has quit [Read error: Connection reset by peer]
fe[nl]ix has joined #lisp
Blkt has joined #lisp
<stylewarning>
When you're writing high-performance code, it's rarely portable.
<pjb`>
stylewarning: what about the verbosity of (logbitp b n) in C?
<stylewarning>
pjb`: what about it?
<pjb`>
write it in C!
<aeth>
Write a function that returns multiple values in C.
<stylewarning>
this isn't a competition
<aeth>
(My low-level CL is filled with multiple values.)
<pjb`>
or (setf (ldb (byte s p) n) f)
<stylewarning>
the fact of the matter is that C has a good DSL for many kinds of bitwise operations, and you can trust a C compiler to produce good code for those
<pjb`>
stylewarning: it's a comparison: CL is lower level a programming language than C
<stylewarning>
this is also not to say that you can't write such in Lisp, which was what I was originally suggesting
<aeth>
pjb`: With the exception of GC.
<stylewarning>
pjb`: i'll believe you when CL isn't tagging bits and boxing things
<pjb`>
the fact of the matter is that CL has a much better DSL for bitwise operations!
<pjb`>
and actually it has 4 different ways to do it!
<aeth>
pjb`: Depends.
<stylewarning>
pjb`: lisp is more mathematical, and hides the machine representation of data pretty well.
<stylewarning>
pjb`: C is consequently not very mathematical, and lets you interpret bits however you'd like
<aeth>
CL has a type system. C is a bunch of bits.
<stylewarning>
anyway, this is non-interesting, because it's a usual rehash of what everybody already knows
<pjb`>
Then don't ask about the verbosity of 0xFFFFFFFF & *(uint64_t*)(&f) in CL?
<aeth>
pjb`: There would be advantages to writing either C strings or s-expressions that trivially map to C-strings directly in CL source, which was the original point.
<stylewarning>
pjb`: Did I ask about the verbosity? I think I asked about C in Lisp.
<aeth>
("C strings" as in strings of C, not the hideous representation of strings that C has.)
<pjb`>
The sources of Zeta-C are available also (if you wanted to port/rewrite it in CL).
<pjb`>
And I started a C compiler written in CL (only the pre-processor so far).
<pjb`>
As you can see, there are several ways to embed C code in CL.
<pjb`>
You might be interested in having a closer look at vacietis.
<aeth>
pjb`: I wonder if it would be better to back the C memory in an emulated C by CFFI's C array representation or by static-vectors rather than CL arrays. Then you get interoperability with C libraries, too.
Kundry_Wag has quit [Remote host closed the connection]
<pjb`>
It's an idea.
<MichaelRaskin>
ECL does have some inline C support, as it goes through C compiler anyway
<pjb`>
It depends on what you want. If you want speed, it might be a way to do it.
<pjb`>
If you want safetly, I would avoid FFI.
<pjb`>
s/tly/ty/
<aeth>
static-vectors would work best, then, because you could trivally substitute normal CL arrays instead of using static-vectors, but share most of the code.
<MichaelRaskin>
Also, it has a good idea how to interpret values in C (because it has to)
<pjb`>
Only if you need interoperability.
<aeth>
We'll need C interoperability for the forseeable future, unfortunately.
<pjb`>
My take is to shift the C environment into the lisp environment (and therefore uplift it to the same safety level as lisp).
kajo has quit [Remote host closed the connection]
<pjb`>
So you wouldn't do FFI, you would just compile the foreign C library with my future compiler and obtain lisp object code.
<aeth>
The issue is APIs. CLX is a rare exception to this.
kajo has joined #lisp
<pjb`>
aeth: what is C interoperability? As long as you have the C sources (which is the case most of the time), you could just recompile them in lisp.
Kundry_Wag has joined #lisp
<aeth>
One example is 3D graphics APIs as well as input/window/sound/etc. A lot of graphical CL apps use cl-opengl with cl-sdl2 for this reason, although in theory you could probably write directly to the OS APIs and bypass the need for something like SDL2 as a dependency.
<aeth>
A graphics toolkit ported to cl-opengl or (in the future) cl-vulkan could, if you don't care about not feeling native (and only macOS users seem to care about that), bypass most, but not all C.
<stylewarning>
pjb`: out of curiosity, have you written much code that has to process terabytes of numerical data in Lisp?
<aeth>
Alternatively, a future revision to the CL standard could include all of these OS APIs into the standard itself. Then the implementors would deal with it and anything written in CL itself would technically be pure CL without touching C APIs.
<aeth>
Sounds unnecessary just for purism, though
<pjb`>
stylewarning: obviously, I'm not in that hurry, or I'd use cuda!
<aeth>
(Some things that require OS C APIs probably could be moved into the language, though.)
<pjb`>
And notice how with cuda, you send SOURCE code to the nvidia GPU!
<stylewarning>
ok
light2yellow has quit [Quit: light2yellow]
<aeth>
pjb`: In the near future you could compile, via a written-in-Lisp compiler, a Lisp-like language to SPIR-V and send that to the GPU. You'd still have to deal with the OpenCL/OpenGL/Vulkan/whatever API, though.
LiamH has quit [Quit: Leaving.]
milanj has quit [Quit: This computer has gone to sleep]
<aeth>
There does seem to be a bare minimum of foreign code necessary
<pjb`>
what if you compile opengl in CL? and use the cuda backend?
<aeth>
OpenGL as in libmesa or something?
<pjb`>
yes.
xh4 has joined #lisp
<aeth>
Then you'd have to interface with the Linux kernel
<aeth>
At some point, C comes up unless it's a Lisp OS
<pjb`>
Yes, the syscalls are the only FFI required.
<pjb`>
and syscalls are NOT C FFI.
<pjb`>
Well, they're C data structures, but not C function calls.
<pjb`>
We've also discussed in defining a syscall API using CL data types instead of C type.
xh4_ has quit [Ping timeout: 252 seconds]
<pjb`>
Kind of like X11 has actual lisp symbols (29-bit + tag bits).
lumm has quit [Quit: lumm]
<pjb`>
Yes, X was once written in lisp…
<pjb`>
Like Postgres, like javascript, like everything… :-(
<aeth>
For the forseeable future, though, you'll want: access to some POSIX things not in the CL standard, access to the GPU, windowing/input, sound, and a few other things.
<aeth>
And if you want portability, on Windows you can't use the syscalls and expect them not to break. You'd have to use CFFI there.
<aeth>
iirc.
<pjb`>
aeth: the only argument is proprietary binary libraries. The key word above was SOURCE.
sjl has quit [Quit: WeeChat 2.0.1]
sjl has joined #lisp
<pjb`>
aeth: yes, but on MS-Windows, you use different CL implementations anyways. You don't run the same CL executable both on MS-Windows and on Linux (unless you use the Linux-in-Windows-10 thingy.
<pjb`>
)
<White_Flame>
pjb`: I, too, have a dream of C-in-Lisp compilation & native API access. Have you done any work on it so far?
<pjb`>
aeth: the idea here is that a CL implementation could provide a native access to syscalls, without calling libc.
<pjb`>
White_Flame: so far, only the pre-processor is implemented, and I started working on the parser.
<aeth>
pjb`: which can be done, for the Linux kernel
<pjb`>
But I've not been able to work on it for 2.5 years at least…
<pjb`>
And since I'm launching a start up now, I won't have any time soon.
<pjb`>
If we become billionnaire, I promise to fork some of it to complete this C to CL compiler :-)
<aeth>
pjb`: GPU, windowing, input, and sound will probably not be pure-CL, however.
<aeth>
In fact, I'd argue that it's basically a waste of time for now.
<pjb`>
aeth: it is in Mezzano, so why not on Linux?
<Bike>
can we stop arguing about this crap
<aeth>
Top down. Start with user-facing things. Replace the middle layers later.
* edgar-rft
donates a billion conses to pjb
<pjb`>
Thanks for the conses!
<aeth>
People will want Lisp middle layers if they have Lisp top layers.
* aeth
optimizes edgar-rft to be non-consing
<edgar-rft>
pjb`, sorry, but it's all garbage
<aeth>
edgar-rft: Does that make pjb` a garbage collector?
<edgar-rft>
he already was before
Kundry_Wag has quit [Remote host closed the connection]
<pjb`>
You know he's the most powerful character in Dilbert?
<edgar-rft>
after the nuclear war garbage collectors will be the kings of earth
pjb` is now known as pjb
light2yellow has joined #lisp
kajo has quit [Ping timeout: 245 seconds]
kajo has joined #lisp
<aeth>
The way I'd see graphical Lisp in the near future is: write to SDL and OpenGL, but be flexible about the SDL part. Eventually, the input/windowing part could be replaced with a more Lispy solution. I suppose OpenGL is just so complex that pjb's solution would be necessary for Lisp purists, although eventually migrating over to the simpler Vulkan might present a simpler future solution.
<aeth>
What will probably happen is either SDL will still be in use on non-Linux platforms or there will be an SDL-replacement that uses the native APIs and some OSes will need CFFI for those (but there wouldn't be any C *dependencies* that need to be shipped)
Kundry_Wag has joined #lisp
<aeth>
All of this is still quite low level. If you wanted McCLIM or whatever, there'd probably be a new OpenGL backend to it eventually.
<pjb>
Intel is creating its own GPUs. There will be some competition in the backends. So perhaps libraries like OpenGL will strive.
<White_Flame>
is there any software out there that doesn't use opengl/d3d/etc types of libraries?
<pjb>
But for computing jobs, I guess people will choose to use the native SDKs. (ie. program directly in cuda). In that case, OpenGL is irrelevant.
<White_Flame>
I guess I mean graphical software specifically
<pjb>
Games?
<aeth>
White_Flame: There are three ways to do a GUI. Browser (or electron), 3D APIs, or directly using the 2D APIs. Unless you're doing very simple things, you want the 3D APIs.
<White_Flame>
pjb: or visualization/modeling. or just plain GUIs
<aeth>
The old 2D APIs are not designed with performance on modern hardware in mind
<aeth>
e.g. You can do 2D stuff in X directly. You shouldn't.
<White_Flame>
pjb: for compute, is cuda winning out over opencl?
<aeth>
White_Flame: Only because Nvidia is winning over AMD/Intel.
<pjb>
In Deep Learning etc, I would say yes.
<aeth>
White_Flame: The future is (hopefully) any language you want compiled to SPIR-V and run in OpenCL or Vulkan compute (they're both from Khronos, so there'd be a heavy overlap in features)
al-damiri has joined #lisp
<aeth>
You'd still have the OpenCL or Vulkan API, but a lot of the toolchain could be pure Lisp, such as your own compiler to SPIR-V.
<aeth>
(OpenGL can also now use SPIR-V and also has compute functionality.)
smurfrobot has quit [Ping timeout: 260 seconds]
<White_Flame>
there seemed to be an implication of running graphics without libs like ogl, which read strangely
<White_Flame>
which prompted my initial question
<White_Flame>
specifically higher performance libs, not just dumb framebuffers
<aeth>
White_Flame: pjb was talking about potentially compiling stuff like libmesa in a C-on-CL compatibility layer.
<aeth>
JS is a language that cannot be fast without JIT. I guess you could "JIT" a language that is transpiled to CL because CL can recompile functions at runtime, though.
<aeth>
I'd be interested to know if anyone has attempted this.
<White_Flame>
I talk about it relatively frequently. The usual target for runtime recompilation has been CLOS dispatch
ted_wroclaw has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<pjb>
theemacsshibe[m]: deep in the old sources of firefox/mozillay, there's the sources of an implementation of an old JavaScript in CL.
<aeth>
White_Flame: I think you talk about JITing a CL implementation. I'm talking about using runtime recompilation in an existing AOT CL to emulate JIT in a language like JS or Lua that is being compiled to CL.
pierpal has quit [Ping timeout: 240 seconds]
Kundry_Wag has quit [Remote host closed the connection]
<pjb>
theemacsshibe[m]: probably you'll have to locate an old version, because I guess they've pruned it.
<theemacsshibe[m]>
I couldn't navigate their version control thing.
<White_Flame>
aeth: there's actually little difference, and CLOS dispatch is an example of what you describe
<White_Flame>
(though it's not a _langauge_ it's jitting)
<pjb>
theemacsshibe[m]: it would be a nice project to take the latest javascript standard, and write an implementatio of it in CL targetting CL.
<pjb>
theemacsshibe[m]: an alternative project would be to write a LLVM backend in CL, and use the Javascript -> LLVM compiler.
<aeth>
Assuming the JIT emulation idea works
msb has joined #lisp
<aeth>
pjb: If you wrote an LLVM backend in CL, you get way more than just JS. You also get Clasp.
<pjb>
of course.
<pjb>
and clang. Does GNU emacs compile with clang?
<pjb>
IIRC, it uses a few GNU C extensions.
<pjb>
and my original purpose was to compile GNU emacs to CL…
<aeth>
Unfortunately, the Linux kernel doesn't quite compile with clang. If it did, you could have Linux-on-CL
<aeth>
Two things need to be ported to everything: Doom and Linux
<White_Flame>
yes, implementing x86 sounds reaaaaaally easy!
<pjb>
it's not too hard.
<aeth>
You could implement physics in CL
<pjb>
I wrote one in 68000 on Mac in 1985…
<pjb>
The problem was more the bugs in the IBM-PC BIOS…
light2yellow has quit [Quit: light2yellow]
<White_Flame>
x86 is a goofball pile of hodgepodge
<pjb>
Of course, you'd want at least 486 for linux…
<White_Flame>
68k is clean as a congressman's official criminal background
<White_Flame>
but yeah, you can always pick a subset that something happens to use, instead of trying to reimplement all of it
rumbler31 has joined #lisp
<White_Flame>
I also shudder to imagine implementing an interface from CL through x86 interpreter through JSLinux through node.js
<pjb>
the only problem with the 68000 is that it loses information on some traps, so you cannot write a multitasking OS on it. There was a unix workstation using 2 68000 with one running one clock late to kludge this bug.
<White_Flame>
is that 68000 only, not 68020+?
<White_Flame>
(also, Amiga scoffs your assessment)
<White_Flame>
(as it guru meditates)
terpri has quit [Ping timeout: 252 seconds]
xrash has quit [Read error: Connection reset by peer]
karswell has quit [Read error: Connection reset by peer]
pierpa has joined #lisp
<pjb>
it's possible, I don't remember well enough.
<pjb>
But IIRC, this 2-68000 system was before the 68020, so…
karlosz has quit [Ping timeout: 248 seconds]
rumbler31 has quit [Ping timeout: 252 seconds]
random-nick has quit [Read error: Connection reset by peer]
rumbler31 has joined #lisp
milanj has joined #lisp
fisxoj has quit [Quit: fisxoj]
Cymew has joined #lisp
mindCrime has quit [Ping timeout: 252 seconds]
papachan has quit [Quit: WeeChat 2.1]
Mutex7 has quit [Quit: Leaving]
Cymew has quit [Ping timeout: 252 seconds]
xaxaac has quit [Quit: Leaving]
margeas has joined #lisp
karswell has joined #lisp
markong has quit [Ping timeout: 264 seconds]
markong has joined #lisp
karlosz has joined #lisp
margeas has quit [Ping timeout: 256 seconds]
Kundry_Wag has joined #lisp
dmiles has quit [Read error: Connection reset by peer]
margeas has joined #lisp
markong has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 245 seconds]
markong has joined #lisp
Kundry_Wag has quit [Ping timeout: 252 seconds]
varjag has quit [Ping timeout: 245 seconds]
margeas has quit [Ping timeout: 248 seconds]
dmiles has joined #lisp
dmiles has quit [Read error: Connection reset by peer]
Guest5936 has quit [Ping timeout: 264 seconds]
milanj has quit [Quit: This computer has gone to sleep]