<aeth>
there really isn't way to do this that makes everyone happy... unless you heavily CLOSify things so that they can effectively rewrite large parts of what you're doing via :around methods
<_death>
keep the markup language constrained.. don't allow html escape, but do allow more limited extension
khisanth_ has quit [Ping timeout: 240 seconds]
<aeth>
_death: What I'm going to do is I'm going to actually parse the HTML in the Markdown files so that I can eventually translate *those* into my intermediate format(s) as well as the Markdown itself.
<aeth>
So... now I have to write a subset of an HTML parser. I'm going to probably be stricter than some who lazily pass through the HTML or something to let browsers magic together a best-guess of what you meant
<aeth>
But now it suddenly turns one of the simplest markups into also including (a subset of) one of the hardest, so I'm going to procrastinate that for a while
<_death>
what about mathematical formulas.. it's not hard to extend markdown to support, say, mathjax syntax.. but now you need to write your own mathjax
JohanP has joined #lisp
<_death>
I remember a long time ago xof showed off some mcclim hack displaying math formulas
superkumasan has joined #lisp
<aeth>
_death: Well, presentation MathML should trivially follow from HTML generation. I mean, it's hideously ugly, but that only will affect generation speed a bit and memory a bit, since you never have to directly touch it. https://en.wikipedia.org/wiki/MathML#Presentation_and_semantics
JohanP has quit [Ping timeout: 240 seconds]
<aeth>
I also already deal with changing the writer in the middle of writing the content (for directly-embedded CSS in <style>) so that's just going to be yet another special case tag
prite has quit [Ping timeout: 276 seconds]
<_death>
talking about the rendering.. but I guess it's something for the future ;)
mindCrime_ has quit [Ping timeout: 276 seconds]
khisanth_ has joined #lisp
<aeth>
_death: I thought MathML is supported in modern browsers and something like MathJAX is for legacy browsers? Although most people who generate equations rarely check that the browser can actually do it without having to go down the legacy branch (another alternative many do, e.g. Wikipedia, is generating images)
<aeth>
_death: but, yes, there would also have to be another path for the native GUI, when that happens
<_death>
aeth: I dunno.. some time ago I wrote a static blog generator with a friend that rendered markdown using 3bmd.. it had support for writing latex to be rendered by mathjax, since the friend was used to writing in that notation
<aeth>
_death: Yet another case of a monopolist holding technology and standard back, I guess. Their solution "use JavaScript" is, of course, good for their bottom line since using JavaScript enables the tracking that drives their megacorporation.
<aeth>
I think I'll use MathML and MathML alone anyway. Maybe with a link to download Firefox. :-)
<aeth>
Basically if you're just a Chromium reskin, you can't use MathML, but if you're any other browser (even Webkit) you can. https://caniuse.com/#search=mathml
<aeth>
(okay, IE/Edge don't support it either, but IE supports nothing interesting and Edge was basically trying to be functionally compatible with Chromium until they decided to eventually switch their backend to Chromium to save the effort)
<_death>
chromium: math is hard, let's emoji
<aeth>
The presentation MathML example from Wikipedia works perfectly fine in Firefox.
vms14 has joined #lisp
<_death>
since browsers are gluttons for complexity, why have mathml instead of the notation that everyone uses already (latex)
lucasb has quit [Quit: Connection closed for inactivity]
<_death>
it would make my life easier, for sure.. (I use a browser with js disabled by default.. every site that uses mathjax w/ latex I need to consider and perhaps reopen with a js-enabled browser)
GoldRin has joined #lisp
<aeth>
_death: the general idea is that you would parse the LaTeX subset that everyone uses for equations into (something like) mathml and never write it directly
EvW has quit [Ping timeout: 250 seconds]
<_death>
also, since you talk about javascript that way... it's surprising that you use gitlab, another annoying site that requires javascript to display source code
<aeth>
supporting (the subset of) math LaTeX would set the precedent to do things like directly supporting Markdown
<aeth>
_death: Ah, weird, I thought it only used JS for the syntax highlighting and not the source code entirely, which is fairly common. Requiring JS for a web application is very different than requiring it for a document, though.
<_death>
yes.. at this point nobody in their right mind contemplates writing a browser.. so adding these things is no big deal
<Josh_2>
welllll
<Josh_2>
there is Next :P
<LdBeth>
At this point pure html are in extinction
<_death>
Josh_2: that uses existing engines
<Josh_2>
oh right
<aeth>
_death: Imo, JS in an ordinary web page should only be used for features that aren't essential... so requiring it to render math equations is absolutely unacceptable, since it's essential to the nature of the page (displaying the non-application document correctly). Doing the Wikipedia approach and making equations images is complicated and anti-accessibility (and also makes it hard to search the page)
<aeth>
_death: Something like MathML is much better.
<aeth>
(Even though it is a hideous monstrosity to look at directly and should never be written by hand)
<_death>
aeth: yeah.. though I can't complain about wikipedia's method ;)
JohanP has joined #lisp
<aeth>
_death: Gitlab requiring JS to display source code actually *is* pretty bad, and it's gitlab-static.net so it requires a whitelist of JS to get it to load in umatrix (which only allows first-party JS by default)...
<aeth>
I wonder if it was always the case, probably not
ralt has quit [Quit: Connection closed for inactivity]
<vms14>
but it's written in cl, you could make it suck less
<LdBeth>
It uses WebKit
<LdBeth>
Pretty much needs to figure out the WebKit API to modify it
igemnace has joined #lisp
mindCrime_ has joined #lisp
<aeth>
I mean, technically, it could just add rendering to the HTML parser that I'll have to write to write a complete Markdown parser, when I get to it... but you kind of want compatible rendering, not just rendering.
<vms14>
do you consider using nginx + hunchentoot?
saravia has joined #lisp
<vms14>
I know nginx is good for a load balancer, and it seems to be a very convenient way to use it as a proxy, so it could serve static stuff and use hunch for dynamic stuff
<vms14>
Nginx is one of a handful of servers written to address the C10K problem
bitmapper has quit [Ping timeout: 276 seconds]
_leb has joined #lisp
akoana has joined #lisp
akoana has quit [Max SendQ exceeded]
<vms14>
knowing I have no thread support in sbcl because I use netbsd for me seems even a better option
<vms14>
how usable is hunchentoot w/o threads?
<vms14>
xD
<aeth>
vms14: While technically I am going to have to do "dynamic" HTML as in not-at-macro-expansion-time HTML (for the markdown), I'm writing static HTML here, for Gitlab Pages.
Josh_2 has quit [Ping timeout: 265 seconds]
t58 has joined #lisp
nowhere_man has joined #lisp
akoana has joined #lisp
nowhereman has quit [Ping timeout: 240 seconds]
<vms14>
are you writing a markdown "generator" using reader macros?
Oladon has joined #lisp
<aeth>
vms14: parsing markdown, writing HTML. Technically, the way I write my parser (which I consider idiomatic for CL) makes it trivial to turn into a reader macro since it uses streams
<aeth>
s/parser/parsers/
<vms14>
so regexp
<vms14>
well reader macros should be slower than cl-ppcre
<_death>
no-defun-allowed: it's a greasemonkey script to fetch and "transclude" the source code without needing to enable js in firefox
<no-defun-allowed>
Right then.
ahungry` has quit [Ping timeout: 240 seconds]
semz has joined #lisp
semz has quit [Changing host]
semz has joined #lisp
stux|RC has quit [Ping timeout: 245 seconds]
lxbarbosa has joined #lisp
stux|RC has joined #lisp
<aeth>
_death: technically you are using JS there... :-p
JohanP has joined #lisp
reggie__ has joined #lisp
reggie_ has quit [Ping timeout: 240 seconds]
JohanP has quit [Ping timeout: 240 seconds]
ravenousmoose has joined #lisp
ravenousmoose has quit [Ping timeout: 252 seconds]
zdm has joined #lisp
ahungry` has joined #lisp
leb has joined #lisp
xkapastel has quit [Quit: Connection closed for inactivity]
leb has quit []
JohanP has joined #lisp
_jrjsmrtn has joined #lisp
Bike has quit [Quit: Lost terminal]
__jrjsmrtn__ has quit [Ping timeout: 240 seconds]
mindthelion has quit [Ping timeout: 240 seconds]
analogue has quit [Quit: Leaving]
techquila has joined #lisp
JohanP has quit [Ping timeout: 240 seconds]
ravenousmoose has joined #lisp
GoldRin has quit [Ping timeout: 268 seconds]
vms14 has quit [Remote host closed the connection]
ravenousmoose has quit [Ping timeout: 276 seconds]
ravenousmoose has joined #lisp
ravenousmoose has quit [Ping timeout: 252 seconds]
JohanP has joined #lisp
<seok>
how's lisp arrays performance compare to numpy?
orivej has joined #lisp
enrio has joined #lisp
JohanP has quit [Ping timeout: 265 seconds]
karswell has quit [Remote host closed the connection]
notzmv has joined #lisp
karswell has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
Lord_of_Life_ is now known as Lord_of_Life
<aeth>
seok: The performance is probably going to be worse, but only because of lack of attention, not because of lack of potential. In CL, you can use native arrays for high-performance code, while in Python you have to FFI out to Fortran or C or C++ using something like Numpy.
<seok>
Yeah, that's what I would've guessed
<seok>
Was hopeful something was written in lisp though
<aeth>
seok: except you can basically do the same thing and, for 1D arrays, use FFI with them and call out to the same optimized Fortran or whatever that Numpy uses in its backend
<aeth>
using static-vectors, for instance
<aeth>
But unlike with Python, there's nothing stopping you from writing Fortran-competing numerical code in CL afaik... it's just, a lot of work.
<seok>
: (
<seok>
Was wishing I could use lisp for quick statistical job with a lot of data
<seok>
Thanks aeth
<aeth>
seok: I'm guessing that natively in CL it's probably going to be about 3x slower than the equivalent Fortran/C/C++ because the compiler won't SIMD your operations and there probably aren't many libraries to do that for you with inline asm for SBCL.
<aeth>
seok: Maybe not as bad vs. Numpy because the FFI is going to add some overhead back in.
<seok>
Is there something faster in other implementations?
superkumasan has quit [Ping timeout: 240 seconds]
<aeth>
SBCL is basically the only implementation you're going to have a good time writing numerical code in, even though it will technically run everywhere (as long as you have a slow path if you write a SBCL-specific fast path in asm)
<aeth>
SBCL does more optimziations for this kind of thing, so slower compile time but faster run time.
ravenousmoose has joined #lisp
t58 has quit [Quit: Night]
<aeth>
But if you care about performance, you're probably going to have to FFI not because you need to FFI to write fast numerical code but because there isn't much numerical code in native CL.
<aeth>
Technically that's not quite true. Maxima, a CAS, compiles Fortran to CL, but it uses this antiquated library that generates garbage numerical SBCL. Something written with SBCL's optimizations in mind could probably produce something that generates considerably faster asm when you run DISASSEMBLE.
<aeth>
seok: what are you trying to do, though?
<seok>
Statistics on forex tick data
<seok>
Ive done some a while ago in python
<aeth>
That doesn't sound particularly elaborate.
<aeth>
What functions do you need?
<seok>
Just thought it would've been cleaner if I could do it in CL if I don't have to give up performance
ravenousmoose has quit [Ping timeout: 276 seconds]
<seok>
just simple min max sd correlation covariance
<seok>
on large dataset (~300 million)
<aeth>
Are you willing to write those routines yourself? If you are, you absolutely don't have to give up performance.
<aeth>
You just have to be aware of the quirks of optimizing SBCL.
<seok>
How much writing do you mean?
<Ober>
memory usage
<aeth>
The tl;dr of optimizing SBCL is that you want to do everything in structs of arrays of specific numerical types, ideally with a known length at compile time.
<Ober>
the aver entries make it much less painful to optimize imho
<seok>
I remember that the amount of data I used to run on numpy was around 16gb
<seok>
so it just fit on my ram, didn't have to do batch jobs
<aeth>
If you're working with integers that are larger (or smaller) than the fixnum size but that can fit in signed-byte or unsigned-byte 64, or if you're working with double floats, you want to keep them in arrays and work with mutations so that you don't heap allocate. (optimize (speed 3)) will warn you in SBCL
<aeth>
You'll have to run SBCL with a command line flag to give more heap memory.
<aeth>
I think it defaults to 1 GB or 2 GB.
<seok>
single floats should be fine
<Ober>
e.g. sbcl --control-stack-size 2048 --dynamic-space-size 20480
<aeth>
oh, if you use single-floats it's easy as long as you're using a 64-bit implementation
<seok>
so as long as I keep data in arrays it won't be so bad?
patrixl has joined #lisp
<aeth>
seok: you want to keep your data in arrays with an :element-type that the implementation can optimize. If you have heterogeneous data, you want to do the struct-of-arrays pattern and have multiple parallel arrays in one struct, since the arrays must be homogeneous.
JohanP has joined #lisp
<aeth>
If you're using single-float it's a bit easier because you don't have to worry about accidental heap allocations like with double-float
<aeth>
seok: An example: (make-array 42 :element-type 'single-float :initial-element 0f0)
<aeth>
seok: Now you have a (simple-array single-float (42)) and you have to add type declarations (type hints) so that the compiler can optimize things more fully (although idk if any do this other than SBCL)
saravia has quit [Remote host closed the connection]
<seok>
So i just have to keep things in simple arrays and declare everything in functions?
<aeth>
seok: simple arrays of an element-type that is not T, or those structs with slots with a :type provided, ideally with a known length so bounds checks can be removed
<aeth>
e.g. this is very optimized: (defun foo (x) (declare (type (simple-array single-float (42)) x)) (* 2f0 (aref x 37)))
<seok>
So, I don't know how numpy works in the back, for matrix operations, will optimized loops in CL be just as fast?
<aeth>
If you use double-floats, things get harder... that example but with double-floats wouldn't work well because it would heap allocate the double-float result. With doubles, you have to mutate more if you want to avoid this. Or inline functions.
<seok>
Well, data provided is only given to 6 decimal points anyway, don't think doubles are needed
<aeth>
seok: Modern processors have asm specifically intended for linear algebra, SIMD... single instructions multiple data. So... The numpy routines probably do heavy compiler hinting or inline SIMD to get this.
JohanP has quit [Ping timeout: 276 seconds]
<aeth>
SBCL has some SIMD support but it doesn't do it automatically, so you're going to be working one value at a time.
<seok>
hm
<seok>
python numpy works on single thread only doesn't it?
<aeth>
Python works in a single thread. Perhaps Numpy's foreign code uses more than one.
<aeth>
If matrix performance is an issue, you could call into a BLAS library for matrix multiplication using something like https://github.com/sionescu/static-vectors/ to give you vectors that are both CL-native and C-native, easy to use in FFI
<seok>
I haven't noticed any multi thread activities when I was working with numpy some time ago
<aeth>
static-vector for matrices has two disadvantages: (1) you have to free your data and (2) you have to use 1D arrays, while matrices are more idiomatically expressed with 2D arrays in CL
<aeth>
(the whole "static" thing is so that the GC doesn't move the data around so C code can use it)
<seok>
Wait, if this library is fast with 1d arrays it is perfect
<seok>
Forex data are only 1d arrays
<aeth>
You should be able to use any BLAS library with a C API with static-vectors
<aeth>
(or other numerical C/etc. library)
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<aeth>
It's very easy to e.g. have an API that copies the vectors and destroys performance, and static-vectors is probably too new to be a dependency for many of those
<aeth>
It's absolutely possible to do efficient linear algebra in CL, both natively and FFI, though.
ravenousmoose has joined #lisp
<aeth>
Just doing it natively in CL but with many threads might beat Python+Numpy, especially if you're using a Ryzen 9 3900X or a Threadripper or similar processors.
<seok>
True that
<aeth>
If Python+Numpy is single threaded and 3x faster, I'm guessing if you throw 24+ threads (R9 3900X) at the problem, it goes away.
<no-defun-allowed>
🅿etalisp time
lxbarbosa has quit [Remote host closed the connection]
Ricchi has joined #lisp
<aeth>
seok: Oh, and never assume that single-floats are sufficient, btw, unless you're using numerical algorithms that tell you that.
<aeth>
Outside of graphics, people tend to love doubles...
<seok>
Hm
ravenousmoose has quit [Ping timeout: 276 seconds]
<aeth>
The main thing about double-floats is that you never want to return an individual double-float or call a non-inline function with an individual double-float (by "individual", I mean not in a struct or an array)
<aeth>
(Especially not when your data is in the millions!)
<aeth>
As long as they're in some other box (or if they stay within the scope of one function), they won't be boxed, and that greatly improves performance.
<aeth>
It's just a side effect of how most CL implementations work: something is heap allocated unless it can (with its type tag!) fit in a native word. So a 64-bit type can't fit because it needs a tag.
rippa has joined #lisp
<aeth>
Although if you have so many things, maybe there's a memory constraint to use singles...
gravicappa has joined #lisp
ebzzry has quit [Read error: Connection reset by peer]
ebzzry has joined #lisp
zdm has quit [Quit: nil]
JohanP has joined #lisp
JohanP has quit [Ping timeout: 240 seconds]
libertyprime has quit [Ping timeout: 265 seconds]
ggole has joined #lisp
<beach>
Good morning everyone!
<LdBeth>
Hello beach
<Josh_2>
Mornin'
raghavgururajan has joined #lisp
mindCrime has quit [Ping timeout: 245 seconds]
mindCrime has joined #lisp
mindCrime has quit [Excess Flood]
vlatkoB has joined #lisp
libertyprime has joined #lisp
JohanP has joined #lisp
red-dot has joined #lisp
libertyprime has quit [Read error: Connection reset by peer]
JohanP has quit [Ping timeout: 246 seconds]
ahungry` has quit [Remote host closed the connection]
mankaev has joined #lisp
ebzzry has quit [Ping timeout: 265 seconds]
JohanP has joined #lisp
akoana has left #lisp ["Leaving"]
sauvin has joined #lisp
dale has quit [Ping timeout: 276 seconds]
dale has joined #lisp
_whitelogger has joined #lisp
raghavgururajan has quit [Remote host closed the connection]
mankaev has quit [Ping timeout: 252 seconds]
mankaev has joined #lisp
_whitelogger has joined #lisp
krid has quit [Ping timeout: 276 seconds]
retropikzel has joined #lisp
ralt has joined #lisp
xkapastel has joined #lisp
dale has quit [Quit: My computer has gone to sleep]
ravenousmoose has joined #lisp
ravenousmoose has quit [Ping timeout: 246 seconds]
<selwyn>
good morning all
JohanP has quit [Ping timeout: 265 seconds]
gareppa has joined #lisp
gareppa has quit [Remote host closed the connection]
manualcrank has quit [Quit: WeeChat 1.9.1]
<beach>
Hello selwyn.
gareppa has joined #lisp
mankaev has quit [Ping timeout: 252 seconds]
retropikzel has quit [Remote host closed the connection]
gareppa has quit [Remote host closed the connection]
JohnMS has joined #lisp
ebrasca has joined #lisp
gareppa has joined #lisp
BooAA has joined #lisp
vlatkoB has quit [Remote host closed the connection]
ravenousmoose has joined #lisp
vlatkoB has joined #lisp
ebrasca has quit [Remote host closed the connection]
gareppa has quit [Remote host closed the connection]
Ricchi has quit [Remote host closed the connection]
nowhere_man has joined #lisp
BooAA has quit [Ping timeout: 260 seconds]
jonatack has quit [Ping timeout: 264 seconds]
<MichaelRaskin>
aeth: re: Wikipedia approach: Images with LaTeX source in alt= is not _that_ bad, is there a good accessibility solution that is actually better for MathML?
JohanP has joined #lisp
marusich has quit [Remote host closed the connection]
dddddd has quit [Remote host closed the connection]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
jello_pudding has joined #lisp
shka_ has joined #lisp
varjag has joined #lisp
jonatack has joined #lisp
kamog has joined #lisp
red-dot has joined #lisp
jello_pudding has quit [Remote host closed the connection]
ebrasca has joined #lisp
longshi has joined #lisp
mankaev has joined #lisp
seok has quit [Remote host closed the connection]
ralt has quit [Quit: Connection closed for inactivity]
JohanP has quit [Ping timeout: 268 seconds]
JohanP has joined #lisp
JohnMS has quit [Quit: Konversation terminated!]
prite has joined #lisp
mindthelion has joined #lisp
random-nick has joined #lisp
techquila has quit [Ping timeout: 245 seconds]
JohanP has quit [Remote host closed the connection]
JohanP has joined #lisp
ravenousmoose has quit [Max SendQ exceeded]
ravenousmoose has joined #lisp
JohanP has quit [Ping timeout: 246 seconds]
mankaev has quit [Remote host closed the connection]
jonatack has quit [Ping timeout: 264 seconds]
prite has quit [Ping timeout: 265 seconds]
ravenousmoose has quit [Ping timeout: 246 seconds]
ravenousmoose has joined #lisp
varjag has quit [Quit: ERC (IRC client for Emacs 26.1)]
JohanP has joined #lisp
iovec has joined #lisp
prite has joined #lisp
JohanP has quit [Ping timeout: 240 seconds]
Duuqnd has joined #lisp
heisig has joined #lisp
Blukunfando has joined #lisp
JohanP has joined #lisp
nika has joined #lisp
JohanP has quit [Ping timeout: 265 seconds]
nowhere_man has quit [Ping timeout: 240 seconds]
varjag has joined #lisp
jonatack has joined #lisp
JohanP has joined #lisp
kajo has quit [Ping timeout: 250 seconds]
JohanP has quit [Ping timeout: 252 seconds]
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
jonatack has quit [Ping timeout: 252 seconds]
jonatack has joined #lisp
Guest96001 is now known as borodust
borodust has quit [Changing host]
borodust has joined #lisp
ravenousmoose has quit [Read error: Connection reset by peer]
Inline__ has joined #lisp
ravenousmoose has joined #lisp
Duuqnd has quit [Ping timeout: 240 seconds]
Inline has quit [Ping timeout: 264 seconds]
jonatack has quit [Ping timeout: 268 seconds]
jonatack has joined #lisp
Inline__ has quit [Quit: Leaving]
varjag has quit [Ping timeout: 265 seconds]
zagura has quit [Remote host closed the connection]
Inline has joined #lisp
cartwright has quit [Remote host closed the connection]
jonatack has quit [Ping timeout: 250 seconds]
jonatack has joined #lisp
cartwright has joined #lisp
JohanP has joined #lisp
nowhere_man has joined #lisp
longshi has quit [Quit: WeeChat 2.5]
orivej has quit [Ping timeout: 240 seconds]
JohanP has quit [Ping timeout: 252 seconds]
_whitelogger has joined #lisp
varjag has joined #lisp
varjag has quit [Ping timeout: 276 seconds]
jonatack has quit [Ping timeout: 276 seconds]
zagura has joined #lisp
JohanP has joined #lisp
saravia has joined #lisp
EvW has joined #lisp
JohanP has quit [Ping timeout: 246 seconds]
igemnace has quit [Quit: WeeChat 2.6]
hiroaki has joined #lisp
hiroaki has quit [Ping timeout: 264 seconds]
scymtym has quit [Remote host closed the connection]
cartwright has quit [Remote host closed the connection]
wusticality has joined #lisp
JohanP has joined #lisp
lucasb has joined #lisp
cartwright has joined #lisp
keep_learning has quit [Remote host closed the connection]
jgodbout has quit [Remote host closed the connection]
fitzsim has joined #lisp
wusticality has quit [Remote host closed the connection]
Bike has joined #lisp
JohanP` has joined #lisp
JohanP has quit [Remote host closed the connection]
nowhere_man has quit [Ping timeout: 252 seconds]
JohanP` has quit [Ping timeout: 268 seconds]
ebzzry has joined #lisp
decent-username has joined #lisp
<decent-username>
How can I create a local binding for something like (aref 1 array)?
<decent-username>
My code becomes really messy if I have to write (cell-low-max (aref cell *octant*)).
<decent-username>
Instead I would like to write (cell-low-max c)
JohanP` has joined #lisp
krid has joined #lisp
<_death>
you can use LET to introduce bindings..
<heisig>
decent-username: My suspicion is you want to bind the place, not the value, so that (setf c ...) works, too. In that case, you should have a look at SYMBOL-MACROLET.
kajo has joined #lisp
<decent-username>
heisig: Yeah, something about macrolet was in the back of my mind
<decent-username>
Thanks for pointing me in the right direction
scymtym has joined #lisp
heisig has quit [Quit: Leaving]
FreeBirdLjj has joined #lisp
saravia has quit [Remote host closed the connection]
Kevslinger has quit [Quit: Connection closed for inactivity]
orivej has joined #lisp
ravenous_ has joined #lisp
xuxuru has joined #lisp
ravenousmoose has quit [Ping timeout: 246 seconds]
red-dot has joined #lisp
FreeBirdLjj has quit [Ping timeout: 268 seconds]
saravia has joined #lisp
FreeBirdLjj has joined #lisp
saravia has quit [Quit: Leaving]
saravia has joined #lisp
saravia has quit [Read error: Connection reset by peer]
saravia has joined #lisp
saravia has quit [Remote host closed the connection]
saravia has joined #lisp
saravia has quit [Remote host closed the connection]
saravia has joined #lisp
scymtym has quit [Remote host closed the connection]
JohanP` has quit [Quit: ERC (IRC client for Emacs 26.3)]
<goofist>
Hmm.. I have tried to register with the common-lisp.net gitlab via my github account, but cannot. First I was directed here. But when I followed the link that minion gave me and clicked github, I was directed to an error saying that my account has been blocked.
hhdave has joined #lisp
<goofist>
In a DM with minion, i requested a second link and this time just tried to register with my email address. The registration process informed me that my address is taken. I thought that perhaps some kind of registration attempt was aborted so that my email is in the db already. So I tried to get a password reset link, and was informed by the process
<goofist>
that *if* my password exists in the database I will be sent an email. This is yet to occur. How can my email both be and not be in the database ?
stux|RC has quit [Quit: Aloha!]
stux|RC has joined #lisp
red-dot has quit [Quit: Going offline, see ya! (www.adiirc.com)]
<pjb>
goofist: you asked publicly. you must have been hacked.
<goofist>
hah
<pjb>
I don't know who manages it. Locate them, and ask them?
igemnace has quit [Ping timeout: 240 seconds]
stux|RC-only has quit [Quit: Aloha!]
stux|RC-only has joined #lisp
<goofist>
arrrg. This is my punishment for not following through with the registration process earlier this year when I was directed to interact with the minion bot back then. I was like: ugg, how convoluted, no thank you. perhaps my registration state is still hanging from back then... sigh...
igemnace has joined #lisp
red-dot has joined #lisp
goofist has quit [Remote host closed the connection]
orivej has joined #lisp
hhdave has quit [Quit: hhdave]
cosimone has joined #lisp
ebrasca has quit [Remote host closed the connection]
cosimone has quit [Quit: Terminated!]
xkapastel has quit [Quit: Connection closed for inactivity]
edgar-rft has quit [Quit: Leaving]
gareppa has quit [Quit: Leaving]
karlosz has joined #lisp
jonatack has joined #lisp
varjag has joined #lisp
Necktwi has joined #lisp
X-Scale has joined #lisp
stepnem has quit [Ping timeout: 240 seconds]
stepnem has joined #lisp
<aeth>
MichaelRaskin: I'm not sure if there is one, but if it was widespread there probably would be one. I don't do much web stuff, though
<aeth>
Kabriel: Ah, okay, I guess there's a high python-to-numpy-to-C/Fortran overhead, then. Not surprising.
<MichaelRaskin>
Well, maths where where just a properly considered alt text is not sufficient gives an upper bound on the spread…
<aeth>
Kabriel: f2cl lapack might "work pretty well", but run disassemble on them in SBCL and they don't come close to stuff written by hand with SBCL's optimizations in mind in terms of quality of generated asm
stepnem has quit [Ping timeout: 245 seconds]
Mandus has quit [Ping timeout: 245 seconds]
<aeth>
MichaelRaskin: technically speaking, every math formula is readable, like (to write some mathematical nonsense) "(a + b) / c = 42 ⇒ ε ∊ (-∞, 7]" is just "a + b over c equals 42 implies epsilon is in the range -∞ to 7 inclusive of 7" or something
slyrus has joined #lisp
<aeth>
Now, whether or not any tool is that smart, idk, but if you provide something like MathML (or LaTeX!) it could in theory be done
<aeth>
s/over c/all over c/
<aeth>
There's a bit of ambiguity that makes this hard to read
fengshaun has quit [Ping timeout: 276 seconds]
scymtym has quit [Ping timeout: 245 seconds]
<MichaelRaskin>
In complicated LaTeX formula structure is sometimes sacrificed for output readability and aesthetics
<aeth>
Yes, which is why MathML would probably be better. Technically it's still "presentation MathML" but it's probably easier to parse
<MichaelRaskin>
Of course, one hopes that the maths you use _in documentation_ should not be _that_ complicated and even LaTeX might be readable
<aeth>
hah
stepnem has joined #lisp
<aeth>
In documentation, you must prove everything that you use
<MichaelRaskin>
Starting from first-order logic and Zermelo-Fraenkel axioms?
EvW has joined #lisp
mrcode_ has joined #lisp
<aeth>
I suppose it's sufficient just to heavily cite the literature for the basics
xuxuru has quit [Quit: xuxuru]
xuxuru has joined #lisp
Necktwi has quit [Quit: leaving]
Mandus has joined #lisp
<aeth>
If there isn't a formal description of Common Lisp, you'd have to write it to cite it, of course.
hiroaki has joined #lisp
gdsg has quit [Ping timeout: 252 seconds]
hiroaki has quit [Ping timeout: 240 seconds]
gdsg has joined #lisp
jmbr has joined #lisp
sjl has quit [Quit: WeeChat 2.2-dev]
edgar-rft has joined #lisp
space_otter has joined #lisp
cosimone has joined #lisp
kajo has quit [Ping timeout: 245 seconds]
gdsg has quit [Quit: Leaving]
gdsg has joined #lisp
cosimone has quit [Quit: Quit.]
scymtym has joined #lisp
gareppa has joined #lisp
fengshaun has joined #lisp
q-u-a-n2 has quit [Read error: Connection reset by peer]
ggole has quit [Quit: Leaving]
amerigo has joined #lisp
gareppa has quit [Quit: Leaving]
stepnem has quit [Ping timeout: 240 seconds]
<LdBeth>
One frequently cited is CLtL2
stepnem has joined #lisp
random-nick has quit [Ping timeout: 276 seconds]
<Bike>
wrong kind of formality
kajo has joined #lisp
kajo has quit [Client Quit]
<aeth>
I'm talking more about the end part of the r7rs pdf (Scheme)
gareppa has quit [Remote host closed the connection]
cosimone has quit [Remote host closed the connection]
Jeanne-Kamikaze has quit [Quit: Leaving]
cosimone has joined #lisp
Oladon has quit [Ping timeout: 268 seconds]
Lycurgus has joined #lisp
Oladon has joined #lisp
EvW has quit [Ping timeout: 250 seconds]
xkapastel has joined #lisp
cosimone has quit [Quit: Quit.]
evelyn has joined #lisp
krid has quit [Remote host closed the connection]
q3d has joined #lisp
cosimone has joined #lisp
saravia has quit [Quit: Leaving]
mathrick has quit [Ping timeout: 264 seconds]
q3d has quit [Remote host closed the connection]
xuxuru has quit [Quit: xuxuru]
saravia has joined #lisp
saravia has quit [Client Quit]
Lycurgus has quit [Quit: Exeunt]
<Tordek>
is there a standard way to have a variable at a particular memory position? e.g., if I were coding for embedded and I needed "char PORTA @ 0x0024;"
<no-defun-allowed>
That's not possible in portable Common Lisp.
<Tordek>
ouch, that's what I get for not reading the channel name!
<no-defun-allowed>
With CFFI, you could probably set up a pointer and use that, however.
<Tordek>
thanks, though :P
<no-defun-allowed>
It'd go like (cffi:mem-ref (cffi:make-pointer #x24) :char)
iovec has quit [Quit: Connection closed for inactivity]
orivej has quit [Ping timeout: 240 seconds]
cosimone has quit [Ping timeout: 245 seconds]
cosimone has joined #lisp
cosimone has quit [Ping timeout: 276 seconds]
arwn has joined #lisp
<arwn>
i'm writing an expert system. currently the function i call to add rules is called with this syntax: `(add-rule (rule-if a and (not b) then c)` rule-if is a macro. how would i change the syntax to drop the parentheses from (not b) and check if there is a not before a or b?