nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
<cgay>
Whitespace works. > or , may or may not work. Hence use whitespace.
<edgar-rft>
that forces me to type blanks after every link, what is idiotic. I'm not responsible to fiy bugs in broken IRC clients
<cgay>
What you say is correct.
warweasle has joined #lisp
zachk has quit [Quit: Leaving]
Kundry_Wag_ has joined #lisp
Kundry_W_ has joined #lisp
nckx has quit [Quit: Updating my GNU GuixSD server — gnu.org/s/guix]
Kundry_Wag_ has quit [Ping timeout: 256 seconds]
<on_ion>
ive been adding spaces after complete URLs for decades. web browsers like to reload from cache if next_url == current_url by string compare so it became habit to get a nice full reload.
ft has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 255 seconds]
ft has joined #lisp
elfmacs has joined #lisp
<edgar-rft>
That's not the point. A comma *can* be part of a valid URL, an angled bracket *never* can be part of an URL. An IRC client that recognizes angled brackets as part of an URL is undoubtfully broken. Don't use shitty software.
* pillton
turns off the computer.
fikka has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
jameser has joined #lisp
Kundry_W_ has quit [Remote host closed the connection]
fikka has joined #lisp
Naergon has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 240 seconds]
<Bike>
does this concern for commas in links mean the topic will be spaced out more
<p_l>
Bike: the topic is stretched thin already, so no
<on_ion>
SBCL is 1.4.7 if we are on the topic of the topic
igemnace has joined #lisp
granttrec1 has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
<on_ion>
or why leave room for something out of date, listing the versions of implementations ? i would myself have more lisp in it like the #1=() part.
eli_oat has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
ZombieChicken has joined #lisp
lnostdal has joined #lisp
Kundry_Wag_ has joined #lisp
markong has quit [Ping timeout: 268 seconds]
TCZ has joined #lisp
eli_oat has quit [Client Quit]
eli_oat has joined #lisp
Kundry_Wag_ has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
Kundry_Wag_ has joined #lisp
innovati has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
on_ion has quit [Read error: No route to host]
TCZ has quit [Quit: Leaving]
on_ion has joined #lisp
Oladon has joined #lisp
TCZ has joined #lisp
<White_Flame>
"#lisp, pedantry with occasional Common Lisp sprinkled in"
emaczen has joined #lisp
fikka has joined #lisp
Pixel_Outlaw has joined #lisp
johnvonneumann has joined #lisp
FreeBirdLjj has joined #lisp
johnvonneumann is now known as Guest93904
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
fikka has quit [Ping timeout: 265 seconds]
pierpa has joined #lisp
nowhere_man has quit [Remote host closed the connection]
nowhere_man has joined #lisp
d4ryus1 has joined #lisp
fikka has joined #lisp
d4ryus has quit [Ping timeout: 260 seconds]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
hjek has left #lisp [#lisp]
FreeBirdLjj has quit [Remote host closed the connection]
nowhere_man has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Tristam has quit [Ping timeout: 240 seconds]
Tristam has joined #lisp
Kundry_Wag_ has quit [Quit: Leaving...]
fikka has quit [Ping timeout: 240 seconds]
megalography has quit [Ping timeout: 255 seconds]
smurfrobot has quit [Remote host closed the connection]
vtomole has joined #lisp
fikka has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
epony has quit [Quit: QUIT]
loli has quit [Quit: WeeChat 2.1]
vhost- has quit [Ping timeout: 260 seconds]
quazimodo has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 260 seconds]
loli has joined #lisp
quazimodo has joined #lisp
vhost- has joined #lisp
fikka has joined #lisp
smurfrobot has joined #lisp
TCZ has quit [Quit: Leaving]
fikka has quit [Ping timeout: 260 seconds]
eli_oat has quit [Quit: Leaving.]
eli_oat has joined #lisp
fikka has joined #lisp
dddddd has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 264 seconds]
eli_oat has quit [Quit: Leaving.]
smurfrobot has quit [Remote host closed the connection]
fikka has joined #lisp
Arcaelyx has joined #lisp
flazh has quit [Ping timeout: 256 seconds]
iqubic has joined #lisp
aindilis has joined #lisp
mejja has quit [Quit: mejja]
hyperreal has joined #lisp
smurfrobot has joined #lisp
hyperreal has left #lisp [#lisp]
smurfrobot has quit [Ping timeout: 264 seconds]
karlosz has quit [Ping timeout: 265 seconds]
ZombieChicken has quit [Ping timeout: 255 seconds]
karlosz has joined #lisp
Oladon has quit [Quit: Leaving.]
fikka has quit [Ping timeout: 240 seconds]
edgar-rft has quit [Quit: edgar-rft]
fikka has joined #lisp
Beepy has quit [Ping timeout: 265 seconds]
Cymew has joined #lisp
varjagg has joined #lisp
Cymew has quit [Ping timeout: 255 seconds]
varjagg has quit [Ping timeout: 248 seconds]
Bike has quit [Quit: Lost terminal]
smurfrobot has joined #lisp
Pixel_Outlaw has quit [Quit: Leaving]
smurfrobot has quit [Ping timeout: 260 seconds]
epony has joined #lisp
schoppenhauer has quit [Ping timeout: 248 seconds]
schoppenhauer has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
tomsen has joined #lisp
fikka has joined #lisp
zooey has quit [Ping timeout: 255 seconds]
zooey has joined #lisp
<emaczen>
What are common causes for the SBCL error: no more immobile pages?
dieggsy has joined #lisp
pierpa has quit [Quit: Page closed]
nckx has joined #lisp
vtomole has quit [Ping timeout: 260 seconds]
<alandipert>
_death thanks for sharing that screencast. epic format string at the end
kajo has quit [Quit: WeeChat 2.1]
Mutex7 has joined #lisp
kajo has joined #lisp
solyd has quit [Remote host closed the connection]
flazh has joined #lisp
kajo has quit [Read error: Connection reset by peer]
milanj has joined #lisp
kajo has joined #lisp
beizhia has joined #lisp
megalography has joined #lisp
kajo has quit [Read error: Connection reset by peer]
kajo has joined #lisp
tomsen has quit [Ping timeout: 256 seconds]
djinni` has quit [Quit: Leaving]
karlosz has quit [Remote host closed the connection]
djinni` has joined #lisp
karlosz has joined #lisp
vlatkoB has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
sauvin has joined #lisp
z3t0 has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
iqubic` has joined #lisp
iqubic` has left #lisp [#lisp]
z3t0 has joined #lisp
iqubic has quit [Ping timeout: 276 seconds]
varjagg has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Satou has joined #lisp
Satou has quit [Client Quit]
varjagg has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
smurfrobot has joined #lisp
oleo has quit [Quit: Leaving]
fikka has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Ping timeout: 268 seconds]
beach has joined #lisp
<beach>
Good morning everyone!
<clintm>
good morning, beach!
<beach>
emaczen: I don't know the answer, but I am guessing the use of FFI.
<clintm>
I've been looking around for options other than using a database (again) for a project, and I'm curious if any of you have suggestions. I've been reading through cl-prevalence and it seems like one reasonable alternative.
<beach>
I have a suggestion. Give me one minute...
dieggsy has quit [Ping timeout: 276 seconds]
<clintm>
There's also lambdalite from mocl as a possible option too.
<clintm>
beach: okie dokie. Gonna walk the dog while you do your thing.
<phoe>
clintm: what do you want to store in your database? you could try a Lisp object store. beach has a very simple and customizable https://github.com/robert-strandh/Clobber while I used BKNR.DATASTORE in the past
fikka has quit [Ping timeout: 260 seconds]
<beach>
clintm: It's Clobber as phoe hinted.
nika_ has joined #lisp
<Ober>
manardb is pretty nice
<Ober>
although with leveldb bindings that should be a choice too
<phoe>
oh, I never used it
<Ober>
leveldb obviously requires the external libs, but manardb does not
<Ober>
except for libposix
<Ober>
osicat rather
fikka has joined #lisp
bbobb has joined #lisp
beach has quit [Read error: Connection reset by peer]
<clintm>
At first glance, it looks like manardb is linux only? At least that's the impression that I get from the project page, and trying to load it in sbcl seems to confirm that.
quazimodo has quit [Ping timeout: 256 seconds]
beach has joined #lisp
varjagg has joined #lisp
quazimodo has joined #lisp
<_death>
alandipert: glad you enjoyed it ;)
<beach>
Ober: In what way manardb and leveldb nice? It is an honest question. I don't know them.
earl-ducaine has quit [Remote host closed the connection]
<clintm>
_death: what did you use to record the video? I enjoyed the screencast as well!
<beach>
Ober: In other words, what is it about those two alternatives that made you recommend them to clintm?
fikka has quit [Ping timeout: 240 seconds]
wigust has joined #lisp
kushal has quit [Remote host closed the connection]
kushal has joined #lisp
varjagg has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
<beach>
Oh, well.
fikka has quit [Ping timeout: 256 seconds]
<clintm>
Thanks for all of the suggestions, everyone. I'm working my way through them now.
fikka has joined #lisp
shrdlu68 has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
MichaelRaskin has quit [Quit: MichaelRaskin]
Cymew has joined #lisp
fikka has joined #lisp
cpape` has joined #lisp
cpape has quit [Read error: Connection reset by peer]
fraya has joined #lisp
pierpal has joined #lisp
Kundry_Wag has quit [Read error: Connection reset by peer]
Kundry_Wag has joined #lisp
python476 has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
Mutex7 has quit [Quit: Leaving]
energizer has quit [Ping timeout: 265 seconds]
RebelCoderRU has joined #lisp
fikka has joined #lisp
<Ober>
beach: manardb is pure cl and it's fast as hell. full clos layer on it. leveldb is just a hotness in k/v stores. and the binding in cl is pretty good
shrdlu68 has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 276 seconds]
pierpal has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
karlosz has quit [Client Quit]
pierpal has quit [Ping timeout: 276 seconds]
mange has quit [Remote host closed the connection]
pierpal has quit [Read error: Connection reset by peer]
pierpal has joined #lisp
shrdlu68 has quit [Quit: Reconnecting]
shrdlu68 has joined #lisp
shrdlu68 has quit [Client Quit]
shrdlu68 has joined #lisp
fikka has joined #lisp
pierpal has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 265 seconds]
shrdlu68 has joined #lisp
nika_ has quit [Quit: Leaving...]
fikka has joined #lisp
smurfrobot has joined #lisp
shrdlu68 has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
Kaz` has joined #lisp
shrdlu68 has quit [Ping timeout: 240 seconds]
shrdlu68 has joined #lisp
fikka has joined #lisp
stardiviner has joined #lisp
shrdlu68 has quit [Remote host closed the connection]
shrdlu68 has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
kajokajo has quit [Read error: Connection reset by peer]
shrdlu68 has quit [Ping timeout: 256 seconds]
shrdlu68 has joined #lisp
fikka has joined #lisp
smurfrobot has joined #lisp
shrdlu68 has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 260 seconds]
shrdlu68 has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
smurfrobot has quit [Ping timeout: 260 seconds]
scymtym has joined #lisp
fikka has joined #lisp
shrdlu68 has quit [Ping timeout: 268 seconds]
shrdlu68 has joined #lisp
RebelCoderRU has quit [Ping timeout: 268 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
light2yellow has joined #lisp
Kazimodo has joined #lisp
schweers has joined #lisp
smurfrobot has joined #lisp
eschatologist has quit [Quit: ZNC 1.6.5+deb2build2 - http://znc.in]
eschatologist has joined #lisp
smurfrobot has quit [Ping timeout: 255 seconds]
<dim>
hi! I think I will need to upload files to Amazon S3 in a streaming fashion (keeping only a chunk of the file content in memory at a time), and I wonder if cl-s3 or sz3 know how to do that... docs aren't that clear... anyone done that before?
<dim>
maybe put-stream from sz3 is what I need
sauvin has quit [Remote host closed the connection]
sauvin has joined #lisp
Naergon has joined #lisp
sauvin has quit [Read error: Connection reset by peer]
sauvin has joined #lisp
sauvin has quit [Remote host closed the connection]
sauvin has joined #lisp
sauvin has quit [Remote host closed the connection]
_cosmonaut_ has joined #lisp
deng_cn1 has joined #lisp
sauvin has joined #lisp
<Ober>
hmm good question
megalography has quit [Ping timeout: 264 seconds]
sauvin has quit [Remote host closed the connection]
orivej has joined #lisp
deng_cn has quit [Ping timeout: 264 seconds]
deng_cn1 is now known as deng_cn
orivej has quit [Ping timeout: 248 seconds]
schjetne has quit [Quit: No Ping reply in 180 seconds.]
<klm2is>
Are these equivalent? `(("name" . ,name) ("and" . "more") and (list (cons "name" name) (cons "and" "more"))
fikka has joined #lisp
<klm2is>
I'm worried the first might not always return a totally new list. Is that possible?
<klm2is>
I missed a paren above...
scymtym has quit [Ping timeout: 255 seconds]
<Bike>
yes, the result of ` shouldn't be modified
<Bike>
which is to say, no, they're not equivalent
<klm2is>
thanks!
Celelibi has joined #lisp
Celelibi has left #lisp ["Flying away like Captain Obvious!"]
fikka has quit [Ping timeout: 264 seconds]
TCZ has quit [Quit: Leaving]
pierpal has joined #lisp
fraya has quit [Remote host closed the connection]
pierpal has quit [Read error: Connection reset by peer]
CrazyEddy has quit [Remote host closed the connection]
<antoszka>
drunk_foxx[m]: Thank you.
igemnace has joined #lisp
CrazyEddy has joined #lisp
fikka has joined #lisp
dyelar has quit [Remote host closed the connection]
stardiviner has quit [Quit: WeeChat 2.1]
smurfrobot has quit [Remote host closed the connection]
<White_Flame>
klm2is: to be more specific, the 2 resulting shapes are structured exactly the same. The `-based one is tied to source code literals, which make them dangerous/unspecified to mutate later
fittestbits has left #lisp [#lisp]
<White_Flame>
even though the first cons in the list is most likely going to be new on each invocation
fikka has quit [Ping timeout: 248 seconds]
rumbler31 has joined #lisp
<klm2is>
thanks.
hjek has joined #lisp
<klm2is>
I had a macro working like (define-my-call url :query ...query alist...)
<klm2is>
well not exactly, I guess it was more complicated than that.
<klm2is>
but the point is, I was using this in two places and seeing some odd cross-contamination in backquoted forms
<klm2is>
I think I have it now though, thank you
smurfrobot has joined #lisp
dieggsy has joined #lisp
smurfrobot has quit [Remote host closed the connection]
papachan has joined #lisp
raynold has quit [Quit: Connection closed for inactivity]
warweasle is now known as warweasle_afk
kmurphy4 has joined #lisp
milanj has quit [Quit: This computer has gone to sleep]
fikka has joined #lisp
DonVlad has quit [Ping timeout: 255 seconds]
Kaz` has quit [Ping timeout: 260 seconds]
quazimodo has quit [Ping timeout: 256 seconds]
milanj has joined #lisp
quazimodo has joined #lisp
smurfrobot has joined #lisp
terpri has joined #lisp
smurfrobot has quit [Remote host closed the connection]
mindCrime has joined #lisp
hjek has quit [Ping timeout: 255 seconds]
matijja has quit [Ping timeout: 268 seconds]
fikka has quit [Ping timeout: 264 seconds]
smurfrobot has joined #lisp
EvW has joined #lisp
random-nick has joined #lisp
smurfrobot has quit [Remote host closed the connection]
pierpal has joined #lisp
mindCrime has quit [Quit: Leaving]
eli_oat has joined #lisp
fikka has joined #lisp
DonVlad has joined #lisp
dyelar has joined #lisp
pfdietz has joined #lisp
mindCrime has joined #lisp
FreeBirdLjj has joined #lisp
svetlyak40wt has joined #lisp
pfdietz has quit [Read error: Connection reset by peer]
argoneus has quit [Quit: No Ping reply in 180 seconds.]
DonVlad has quit [Read error: Connection reset by peer]
<remix2000[m]>
Hello! Is that true that CL code is fully portable across implementations?
<jackdaniel>
if you write a conforming Common Lisp program then yes
<jackdaniel>
if you use implementation-specific extensions - then no
argoneus has joined #lisp
nowhere_man has joined #lisp
<remix2000[m]>
How about C FFI? Is it compatible across major implementations?
<Bike>
it's pretty portable, yeah.
shrdlu68 has left #lisp [#lisp]
fikka has quit [Ping timeout: 240 seconds]
_cosmonaut_ has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
damke has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
terpri has quit [Ping timeout: 260 seconds]
elfmacs has quit [Ping timeout: 256 seconds]
Cymew has quit [Remote host closed the connection]
smurfrobot has joined #lisp
Cymew has joined #lisp
fikka has joined #lisp
jmercouris has joined #lisp
megalography has quit [Ping timeout: 265 seconds]
elfmacs has joined #lisp
<White_Flame>
remix2000[m]: there are a lot of libraries called "trivial-<x>" which are small portability shims for accessing non-standard but common features
Cymew has quit [Ping timeout: 265 seconds]
<White_Flame>
but CL itself is a standard that hasn't changed since its inception, so conformance means strong compatibility within its scope
Cymew has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
Cymew has quit [Remote host closed the connection]
Cymew has joined #lisp
_cosmonaut_ has joined #lisp
<remix2000[m]>
Are C bindings cross-platform?
<White_Flame>
that could be taken multiple ways, but the CFFI library works across implementations
<on_ion>
is there a way to ask a particular CL implementation to check conformity to CL for some code ?
<White_Flame>
when you cross platforms, that all depends on how the C library works per platform, regardless of Lisp
<Bike>
on_ion: compile it
<Bike>
none of them are completely strict, though
<on_ion>
Bike: sbcl will compile with sbcl extensions would it not
<on_ion>
...
<rumbler31>
on_ion: is there some particular feature you're curious about?
<Bike>
including extension code doesn't make it nonconforming
<rumbler31>
the "not that hard to test" case is to simple compile the concerned code on all available implementations
<on_ion>
rumbler31: nope im just following the conversation. "jackdaniel | if you write a conforming Common Lisp program then yes" <-- ok so how does one know if their progrm is comforming to Common Lisp? obvious question no ?
<on_ion>
ok, extension code... sigh
<rumbler31>
I think the word "comforming" is misused here
<White_Flame>
some sort of automated test for conformance would get into halting problem territory
fikka has joined #lisp
<on_ion>
tht would make sense rumb
smurfrobot has quit [Remote host closed the connection]
<rumbler31>
implementations conform to the standard. code is simply compiled by the implementation. If you write code where the standard says "the behavior is undefined" then you should expect different behavior on different implementations
Cymew has quit [Ping timeout: 264 seconds]
<Bike>
probably not halting problem, except for a few such requirements, like that macroexpansion always terminates
<schweers>
on_ion: It is not always straightforward to know if you’re writing strictly conforming code, although with time you can gain some experience. For this reason I run my code on at least one other implementation from time to time (mostly running the test cases). Normally I use sbcl, but use CCL for this reason. This has triggered some bugs in my code and made me more aware of what can be non-portable.
elfmacs has quit [Ping timeout: 255 seconds]
<rumbler31>
I think a better way to phrase the discussion is "how to know how portable your code is across implementations"
Cymew has joined #lisp
<White_Flame>
Bike: the territory includes "figure out what the range of dynamic behavior is, by looking at the code". Same thing for C, try to write a program to scan code to see if it invokes undefined behavior
<White_Flame>
(joke answer: always return true)
<emaczen>
phoe: I just saw your response
<on_ion>
"different behavior on different implementations" that already sounds like dangerous territory.
<rumbler31>
obviously, impl specific extensions aren't, and relying on undefined behavior also is a likely source of inspection
<emaczen>
I'm not using any FFI at the moment...
<sjl>
I do something similar to schweers -- develop primarily in SBCL but run my test suites in sbcl+ccl+ecl+abcl
<on_ion>
schweers: ah i see, ive seen others do that as well, that seems practical
<jackdaniel>
Bike: I think that clisp has a mode enforcing strict ANSI, but I may be wrong
<rumbler31>
on_ion: yes dangerous territory I suppose
warweasle_afk is now known as warweasle
<emaczen>
are immobile pages, like pages in RAM?
<Bike>
jackdaniel: i think that's more of a "turn off nonconformant behavior we have by default" flag
fikka has quit [Ping timeout: 265 seconds]
<schweers>
on_ion: one example I ran into the other day: I use a third party library which exposes some classes. The slots of the objects of these classes are filled by reading input files. One of the fields I frequently access in a random order is a list. I replaced it with a simple-array and it was fine. Until I ran the tests on CCL. Turns out, the slot had a type specifier of LIST, and CCL checks for that.
megalography has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
MasouDa_ has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
svetlyak40wt has quit [Remote host closed the connection]
damke_ has joined #lisp
fikka has joined #lisp
nickenchuggets has joined #lisp
dyelar has quit [Remote host closed the connection]
MasouDa_ has quit [Quit: No Ping reply in 180 seconds.]
fikka has quit [Ping timeout: 248 seconds]
damke has joined #lisp
smurfrobot has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
damke_ has quit [Ping timeout: 268 seconds]
Cymew has joined #lisp
jfrancis has joined #lisp
FreeBirdLjj has joined #lisp
<jfrancis>
I have a bunch of code that reads and processes files produced by a third party (the FAA, specifically). About a week ago, they started adding a BOM (unicode byte order mark, 0xef 0xbb 0xbf) to the front of every file. I'm pulling my hair out, tried everything I can possibly think of to skip past those first three bytes and read the rest of the file (which is just plain old ASCII). No luck. Anyone dealt with this? Any thoughts? 64-bit SBCL 1.4.5.38-9ee5e08
Cymew has quit [Ping timeout: 264 seconds]
innovati has joined #lisp
<Bike>
if it's ascii can't you just read it as unicode?
Cymew has joined #lisp
sjl has quit [Ping timeout: 255 seconds]
<jfrancis>
Perhaps, but if I can, I haven't figured out how. Adding ":foreign-encoding :utf-8" to with-open-file didn't hack it. Although at least the errors changed.
sjl has joined #lisp
nowhere_man has quit [Ping timeout: 256 seconds]
sjl__ has joined #lisp
kmurphy4 has quit [Quit: kmurphy4]
Cymew has quit [Ping timeout: 256 seconds]
<Xach>
jfrancis: latin-1/iso8859-1 is one option that springs to mind
sjl has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
smurfrobot has quit [Remote host closed the connection]
smurfrobot has joined #lisp
m00natic has quit [Remote host closed the connection]
<jfrancis>
Oops, obviously, I mean :external-format, not :foreign-encoding. Confusing my languages. Using either :latin-1 or :iso8859-1 gives me the error "The bounding indices 40 and 45 are bad for a sequence of length 42."
fikka has quit [Ping timeout: 240 seconds]
<jfrancis>
I could strip the first three characters from each file as a pre-processing step before I feed them to my code, but that's precisely what I'm trying to avoid.
<jfrancis>
first three bytes, rather
Cymew has joined #lisp
<jfrancis>
Or I could send a letter to the FAA and ask them to go back to publishing the files the way they've been doing it for ten years up until this Monday. But I doubt that will get much traction.
<on_ion>
index of 40 bad for sequence of 42? hmmm
<on_ion>
length+
jmercouris has quit [Remote host closed the connection]
jeosol has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 256 seconds]
Ven`` has joined #lisp
fikka has joined #lisp
Ven`` has quit [Client Quit]
sjl__ is now known as sjl
tomsen has joined #lisp
Cymew has joined #lisp
energizer has joined #lisp
kajo has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 264 seconds]
kajo has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
smurfrobot has quit [Remote host closed the connection]
fikka has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
MasouDa has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
terpri has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
MasouDa has quit [Ping timeout: 256 seconds]
_cosmonaut_ has quit [Ping timeout: 265 seconds]
<_death>
jfrancis: what happens if you just (read-char stream) after opening the file to skip the BOM
Cymew has joined #lisp
fikka has joined #lisp
surya has joined #lisp
SenasOzys has joined #lisp
python476 has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 248 seconds]
fikka has quit [Ping timeout: 240 seconds]
<jfrancis>
I get "the octet sequence #(239) cannot be decoded."
damke has quit [Ping timeout: 268 seconds]
Cymew has joined #lisp
<_death>
hmm, seems to work here with "latest" sbcl and default external format etc.
pjb has joined #lisp
<_death>
you can also try a bivalent stream and read the first 3 octets..
surya has quit [Remote host closed the connection]
michel_ has joined #lisp
Cymew has joined #lisp
<_death>
and the sbcl manual mentions a :replacement option that can be supplied to external-format, so that may also work
fikka has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
<jfrancis>
Sigh. It just seems horribly broken that I can't read a fairly common (though horribly broken) file format without ridiculous gyrations. Sticking a Byte-Order-Marker on the front of a file, despite the inherent evil of it, is common.
<_death>
well, sbcl TODO specifically mentions it..
<ZombieChicken>
jfrancis: If it breaks a standard or you can explain how it's broken, then maybe the email makes more sense. Perhaps whoever made that change was just ignorant
<_death>
though it seems like a place to stick things that won't ever get done ;)
fikka has joined #lisp
<jfrancis>
ZombieChicken: Here's the problem boiled down to it's essence: How can I read an ASCII file in a portable way in CL that has a BOM on the front of it. Assuming, of course, that I can't mercilessly flog the person who put the BOM there in the first place.
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
<ZombieChicken>
jfrancis: I'm aware. I'm also not well acquanted with CL, so I can't offer any real help
<_death>
if it has a BOM, it's not ASCII.. and if you want to do it portably, you need to use a binary stream and do the decoding yourself
fikka has quit [Ping timeout: 256 seconds]
<ZombieChicken>
But if that appended data is nonstandard, an email and a prayer you get to someone who isn't stupid would be the best option; working around and excepting a broken file format doesn't help anyone
<ZombieChicken>
s/appended/prepended
<ZombieChicken>
grr
<ZombieChicken>
s/exepting/accepting
<ZombieChicken>
need more coffee
pfdietz has joined #lisp
<ZombieChicken>
_death: Possible to grab a binary stream, read a few bytes, then convert the rest to an ASCII stream?
<jfrancis>
ZombieChicken: You're not seriously thinking an email to a US Gov't Federal Agency will get them to change a file format, are you? :D
<pfdietz>
Does sbcl provide restarts for that reader error? Maybe ask for one that would help here.
Cymew has quit [Ping timeout: 248 seconds]
<ZombieChicken>
jfrancis: No, I don't expect it to do anything useful unless you're bribing people, but you might get lucky
<jfrancis>
Yeah, that's what I've resorted to. Opening the file as binary, discarding the first three bytes, then reading in the rest and converting it back to a string. It's unspeakably inefficient. Then again, it only ever has to be done once per file.
edgar-rft has joined #lisp
mflem has joined #lisp
<_death>
ZombieChicken: yes, you can do precisely that with a bivalent stream.. in sbcl you can open a bivalent stream by providing :element-type :default
fikka has joined #lisp
<jfrancis>
So I can open a stream, do three (read-byte ), then read the rest as strings? If so, is that portable, or is that an SBCL-ism?
Trystam has joined #lisp
FreeBirdLjj has quit [Remote host closed the connection]
<_death>
jfrancis: it's sbcl-specific.. there are portable libraries like flexi-streams
Tristam has quit [Ping timeout: 240 seconds]
Trystam is now known as Tristam
karlosz has joined #lisp
<jfrancis>
Hmm. Ok. I just got my other code working (that reads it as binary, then converts the byte vector to ASCII). But that code is so embarrassingly bad, I'll go look at flexi-streams. Thanks!
fikka has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
cage__ has joined #lisp
cage_ has quit [Read error: Connection reset by peer]
Cymew has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Cymew has joined #lisp
<jfrancis>
Heh, it runs out of heap when loading the 182meg input file. Guess I need to go figure out the "right" way.
DemolitionMan has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 256 seconds]
Naergon has quit [Ping timeout: 264 seconds]
tomsen has quit [Ping timeout: 240 seconds]
Cymew has joined #lisp
Bike_ has joined #lisp
shka_ has joined #lisp
SenasOzys has quit [Ping timeout: 248 seconds]
fikka has joined #lisp
Bike has quit [Ping timeout: 260 seconds]
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<pierpal>
182MB is very little data, my toaster has more than that ram. How are you reading those files?
SenasOzys has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
pierpal has quit [Quit: Poof]
pierpal has joined #lisp
<edgar-rft>
let's toast our bread with overheated RAM
<antoszka>
I think UIOP has some useful SLURP-STREAM implementation these days.
<makomo>
tbh i can't really say i'm satisfied with his explanations :^(
<aeth>
Having spent a *LOT* of time with Common Lisp, there's nothing magical or special about it.
<aeth>
What it has is the lack of a misfeature that virtually every other programming language has: elaborate syntax.
<makomo>
well the key point is your *LOT* :-)
orivej has joined #lisp
<makomo>
if everyone else did the same, people wouldn't be so "confused" about lisp
<makomo>
in the second part, i think robert mentioned EVAL way too many times, and gave everyone the impression that somehow it's about EVAL
<makomo>
so people are saying things like "so what? lots of languages have EVAL"
rippa has quit [Quit: {#`%${%&`+'${`%&NO CARRIER]
fikka has quit [Ping timeout: 248 seconds]
<aeth>
There are three advantages to the simple syntax. Lisp gives your source code a level of polish you literally cannot get anywhere else (okay, there's probably a few other places) without writing your own programming language. And doing things at compile time is just about as easy as doing things at runtime, which is rare. (Similar levels of polish to point #1 are probably at a runtime cost, not at compile time.)
<aeth>
And you don't have to revise its standard every 4 years to give something new a convenient form in your language's syntax.
<aeth>
(Even CLOS could have been optional.)
<phoe>
emaczen: oh, okay
pierpal has joined #lisp
<aeth>
I don't think Lisp popularizers generally hit on my points because... they're not magical.
<makomo>
aeth: well i agree, but that sort of thing comes after a certain amount of time/experience, and i don't think it applies just to lisp
smurfrobot has joined #lisp
ZombieChicken has quit [Quit: Have a nice day]
klm2is has quit [Quit: Leaving]
rumbler31 has quit [Remote host closed the connection]
<pjb>
makomo: with sexps, code injection are not possible. with text, they're common occurences.
<makomo>
aeth: in general i think experienced people tend to forget the little things that bothered them when they were just starting out
vlatkoB has quit [Remote host closed the connection]
<makomo>
and then instead of emphasising certain stuff (that they found confusing early on), they just gloss over it or assume it should be clear to everyone
<pjb>
makomo: lisp invented in 1959, would prevent thousands of students getting PhDs, tens or hundreds of thousands of companies having contracts to "prevent" or correct the problem, that wouldn't exist in the first place.
<makomo>
pjb: i've already been sold on lisp :-). i'm mainly referring to the comments on the video
<emaczen>
will anyone inform me about SBCLs "immobile pages"?
<pjb>
makomo: it's the same thing with OSes. Without unix and C, (ie. if you used controlled execution programming languages such as lisp (without FFI), and capability-based OSes, you wouldn't have jobs for millions of programmers and computer security engineers.
<emaczen>
or point me somewhere? There isn't anything in the SBCL manual that I have
jeosol has quit [Ping timeout: 260 seconds]
smurfrobot has quit [Ping timeout: 260 seconds]
<pjb>
makomo: basically, you'd halfe the computing GDP, and you'd have to make all those people work on solar system and galaxy colonization instead…
<makomo>
pjb: sometimes i wonder where would lisp be today if all of the effort that went into other languages went into *just* lisp
dieggsy has quit [Ping timeout: 255 seconds]
<pjb>
makomo: that's the less. wonder where would humanity be!
<ZombieChicken>
pjb: or they would be working on more useful and interesting problems than trying to (re)fix problems
<makomo>
haha :-)
<aeth>
makomo: Imo, Lisp was hard for me to learn initially because all of the material was treating it as this special magical thing (which is probably more accurate for Haskell than for Lisp). I picked it up at a much more rapid pace once I realized it was basically like any other language, with some key style differences, like relying on return values from everything being an expression rather than on setting variables. (e.g. use a cond to retu
<makomo>
perhaps it was a necessary evil :D
<aeth>
(e.g. use a cond to return one of several possible values, not an if/then/else block to set a variable)
<makomo>
aeth: mhm. i feel like that's a pretty common thing. reminds me of monads and burritos a little bit :-)
matijja has quit [Remote host closed the connection]
<makomo>
assuming a compiling lisp implementation (is it even possible for a cl implementation to not be compiling, since stuff like COMPILE and COMPILE-FILE are required?), what is the difference between lisp's "on the fly" compilation and JIT compilation?
<makomo>
is JIT just a subset of "on the fly" compilation? i.e. the moment when the code is compiled is (drum roll) just before running the code? while in lisp i can compile whenever i want?
<White_Flame>
JIT recompiles after first run
<White_Flame>
lisp is technically ahead-of-time compilation
<White_Flame>
the machine code is generated when the source code is introduced to the system
<White_Flame>
(in most circumstances; having a separate COMPILE call might do different things, but in practice, defining the function puts it in its final state that the implementation supports)
<makomo>
you say "recompiles", probably because you're assuming something like bytecode or?
<White_Flame>
most JIT systems look at collected heuristics durign runtime, then recompiles that same original source with different optimization assumptions
<White_Flame>
like which type is most often seen, etc
<White_Flame>
so it can generate native machine code multiple times for the same source code, as it learns more
<White_Flame>
deciding which calls to inline is also a decision that can be made after first run, depending on the sorts of call overhead it's measured
<makomo>
i see, but none of that is inherent to "*just* in time" compilation right? i.e. couldn't you do the same thing with ahead-of-time compilation?
python476 has quit [Ping timeout: 240 seconds]
<makomo>
i mean, you learn something about the code, and then recompile parts of the code, but not *just* in time, rather *ahead* of time, just to be run later
<White_Flame>
right, the term has drifted in meaning from the literal wording
<makomo>
yeah, that's what bothers me
<makomo>
so let's say you're not defining a function but evaluating a form like (+ 1 2) at a lisp REPL
<White_Flame>
"just in time" can also imply the time that it's needed to be faster, as you notice where the timne is being spent
<makomo>
doesn't that technically do *just* in time compilation (and evaluation)?
<makomo>
because it compiles it and evaluates it right away?
<White_Flame>
yep
<makomo>
so then really the key point about lisp's compiler is its availability at runtime and the interface for the user
<White_Flame>
right. But each individual function is only usually compiled once
<makomo>
i.e. it's not part of some runtime system you can't touch/see, but you can actually invoke it yourself, as the user
<makomo>
mhm
<White_Flame>
so if you have something declared inline, or redefine a macro, those effects won't get recompiled into prior-compiled functions
<makomo>
yup
zooey has quit [Remote host closed the connection]
zooey has joined #lisp
<makomo>
would you know how usual lisp compiling implementations work? i mean i get that generating machine code and executing it at run-time is not really any different than producing an executable and then executing that (ala C/C++/etc., but still)
scottj has left #lisp [#lisp]
<makomo>
so when something gets compiled, the machine code gets placed somewhere in memory and the control is transfered to that machine code whenever the function is invoked for example?
<makomo>
something like that?
Bike has joined #lisp
<White_Flame>
yep. Function objects are created which contain a block of machine code
<makomo>
so the machine code is sort of spread around in memory?
<White_Flame>
and those objects can be garbage collected
kmurphy4_ has joined #lisp
<makomo>
it's not the classical "here's a bunch of machine code in an executable"
<makomo>
like an .exe file with all of its code sections and the like
xaxaac has joined #lisp
<makomo>
that's pretty cool, because that sort of "runtime code generation" is something you get to see while reverse engineering malware or self-modifying code, etc.
wigust has quit [Ping timeout: 256 seconds]
Khisanth has quit [Ping timeout: 264 seconds]
random-nick has quit [Ping timeout: 268 seconds]
trocado has joined #lisp
DemolitionMan has joined #lisp
asarch has quit [Quit: Leaving]
kmurphy4_ has quit [Quit: kmurphy4_]
sz0 has joined #lisp
FreeBirdLjj has joined #lisp
Khisanth has joined #lisp
FreeBirdLjj has quit [Ping timeout: 248 seconds]
Pixel_Outlaw has joined #lisp
<aeth>
I think that AOT Lisps have everything you need to make a JIT language within one
<aeth>
e.g. if a type is observed through some runtime to be common you could replace some running-in-Lisp language's function with a function that has a typecasw where the first argument is a faster function written for that type
<aeth>
s/first argument/first case/
trocado has quit [Ping timeout: 248 seconds]
<stylewarning>
Here was round 2 of Computerphile and Lisp. Pardon the few gaffes you Lisp experts! https://youtu.be/dw-y3vNDRWk
<stylewarning>
Oh I see it was already discussed. :)
<stylewarning>
makomo: thanks for the feedback. I think you raise a lot of great points. It seems people got stuck on EVAL, which is a necessary component of the process, but maybe should have been buried a bit deeper. But if I said “macro”, people would likewise get up in arms.
<makomo>
stylewarning: oh wow, hi! :-)
<makomo>
i wasn't aware you went under this name, cool to know :)
<stylewarning>
In the numerous times I’ve tried to explain these concepts to people in less than 10 minutes, I’ve come to the conclusion that either the concept is somewhat intrinsically difficult to install in your brain, or I’m not a very good teacher. :)
<makomo>
yeah, i think a lot of people failed to see past the "woooow, what's so great about EVAL"
<rme>
It takes a lot of courage to agree to be in a video like that.
<rme>
So, nice job, stylewarning/
<makomo>
indeed :-)
<stylewarning>
The prompt was: “explain something well enough so a videographer could learn at least one new thing” :)
beizhia has joined #lisp
<makomo>
the comments on the first video aren't too promising either
<makomo>
most of them are "all we hear is how good lisp is, where are the examples"
<makomo>
but most didn't realize there was a second video coming up
karlosz has quit [Quit: karlosz]
<makomo>
one of the comments brought up something like "how is this different from C's (or C#'s, i'm not sure?) #define", which is an okay question imo
<stylewarning>
The first take of both videos was a bottom up description of the syntax of an S-expression followed by the semantics of EVAL, a la Allen
<stylewarning>
That was way, way too much.
<makomo>
(yeah, it was C. i somehow duplicated and merged the # with C and got C#)
<makomo>
stylewarning: a quick question, is your old blog done for good? i.e. the only way to access is through archive.org?
scymtym has quit [Ping timeout: 255 seconds]
<stylewarning>
It’s done for good. It’s been on the back burner to get that content back up on stylewarning, but the db was hosed, so I have to copy manually
xaxaac has quit [Quit: Leaving]
<aeth>
The for loop example is a good one
Khisanth has quit [Ping timeout: 256 seconds]
LiamH has quit [Quit: Leaving.]
<stylewarning>
aeth: but it’s considered contrived to many because everybody already knows what a for-loop is (:
<aeth>
But I think many programmers can read between the lines and think about what loop construct they'd like to write as a macro.
<stylewarning>
I hope so.
<aeth>
e.g. It'd be trivial to write a foreach on top of map nil or loop, even though CL doesn't actually have one.
<makomo>
stylewarning: yeah, that's what i read out of the comments too. people are so accustomed to for loops that they take them for granted, but i do hope they could see the point
<makomo>
an example i really liked was about sorting networks in Let Over Lambda
schoppenhauer has quit [Ping timeout: 268 seconds]
<aeth>
e.g. (foreach (foo foos) (whatever foo)) could just be macroexpanded into (map nil (lambda (foo) (whatever foo)) foos)
<aeth>
(loop doesn't quite do the same thing as that map nil, at least portably.)
<stylewarning>
I also thought about showing a truth table macro
<stylewarning>
That generates an optimal Boolean function
<aeth>
I think that's the problem with a video format like that.
<aeth>
A tutorial (video or otherwise) could go into more practical examples and build up
schoppenhauer has joined #lisp
<aeth>
for (ending with oh, hey, it's in the language as dotimes) -> foreach (trivial on top of map nil) -> something more elaborate, maybe
<aeth>
stylewarning: Were you interviewed for that channel or is that your channel?
<stylewarning>
Interviewed while I was in England to do a whole different thing (explain how to program a quantum computer)
<aeth>
ah
<stylewarning>
It was just happenstance and on-the-spot
<stylewarning>
The lack of prep shows :)
<aeth>
Well, you could always start a YouTube channel (if you don't already have one) and take advantage of the YouTube related algorithm that would hopefully pick up a more in depth (20-30 minute?) video
<aeth>
And, yes, I did notice lots of little nitpicky things that would be rude to pick. :-p
tomsen has joined #lisp
<aeth>
(And in case anyone didn't pick it up, the difference between a foreach implemented via map nil and a foreach implemented via a portable usage of loop is that map nil is generic to all sequences, and the loop-based foreach would have to choose between lists or vectors.)
Khisanth has joined #lisp
markong has quit [Ping timeout: 240 seconds]
varjagg has quit [Read error: Connection reset by peer]