kdridi has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
lnostdal has quit [Ping timeout: 255 seconds]
zaquest has quit [Quit: Leaving]
dtornabene has quit [Quit: Leaving]
zaquest has joined #lisp
Cymew has joined #lisp
rumbler31 has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
Cymew has joined #lisp
lnostdal has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
pjb has joined #lisp
pjb is now known as Guest10414
Cymew has quit [Ping timeout: 276 seconds]
Cymew has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
Denommus has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
fisxoj has joined #lisp
Cymew has joined #lisp
fikka has joined #lisp
smurfrobot has joined #lisp
smasta has joined #lisp
markong has quit [Ping timeout: 276 seconds]
Cymew has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
smurfrobot has quit [Ping timeout: 264 seconds]
kundry_wag has joined #lisp
Cymew has quit [Ping timeout: 265 seconds]
fikka has joined #lisp
Cymew has joined #lisp
kundry_wag has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 248 seconds]
PuercoPope has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
kobain has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
thallia has quit [Ping timeout: 240 seconds]
parjanya has joined #lisp
Cymew has joined #lisp
lima4_ has joined #lisp
pfdietz has quit []
pfdietz has joined #lisp
thallia has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
Guest10414 is now known as pjb
kundry_wag has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
fikka has joined #lisp
kundry_wag has quit [Ping timeout: 240 seconds]
Cymew has quit [Ping timeout: 240 seconds]
rumbler31 has joined #lisp
Cymew has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
EvW1 has quit [Ping timeout: 265 seconds]
Pixel_Outlaw has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
fikka has joined #lisp
Cymew has joined #lisp
damke_ has quit [Ping timeout: 264 seconds]
minion has joined #lisp
Cymew has quit [Ping timeout: 252 seconds]
fikka has quit [Ping timeout: 248 seconds]
rgrau has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
MetaYan has quit [Ping timeout: 240 seconds]
rgrau has joined #lisp
damke_ has joined #lisp
fikka has joined #lisp
Cymew has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
fisxoj has quit [Quit: fisxoj]
MetaYan has joined #lisp
fikka has quit [Ping timeout: 264 seconds]
<Xach>
The gang of 5 emails are so direct and harsh sometimes.
Cymew has quit [Ping timeout: 240 seconds]
thallia has quit [Ping timeout: 240 seconds]
thallia has joined #lisp
fikka has joined #lisp
<stacksmith>
Xach: which gang are you referring to?
<Xach>
stacksmith: the gang who started standardizing CL
Cymew has joined #lisp
<stacksmith>
Ah. That makes more sense than 'Gang of Five: Leaders at the Center of the Conservative Crusade'
fikka has quit [Ping timeout: 240 seconds]
<Xach>
yeah. they were on what was thought to be a private list so they were candid about assessing peers.
<Xach>
but the mailing list is out there now. there are a lot of interesting threads to pull on.
<Xach>
just made me google bbn's Common Lisp implemented in their Scheme.
kundry_wag has joined #lisp
<rme>
My rule is to assume that any mail I send will be public sooner or later.
<rme>
That rule has already paid off more than once.
Cymew has quit [Ping timeout: 240 seconds]
<stacksmith>
My rule is to assume anything written or spoken or otherwise leaked outside of my brain can and will be used against me.
<Xach>
That lesson was drilled into me in jwz's history of the bad-attitude list at netscape
thallia has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
fikka has joined #lisp
<stacksmith>
I am constantly amused by the youngins' inexplicable desire to post frighteningly stupid stuff online.
<aeth>
Just ban social media for people under the age of 25.
<stacksmith>
I suppose there is the presumption that the old fart at HR is too old to know how go google.
kundry_wag has quit [Ping timeout: 276 seconds]
<aeth>
stacksmith: The problem is that the person in HR is probably 28
<stacksmith>
exactly.
<stacksmith>
Not that old farts don't know how to google.
Cymew has quit [Ping timeout: 260 seconds]
fikka has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
igemnace has joined #lisp
<stacksmith>
And of course, HR is the least dangerous adversary capable of at the very least googling.
<aeth>
I don't think anyone under 30 is going to be able to go into politics.
<aeth>
Everyone is an idiot as a teenager, it's just that now it's saved forever on the Internet.
<stacksmith>
Definitely no one with an XY chromosome.
python476 has quit [Ping timeout: 248 seconds]
Cymew has quit [Ping timeout: 260 seconds]
vtomole has joined #lisp
fikka has joined #lisp
<jasom>
Xach: was KMP in the gang of 5? He was pretty direct in the few c.l.l threads I remember reading from him.
Cymew has joined #lisp
mlf has joined #lisp
fikka has quit [Ping timeout: 256 seconds]
orivej has joined #lisp
Cymew has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
fisxoj has joined #lisp
fikka has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
<pierpa>
KMP edited the standard, he came much later
fikka has quit [Ping timeout: 248 seconds]
damke_ has quit [Ping timeout: 264 seconds]
Cymew has quit [Ping timeout: 255 seconds]
z3t0 has joined #lisp
Cymew has joined #lisp
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
pagnol has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
z3t0 has quit [Ping timeout: 260 seconds]
Cymew has joined #lisp
<pjb>
Once you record the history of everybody, nobody will be able to do anything anymore. This is what I like in cristal buildings. Eventually, society has either to put back privacy, allowing everybody to be as evil as they wish, or keep the transparency, and admitting people with their benign faults.
safe has joined #lisp
<pjb>
And democratie is based on free speach, so you should be able to take any speach. You can always go away if you don't want to see or hear.
<pjb>
Of course, mid-term this may very well not matter at all, assuming some kind of hard singularity…
Cymew has quit [Ping timeout: 256 seconds]
<pjb>
If you're american and smart, go work for Space X!
fikka has joined #lisp
d4ryus2 has joined #lisp
smurfrobot has quit [Remote host closed the connection]
d4ryus1 has quit [Ping timeout: 240 seconds]
<aeth>
pjb: bad idea, SpaceX probably uses C++
fikka has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
<aeth>
The world needs more people writing CL professionally.
<pjb>
Only way: start up a company and hire CL programmers.
fart has joined #lisp
Cymew has joined #lisp
fart has quit [Client Quit]
<aeth>
pjb: A "startup" implies that there will be a liquidity event at some point. This event is less and less likely to be an IPO.
<aeth>
There aren't really any CL companies that are large enough for a successful exit, either.
fikka has joined #lisp
<pjb>
aeth: that depends on the size of the company. Basically as founder, you get to decide on the trajectory.
Cymew has quit [Ping timeout: 256 seconds]
<aeth>
Founders only have control until they decide to sell shares to investors.
igemnace has quit [Ping timeout: 256 seconds]
<pjb>
Yes, but they decide.
Cymew has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<Zhivago>
The only way for a CL start-up to succeed is for CL not to matter to the start-up.
lnostdal has quit [Ping timeout: 255 seconds]
<Zhivago>
That is, the decision to use CL should be purely expedient.
<pjb>
Of course.
<Zhivago>
Otherwise all of the network effects are entirely stacked against you.
smurfrobot has quit [Remote host closed the connection]
<Zhivago>
It's increasingly unclear what actual advantages really remain to CL.
<aeth>
Zhivago: The only thing advertising that you use Lisp gets you is the front page of HN
<Zhivago>
Macros, multiple-dispatch, and conditions, perhaps.
<aeth>
Zhivago: The advantage of CL is imo the performance of SBCL.
<aeth>
The languages faster than CL tend to be very, very different from CL (C, C++, Rust, Fortran, etc.)
Cymew has quit [Ping timeout: 268 seconds]
<Zhivago>
SBCL performance isn't that great -- last I looked I don't remember it doing significantly better than v8 javascript.
<aeth>
It depends on what you're doing.
<aeth>
JITs are great for magic.
Cymew has joined #lisp
<aeth>
JITs are great for having the easiest to read source code in carefully crafted microbenchmarks... but those benchmarks probably fall apart if you change even small details in the source
fikka has joined #lisp
<Zhivago>
JITs are generally not great for microbenchmarks since they usually need do to profiling on the fly.
<aeth>
I've seen some LuaJIT microbenchmarks, and the source examples are very elegant, but that doesn't change the fact that Lua is a language where everything's a giant hash table unless the JIT decides it's safe to ignore that.
<Zhivago>
But sure -- benchmarks are tricky to make meaningful.
<Zhivago>
Yeah, but I'm talking about V8 which is compiling to native code on the fly.
<aeth>
If a CL implementation even had 10% of the resources pouring into JS, it would be much easier to optimize.
<aeth>
JS is not an easy language to make fast, it's just that it has a ton of money behind it.
Cymew has quit [Ping timeout: 256 seconds]
<Zhivago>
Until we get to typescript, I would agree.
<Zhivago>
At which point the differences pretty much seem to disappear again.
<Zhivago>
So, my conclusion is that macros are really the only interesting feature CL has left.
fikka has quit [Ping timeout: 264 seconds]
Cymew has joined #lisp
<aeth>
Most comparable languages to CL are using JITs to be fast. Even Racket, afaik, is moving to a JIT.
<Zhivago>
Sure, JIT even makes sense for C.
<aeth>
With the right GC, an AOT-compiled CL could get *predictable* performance. There's probably a niche for that.
igemnace has joined #lisp
<Zhivago>
Except rather than JIT, you should be thinking of it as dynamic profile driven optimization.
smurfrobot has joined #lisp
<Zhivago>
Being AOT means that you're not optimizing for the actual workload.
<Zhivago>
But dynamic profile based optimization isn't quite JIT either.
<Zhivago>
There's a broad space between AOT and JIT.
<Zhivago>
Just as you can get improved cache performance by judicious use of bytecode interpreters.
<aeth>
Zhivago: I think the feature of CL that works well is its development environment. Emacs + SLIME is basically half-Lisp Machine knockoff and half Smalltalk knockoff, but it still beats most languages.
Cymew has quit [Ping timeout: 260 seconds]
<aeth>
A lot of people do really hacky things in their languages to try to get similar live coding experiences.
<aeth>
What CL needs, though, is a modern written-in-CL IDE.
Cymew has joined #lisp
smurfrobot has quit [Remote host closed the connection]
<Zhivago>
That's a fair argument. Although the incremental destructve modification of the environment makes that a bit risky.
<Zhivago>
I'm also trying to think of what language level features are important for that.
<aeth>
Zhivago: Well, I think the only safe way to do a CL IDE would be to essentially run two CLs, and keep the inferior-lisp thing going like in the current Emacs+SLIME methodology
<aeth>
The only alternative I know of is to delay the IDE project 5+ years while writing a new CL implementation, etc.
<Zhivago>
Well, it's not like the inferior-lisp is safe, but as long as you have good persistence at the file level, it probably doesn't matter if you also break the IDE.
Cymew has quit [Ping timeout: 260 seconds]
<aeth>
It's not like Emacs is particularly reliable.
<aeth>
Personally, I 'garbage collect' my Emacs by closing it regularly, and starting a fresh Emacs. People who leave it running for long periods of time tend to see the memory really climb iirc.
<Zhivago>
What I've observed for myself is that I don't really care about live coding or the repl any more, since the machines are so fast today that I can just run a new instance through dynamically from scratch.
Cymew has joined #lisp
<aeth>
Zhivago: You should look at some of the CEPL videos for some modern live coding. It's always more interesting when graphical.
<pjb>
aeth: nope, I've got a (uptime)"Up 0d 19h 40m 37s (Mon 2018-02-12 08:37:50), 72 buffers, 19 files" and only 5671080 KB of VSZ.
<pjb>
milanj has quit [Quit: This computer has gone to sleep]
Cymew has quit [Ping timeout: 260 seconds]
<Zhivago>
I expect it is purely related to the rise of the smartphone.
smurfrobot has joined #lisp
arescorpio has quit [Excess Flood]
Cymew has joined #lisp
<pjb>
Zhivago: incremental destruction of the environment doesn't seem to be much of a problem with emacs, Smalltalk and even long-running lisp images in slime…
<pjb>
It can occur, but rarely. And since we're file-based anyways…
smurfrobot has quit [Ping timeout: 265 seconds]
Cymew has quit [Ping timeout: 248 seconds]
<Zhivago>
Well, you get method, function and variable accumulation and struct redefinition. It's always a bit annoying when stuff stops working after a fresh restart -- but with discipline, I'm sure it can be mostly avoided.
fikka has joined #lisp
Cymew has joined #lisp
smasta has quit [Ping timeout: 264 seconds]
<aeth>
Structs, inline functions, and macros are the problem points afaik. Sometimes packages, too.
fikka has quit [Ping timeout: 248 seconds]
<aeth>
You could afaik fix the first three with a system that tracks users of the struct/inline function/macro and recompiles those with your C-c C-c in addition to the thing itself
Cymew has quit [Ping timeout: 256 seconds]
<aeth>
I'm not sure how you'd be able to get around the "warning: FOO also exports the following symbols:" thing in SBCL if you remove an exported symbol. (I don't think it used to be a warning, though? I think it used to be an error.)
dieggsy has quit [Quit: ERC (IRC client for Emacs 27.0.50)]
<aeth>
But what I personally do is M-x s-r-i-l frequently to make sure that everything still works.
Cymew has joined #lisp
<aeth>
Loading with :verbose t is a must, too.
smurfrobot has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
Cymew has quit [Ping timeout: 268 seconds]
Cymew has joined #lisp
fikka has joined #lisp
<stacksmith>
aeth: what does M-x s-r-i-l do?
dddddd has quit [Remote host closed the connection]
<aeth>
slime-restart-inferior-lisp
Pixel_Outlaw has quit [Quit: Leaving]
<aeth>
Even for things that are fixable in theory, it's often just faster to restart everything and quickload the project again
Cymew has quit [Ping timeout: 248 seconds]
Cymew has joined #lisp
<stacksmith>
true. I've been typing and tabbing like a fool. s-r-i-l is almost easier.
<Zhivago>
That's my experience -- incremental evaluation was a great solution when machines were slower.
<aeth>
stacksmith: depending on what you have installed s-r-i-l might not be unambiguous. You might need sl-r-i-l or something
smurfrobot has joined #lisp
<aeth>
Zhivago: But taken to the extreme of CEPL, it's still a benefit. Ime, you're going to experience (at best) seconds of delay without a live coding architecture like CEPL.
<drmeister>
So, several years ago I wrote this Common Lisp application to generate meeting schedules for our Temple University Chemistry graduate recruiting weekend.
<drmeister>
It has to work out schedules that match ~30 visiting students with ~25 faculty and match interests, time availability and a bunch of other constraints.
<drmeister>
I used the same math to generate the schedules that Cando uses to design molecules - Monte Carlo simulated annealing.
<drmeister>
I ran it in SBCL for several years.
Cymew has quit [Ping timeout: 256 seconds]
<drmeister>
This is the first year I was able to run it in Clasp - in a jupyter notebook no less.
<drmeister>
It takes 13.3 seconds to do one annealing run in SBCL and 57.9 seconds in Clasp.
<drmeister>
So we have work to do still - but not bad.
<drmeister>
pfdietz: Oh - very interested - thanks
Cymew has joined #lisp
kajo has quit [Quit: WeeChat 2.0.1]
kajo has joined #lisp
<stacksmith>
pfdietz: thanks for the link!
Cymew has quit [Ping timeout: 260 seconds]
zaquest has quit [Read error: Connection reset by peer]
zaquest has joined #lisp
aindilis has quit [Ping timeout: 256 seconds]
Cymew has joined #lisp
<drmeister>
The only problem was that ATOM in Cando means something different from CL:ATOM - so I had to package prefix it.
* drmeister
shakes his fist at early Lisp programmers.
Cymew has quit [Ping timeout: 240 seconds]
<drmeister>
I don't care what anyone says - CL:ATOM is a terrible special symbol to use in Common Lisp. Democritus reserved that word 2,500 years ago.
<pjb>
drmeister: but he was as wrong as John McCarthy.
<pjb>
Atoms are not atomic. ATOMs neither.
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
shka has joined #lisp
<beach>
Good morning everyone!
<drmeister>
Touche!
<drmeister>
Hi beach
<pfdietz>
You can shadow ATOM in the package you are working in, and use CL:ATOM if you want that standard symbol.
<drmeister>
That's what I've done in Cando
smurfrobot has quit [Ping timeout: 240 seconds]
smurfrobot has joined #lisp
schoppenhauer has quit [Ping timeout: 256 seconds]
* drmeister
is old-school
damke_ has joined #lisp
schoppenhauer has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
smurfrobot has joined #lisp
pierpa has quit [Quit: Page closed]
fikka has joined #lisp
kundry_wag has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
<mfiano>
Is there a way to add documentation to implicit DEFSTRUCT accessors/constructor other than using #'documentation, thus not getting picked up by Quickdocs?
osalberger has quit [Quit: Going offline, see ya! (www.adiirc.com)]
fikka has joined #lisp
z3t0 has joined #lisp
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
MrBusiness has joined #lisp
z3t0 has quit [Ping timeout: 256 seconds]
rumbler31 has quit [Remote host closed the connection]
Bike has quit [Quit: Lost terminal]
fikka has joined #lisp
parjanya has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Read error: Connection reset by peer]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 255 seconds]
kajo has quit [Read error: Connection reset by peer]
smurfrobot has quit [Ping timeout: 248 seconds]
kajo has joined #lisp
fortitude has quit [Read error: Connection reset by peer]
fikka has joined #lisp
fortitude has joined #lisp
mjl_ has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
<shka>
hey
<shka>
how do you write function on integers that is supposed to overflow?
fikka has joined #lisp
<shka>
what i do is to chain it with logand and maximal fixnum
<shka>
not sure if that's the best way to do it
<aeth>
What is it supposed to do when it overflows?
<shka>
i don't care, it is a hash function
vtomole has quit [Ping timeout: 260 seconds]
<aeth>
If you want it to wrap around, I would probably just use mod, but I only have ever done that with unsigned integers. If you want it to be signed, I suppose you can just use mod anyway and then add to it, but that could be inefficient.
<aeth>
mod with a power of 2 could in theory be optimized, I think?
<aeth>
SBCL seems to optimize mod with a power of 2
<shka>
well, that is essentially the same as logand with max fixnum
<shka>
but what i'm trying to figure out, is how to avoid promoting fixnum to integer
fikka has quit [Ping timeout: 264 seconds]
damke_ has quit [Ping timeout: 264 seconds]
<aeth>
What I tend to do is work with (unsigned-byte 8), (unsigned-byte 32), or (unsigned-byte 64) and use mod to keep it in that range. (unsigned-byte 64) could, in theory, not be a consing bignum if part of a specialized array and used in a 64-bit implementation, even though it can be larger than the fixnum size. It works in SBCL, I'd have to see how many support it, though.
damke_ has joined #lisp
<aeth>
(I guess (unsigned-byte 16) would also work... I just have never needed to use it yet)
smasta has joined #lisp
fisxoj has quit [Quit: fisxoj]
<aeth>
It looks like SBCL will even optimize mod for (expt 2 64) as long as you do use an array to avoid the boxing. e.g. (defun foobar (x) (declare ((simple-array (unsigned-byte 64) (1)) x)) (setf (aref x 0) (mod (1+ (aref x 0)) (expt 2 64))) x)
<aeth>
When it's a fixnum for sure, no need for an array for it to be optimized, e.g. (defun foo (x) (declare ((unsigned-byte 32) x)) (mod (1+ x) (expt 2 32)))
smasta has quit [Ping timeout: 248 seconds]
<aeth>
I'm not sure how hard these optimizations would be to introduce to implementations that don't have them at the moment.
whoman has quit [Remote host closed the connection]
whoman has joined #lisp
igemnace has quit [Quit: WeeChat 2.0.1]
scymtym has quit [Remote host closed the connection]
scymtym has joined #lisp
smurfrobot has joined #lisp
hhdave_ has joined #lisp
saki has joined #lisp
Lycurgus has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
smasta has joined #lisp
fortitude has quit [Read error: Connection reset by peer]
smasta has quit [Ping timeout: 255 seconds]
fortitude has joined #lisp
shrdlu68 has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 240 seconds]
thijso has joined #lisp
fikka has joined #lisp
jibanes has quit [Ping timeout: 256 seconds]
_cosmonaut_ has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
jibanes has joined #lisp
python476 has joined #lisp
pagnol has joined #lisp
aindilis has quit [Ping timeout: 265 seconds]
thodg has joined #lisp
aindilis has joined #lisp
fikka has joined #lisp
pillton has quit [Ping timeout: 248 seconds]
solyd has quit [Quit: solyd]
solyd has joined #lisp
fikka has quit [Ping timeout: 248 seconds]
smasta has joined #lisp
fikka has joined #lisp
daniel-s has joined #lisp
smasta has quit [Ping timeout: 240 seconds]
angavrilov has joined #lisp
ggherdov has quit []
nowhereman_ has joined #lisp
ggherdov has joined #lisp
solyd has quit [Quit: solyd]
nowhere_man has joined #lisp
nowhereman_ has quit [Ping timeout: 265 seconds]
solyd has joined #lisp
<thodg>
anyone into streams ?
<thodg>
and multi agent programming
dmiles has joined #lisp
<thodg>
please msg me
nowhereman_ has joined #lisp
nowhere_man has quit [Ping timeout: 255 seconds]
ludston_ has quit [Read error: Connection reset by peer]
nirved has joined #lisp
ludston has joined #lisp
smurfrobot has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
smasta has joined #lisp
SuperJen has joined #lisp
smasta has quit [Ping timeout: 256 seconds]
JenElizabeth has quit [Ping timeout: 255 seconds]
SuperJen has quit [Remote host closed the connection]
JenElizabeth has joined #lisp
smasta has joined #lisp
Denommus` has joined #lisp
smasta has quit [Ping timeout: 248 seconds]
Denommus has quit [Ping timeout: 276 seconds]
daniel-s has quit [Remote host closed the connection]
p_l has quit []
p_l has joined #lisp
EvW has joined #lisp
mishoo has quit [Ping timeout: 248 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
markong has joined #lisp
thodg has quit [Ping timeout: 240 seconds]
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
attila_lendvai has joined #lisp
dmh has quit []
dmh has joined #lisp
mishoo has joined #lisp
d4ryus2 is now known as d4ryus
<Cthulhux>
no
mishoo has quit [Ping timeout: 248 seconds]
jibanes has quit [Ping timeout: 240 seconds]
jibanes has joined #lisp
Mandus has quit [Ping timeout: 248 seconds]
Mandus has joined #lisp
Denommus` has quit [Ping timeout: 255 seconds]
EvW has quit [Ping timeout: 255 seconds]
quazimodo has joined #lisp
fikka has quit [Quit: leaving]
fikka has joined #lisp
<nydel>
g'morning all
attila_lendvai has quit [Read error: Connection reset by peer]
EvW has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
smokeink has joined #lisp
nowhere_man has joined #lisp
smurfrobot has joined #lisp
nowhereman_ has quit [Ping timeout: 264 seconds]
wxie has joined #lisp
smurfrobot has quit [Ping timeout: 256 seconds]
jmercouris has joined #lisp
<jmercouris>
jasom: do you have a link?
rumbler31 has joined #lisp
jmercouris has quit [Ping timeout: 240 seconds]
makomo has joined #lisp
jmercouris has joined #lisp
<jmercouris>
I'm trying to remember, there's some package to turn asdf systems into deb packages automatically, or something of that nature, anyone know what I'm talking about?
lnostdal has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
JenElizabeth has quit [Remote host closed the connection]
JenElizabeth has joined #lisp
<Xach>
I think dim has something called ql2deb
JenElizabeth has quit [Remote host closed the connection]
JenElizabeth has joined #lisp
JenElizabeth has quit [Remote host closed the connection]
shifty has quit [Ping timeout: 240 seconds]
raynold has quit [Quit: Connection closed for inactivity]
Lycurgus has quit [Quit: Ex Chat]
<jmercouris>
nothing coming up on google or duckduckgo
<jmercouris>
it's okay, I'll just compile for Linux users I guess
<jmercouris>
at least debian users
Lycurgus has joined #lisp
fortitude has quit [Read error: Connection reset by peer]
<jmercouris>
so this creates an issue, when I compile binaries, and the *temporary-directory* is already set, asdf will use it
<jmercouris>
then, when other people attempt to using anything that uses temp directory, it will try to access a folder that does not exist
nullman has joined #lisp
damke_ has joined #lisp
<jackdaniel>
just call (setup-temporary-directory)
<jackdaniel>
that will reinitialize the var on call
<jmercouris>
jackdaniel: so I should put it in my application startup?
<jmercouris>
e.g. not as a top level form?
<jackdaniel>
hm, or not, apparently #'default-temoprary-directory is reader-conditionalized
Murii has quit [Ping timeout: 276 seconds]
<jackdaniel>
even not that, it is simply expanded at compilation time
<jmercouris>
what about (setf uiop::*temporary-directory* (uoip:default-temporary-directory))
<jackdaniel>
as I said one line above, function default-temporary-directory is "fixed" at compilation time
<jmercouris>
Ah, damnit
<jackdaniel>
you could cripple os-cond macro of course
<jmercouris>
maybe I should copy it into a utility in my program
<jmercouris>
Actually, you know, it doesn't really matter
<jackdaniel>
to behave just as it behaves on abcl (btw, this is a terrible idea to have operator which behaves differently depending on implementation - os-cond expands into cond on ABCL and directly into body (resolved at compile time) on others
<jmercouris>
as I can will not use windows anyways
<jmercouris>
s/can//
<jackdaniel>
that's a spirit ,p
<jackdaniel>
either way you'll have to compile separately for each platform
<jmercouris>
also true
<jackdaniel>
so this will make no difference to you
<jmercouris>
indeed
<jmercouris>
thanks for your advice
<jackdaniel>
still I'm amazed by os-cond operator (though I understand the motivation - java bytecode is portable across operating systems)
damke_ has quit [Ping timeout: 264 seconds]
<jmercouris>
yeah, but the java vm is better than any lisp implementation
<jmercouris>
I don't mean to start a flamewar, but the jvm is unbelievably fast for what it is
<jmercouris>
and well engineered
<jackdaniel>
I don't see how it is related in any way to what I said above
<jackdaniel>
(except word "java" ;)
<jmercouris>
I'm just saying, every jvm implementation is more extensive and considers OS edge cases
<jmercouris>
e.g. the team that implemented the jvm for windows, and for linux, etc they considered all of these issues so that the java devs don't have to
<jmercouris>
maybe my point is getting lost in the space between my brain and the keyboard, doesn't matter anyway
<jackdaniel>
I'm more curious *why* you're saying this (your remarks started with "yeah, but…")
EvW has quit [Ping timeout: 260 seconds]
<jmercouris>
I was trying to say "yes, you are correct, but java has infinity more development money and engineer time"
johnnymacs has quit [Remote host closed the connection]
<jackdaniel>
I still don't understand the "but" part, but not interested enough to keep asking ;)
attila_lendvai has quit [Read error: Connection reset by peer]
m00natic has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
kundry_wag has joined #lisp
Kundry_W_ has joined #lisp
Bike has joined #lisp
kundry_wag has quit [Ping timeout: 260 seconds]
benny has quit [Ping timeout: 248 seconds]
benny has joined #lisp
EvW has joined #lisp
orivej has joined #lisp
<phoe>
What would be a proper way to write a macro that negates a place's value and sets it there?
<phoe>
I want to achieve what beach mentioned, evaluating the place subforms only once.
convexferret has quit []
<phoe>
My first idea is (defmacro negatef (place) (with-gensyms (val) `(let ((,val ,place)) (setf ,place (not ,val))))) but I don't think it achieves this.
<beach>
I think you can get away with the short form of DEFSETF.
convexferret has joined #lisp
<beach>
Oh, sorry, I am confused.
<phoe>
I want to be able to call (negatef x) where X is a place.
<beach>
No, you need to use get-setf-expansion.
<phoe>
:(
<phoe>
Time to go the complicated route, then.
<jackdaniel>
and these 5 values are indeed hard to grok at first
<beach>
It is not that bad. You can check an example.
<phoe>
I did. Didn't help me much back then.
orivej_ has joined #lisp
<jackdaniel>
phoe: probably best way to do that is to check up on shiftf (or rotatef) source of your favourite implementation
orivej has quit [Ping timeout: 264 seconds]
<beach>
phoe: Look in SICL/Code/Cons/push-pop-defmacro.lisp
<jackdaniel>
(by "doing that" I mean – understanding the concept)
<beach>
But now you know about get-setf-expansion too.
<beach>
... so it wasn't wasted
<phoe>
Yes.
<phoe>
Now I'm a little bit less stupid.
<beach>
There is a TV show here in France named (in translation) "you will dies less stupid (but you will still die)"
EvW has quit [Ping timeout: 255 seconds]
<phoe>
Very good.
<beach>
It's about popular science.
<phoe>
...should I submit this anywhere though?
<beach>
NEGATEF? sure Alexandria maybe.
EvW has joined #lisp
<lieven>
I would expect negatef to map x to -x, x to not x is more TOGGLEF
<dlowe>
notf?
<beach>
Or NOTF.
<lieven>
yeah
kobain has joined #lisp
infinisil has quit [Quit: Configuring ZNC, sorry for the join/quits!]
fikka has joined #lisp
zooey has quit [Read error: Connection reset by peer]
<phoe>
notf
<phoe>
yes
<pfdietz>
-F
zooey has joined #lisp
johs has quit []
johs has joined #lisp
mingus has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 260 seconds]
dieggsy has joined #lisp
smurfrobot has joined #lisp
<phoe>
pfdietz: that's decf
fikka has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
JenElizabeth has joined #lisp
mishoo has joined #lisp
jmercouris has quit [Ping timeout: 265 seconds]
warweasle has quit [Quit: later]
smurfrobot has joined #lisp
fikka has quit [Ping timeout: 276 seconds]
<phoe>
I just read "setf" as "setify"
smurfrobot has quit [Ping timeout: 276 seconds]
sjl has quit [Quit: WeeChat 1.9.1]
fikka has joined #lisp
smasta has joined #lisp
froggey has joined #lisp
scymtym has quit [Ping timeout: 265 seconds]
JenElizabeth has quit [Remote host closed the connection]
Kaisyu has quit [Quit: Connection closed for inactivity]
JenElizabeth has joined #lisp
JenElizabeth has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 256 seconds]
moonfght has joined #lisp
moonfght has quit [Remote host closed the connection]
moonfght has joined #lisp
fikka has joined #lisp
moonfght has quit [Remote host closed the connection]
moonfght has joined #lisp
<__rumbler31>
noob question alert. in http://clhs.lisp.se/Body/m_defi_2.htm the example where setq is used to initialize x to '(1 2 3) and y to x, what signals to the programmer that a copy of the list is made vs storing a reference
<__rumbler31>
oh wait, append returns a new list doesn't it
<phoe>
__rumbler31: not really
<phoe>
"...the list structure of each of lists except the last is copied."
<beach>
__rumbler31: There is never any implicit copying in Common Lisp.
attila_lendvai has quit [Read error: Connection reset by peer]
<phoe>
so, "what signals to the programmer" - the documentation for macro APPENDF.
<beach>
__rumbler31: So SETQ never copies anything.
<__rumbler31>
I see, that is the key. thank you
<beach>
I call this feature "uniform reference semantics".
attila_lendvai has joined #lisp
<beach>
Every object is manipulated through a reference to the real object. Assignment, argument passing, etc., only copies the reference.
<__rumbler31>
mmm
<tfb>
beach: every mutable object, anyway
<tfb>
(ie numbers can be weird)
<beach>
Notice the word "semantics". An implementation can copy if the programmer can not verify this fact, for instance if the object is immutable.
<__rumbler31>
ok
<__rumbler31>
very nice
<beach>
So it is "AS IF every object is manipulated..."
<beach>
__rumbler31: It's the only sane way of doing it. That is why so many other languages get it wrong.
Cymew has quit [Remote host closed the connection]
<beach>
OK, I think I have a framework for indentation in the editor. Currently, the only thing it knows how to indent is LET, and here is an example: http://metamodular.com/indentation.png though the green rectangle will be replaced with a left arrow and the red one with a right arrow, and they will be in a column outside the text.
<beach>
Notice that the list of bindings is in 5 instead of 4 and the body form is in column 1 instead of 2.
smasta has quit [Ping timeout: 240 seconds]
<beach>
is in column 5 instead of 4.
fikka has joined #lisp
smurfrobot has joined #lisp
<beach>
Contrary to what other editors do, this framework is not based on regular expressions or similar. It parses the buffer using the Common Lisp reader, and it does not attempt to parse the bindings as forms.
Cymew has joined #lisp
moonfght_ has joined #lisp
<beach>
Once I have indent functions for most special forms and for some standard functions and macros, and a command for adjusting the indentation, I think I have enough to start using it for programming. More sophisticated stuff will come later, such as determining the roles of the symbols.
moonfght_ has quit [Remote host closed the connection]
moonfght_ has joined #lisp
pagnol has quit [Ping timeout: 252 seconds]
moonfght has quit [Ping timeout: 260 seconds]
moonfght_ has quit [Remote host closed the connection]
fikka has quit [Ping timeout: 240 seconds]
moonfght_ has joined #lisp
smurfrobot has quit [Ping timeout: 260 seconds]
<beach>
I take it nobody is impressed. Oh well. :)
moonfght_ has quit [Remote host closed the connection]
Cymew has quit [Ping timeout: 240 seconds]
blackwolf has joined #lisp
<phoe>
I am, just busy now
moonfght_ has joined #lisp
smasta has joined #lisp
<beach>
I was joking.
<phoe>
I wish I was joking about being busy. :(
<beach>
I don't expect anyone to be impressed until they see a more polished product.
<phoe>
How do you plan on dealing with the existing indentation? LET is indented differently by SLIME.
<phoe>
SLIME/Emacs*
<beach>
No, I indent it the same way.
moonfght_ has quit [Remote host closed the connection]
moonfght_ has joined #lisp
<beach>
... other than when Emacs gets it wrong of course. :)
Cymew has joined #lisp
moonfght_ has quit [Remote host closed the connection]
moonfght_ has joined #lisp
<phoe>
(let
<phoe>
((x 10))
<phoe>
(1+ x))
<phoe>
that's what Emacs gives me. Four spaces, two spaces.
fikka has joined #lisp
<Bike>
what's an example of an invalid character, in the default table?
<jackdaniel>
slime indents 2 spaces for any &body (including let)
<beach>
Maybe I wasn't very clear. The incorrect indentation in the image is signaled by the colored rectangles.
<phoe>
...oh wait
<jackdaniel>
ah, that makes more sense
<phoe>
ooooh, you get colored rectangles if there are too many or too few spaces
<beach>
When I have the correct indentation, no rectangles are drawn.
<phoe>
clever!
<phoe>
I get it now.
<jmercouris>
My buffer is completely free of boxes of any color, my indentation must be perfect :P
<Bike>
are there any, even....
<beach>
But they won't be rectangles in the final version.
Cymew has quit [Ping timeout: 264 seconds]
<phoe>
I use aggressive-indent in emacs so my code is always auto-indented no matter what I do.
<jmercouris>
phoe: I prefer smashing M-q when something feels off
<beach>
phoe: That sounds like an option that I might want to consider.
<beach>
jackdaniel: Yes, that's why I want something better.
<jackdaniel>
I know, I've mentioned it because phoe and jmercouris said that they "indent everything" - just pointed out that some cases are not covered by that
<beach>
jmercouris: I feel like it is using regular expressions to determine indentation.
fikka has quit [Ping timeout: 248 seconds]
<beach>
jackdaniel: Got it.
<jackdaniel>
I've tried to install lem, but roswell didn't happen to work, so I've lost the interest (roswell is a requirement according to the doc)
<jmercouris>
beach: Probably, but how do you feel about it? do you like the project?
moonfght_ has quit [Remote host closed the connection]
<beach>
jmercouris: It is probably fine, for those who don't mind the fact the regular expressions are used to determine indentation.
<jmercouris>
I feel as if in the screencast it hasn't demonstrated anything emacs can't do, so I haven't been really motivated to try it
moonfght_ has joined #lisp
moonfght_ has quit [Remote host closed the connection]
<stacksmith>
I've used lem for a bit, and implemented an XCB backend and a file chooser addon. In the end I got bored, it's just like having an emacs with a lot less functionality although in CL.
<jmercouris>
beach: What's the biggest reason somebody should use Climacs (in the finished version) rather than an existing editor?
<beach>
jmercouris: It does not use regular expressions to determine indentation.
<jackdaniel>
first four letters answer the question ;-)
Cymew has quit [Ping timeout: 255 seconds]
<jmercouris>
jackdaniel: why should we care about the rendering technology?
<stacksmith>
Lem horizontal scrolling is nuts. As in not at all, except for the line you are on.
<jackdaniel>
jmercouris: ";-)" stays for "I'm joking"
<stacksmith>
And no wrapping.
<jmercouris>
Ah, I see :D
<jmercouris>
beach: Is this a very huge problem in your workflows?
<jackdaniel>
s/stays/stands/
<beach>
jmercouris: I am only half joking. The technology I am developing will make possible many more interesting operations on Common Lisp code.
Cymew has joined #lisp
DGASAU has quit [Read error: Connection reset by peer]
<jmercouris>
beach: so it presents a better platform, more than anything else?
DGASAU has joined #lisp
fikka has joined #lisp
<beach>
jmercouris: I will be able to tell whether (say) a Common Lisp function name is used in a role as a lexical variable, and use different colors or fonts for the two cases.
<jmercouris>
That woould be pretty cool
<beach>
jmercouris: I will be able to determine what bindings or assignments to a variable can affect a particular use of it.
<beach>
I will be able to tell what expressions are forms and what expressions are not.
<jmercouris>
It's too bad that adopting something like Climacs means losing all of your emacs packages
<beach>
Indeed.
EvW has quit [Ping timeout: 256 seconds]
<beach>
Initially, all I can hope for is that it will be enough of an improvement over Emacs for editing Common Lisp code that I will use it for that and Emacs for the rest.
<beach>
Not ideal, I know.
<jmercouris>
you could embed it into emacs possibly
<jmercouris>
using the "xwidget" branch
<jmercouris>
or whatever it's called
<jmercouris>
but nesting keybindings like that is always really tricky
lnostdal has quit [Ping timeout: 255 seconds]
<jackdaniel>
there was a probject (not sure if it was something useful at some point of time) to implement elisp in CL
<jackdaniel>
namely it was written for Hemlock afair
Cymew has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 240 seconds]
<jmercouris>
you could probably port a lot of elisp code into cl pretty easily, it may make more sense to just rewrite any packages you need
<jmercouris>
but then climacs would have to implement a lot of the same mechanisms for extension that exist in emacs
<jackdaniel>
as of my needs, I wouldn't mind having a good editor which is not emacs
<jmercouris>
beach: do you remember approximately 9 months ago, you spoke about a common lisp program core controlling a foreign gui process
<beach>
No, but it sounds like something I would have done.
<jmercouris>
beach: If I remember correctly you said that the foreign code could not be fully trusted, and this would make the system more stable and reliable
<jmercouris>
I was asking about this again a few days ago, but I presume you were asleep
<beach>
Yes, I think that is true.
nowhereman_ has joined #lisp
<jmercouris>
So, do you think I should do this for Next?
<beach>
Well, people told you it would be complicated.
<jmercouris>
I was going to have just a socket connection between a CL core, and whatever "graphical frontend" exists
<jmercouris>
It is complicate
<jmercouris>
complicated*, but do you think it is worth it?
smurfrobot has joined #lisp
<jmercouris>
I'll be able to use any platform without it having to be ported to some CL interface, it need only support sockets
<beach>
I wouldn't consider doing it myself because it is a lot of work, but if you are up to it, sure, give it a shot.
Arcaelyx has joined #lisp
<jmercouris>
It doesn't even mean a rewrite of my system, I only need to create a "remote-backend" in lisp, that will function as the interface between the GUI and the Core
fikka has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
<jmercouris>
maybe I will do it in release 0.09
<jmercouris>
it would make my system even faster...
varjag has quit [Quit: ERC (IRC client for Emacs 24.5.1)]
<jmercouris>
and if it is too much work, I don't have to merge it in
<beach>
Yes, you seem to have the energy to try it, so go ahead.
knobo1 has joined #lisp
<jmercouris>
I'm not sure if you are suggesting I am naieve and wasting my time or really think I should try it :D
pierrethierry has joined #lisp
<knobo1>
How can I call on a conditions report function?
nowhere_man has quit [Ping timeout: 260 seconds]
pierrethierry is now known as nowhere_man
<Xach>
knobo1: (format t "~A" condition)
Cymew has joined #lisp
<Xach>
there are other ways
nowhereman_ has quit [Ping timeout: 252 seconds]
<beach>
jmercouris: Well, you have written a program that uses foreign code, which is something I wouldn't contemplate in the first case, so I am having a hard time putting myself into your situation.
<knobo1>
ah, right
<beach>
in the first PLACE
<jmercouris>
Fair enough, I think I will do this then, 3rd times the charm right? :D at least every release is faster and more stable than the one before
<beach>
jmercouris: I do think you should try it. It could be a learning experience.
fikka has quit [Ping timeout: 268 seconds]
<jmercouris>
It definitely will be, I no nothing about sockets (in lisp) and this kind of paradigm, what are the pitfalls etc
<jmercouris>
s/no/know...
Cymew has quit [Ping timeout: 240 seconds]
vibs29 has quit [Ping timeout: 248 seconds]
<beach>
jmercouris: The way I would have done a project like that would be to first write an appropriate backend for McCLIM (which would then benefit many others) and then write the GUI using McCLIM.
<beach>
It might take longer, but it would benefit others too.
smurfrobot has quit [Read error: Connection reset by peer]
<beach>
But I think I understand that you want to make money out of your projects, so that's another difference.
vibs29 has joined #lisp
Cymew has joined #lisp
mjl_ has quit [Quit: Lost terminal]
<jmercouris>
beach: I have no other means to support myself while working full time on Next, so the consequence is that I have to make money
<pjb>
beach: I'll be impressed when it will be able to indent "correctly" random reader macros.
mjl_ has joined #lisp
<jmercouris>
beach: I am also interested in benefitting others, which is why my source is BSD and entirely open
<beach>
pjb: That's a tough one, but it might be possible to do something.
<jmercouris>
beach: For me to get into something like McCLIM, I see it like a moonshot, way above my skills. If I do ever end up making money though, I plan on giving back to the Lisp community through source, and maybe sponsorships, who knows, however I can
<beach>
pjb: That would be an interesting project. I think I'll leave it to others though. I don't personally need such a feature.
<pjb>
table-based programming ;-)
knobo1 has quit [Ping timeout: 276 seconds]
<beach>
pjb: And I am always working with the hypothesis that I might be the only end user, so I'll do the features I personally need first.
<pjb>
Well, we can restrict indenting to the prefix spaces…
scymtym has joined #lisp
smurfrobot has joined #lisp
<beach>
For example, Shinmera has declared early on that he would never use an editor that runs in the same process as the Common Lisp system it is communicating with. And if many people feel that way, there is a good chance I might be the only user.
<pjb>
beach: I would use it.
<beach>
Oh, good!
<pjb>
I wrote several such mini editors (ed, sedit, etc).
<beach>
I can imagine.
moei has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
fourroot has joined #lisp
<fourroot>
hi
<jmercouris>
fourroot: hi
Cymew has joined #lisp
fikka has joined #lisp
saki has quit [Quit: saki]
smurfrobot has quit [Ping timeout: 240 seconds]
smasta has quit [Ping timeout: 264 seconds]
makomo has quit [Ping timeout: 240 seconds]
raynold has joined #lisp
smasta has joined #lisp
Cymew has quit [Ping timeout: 256 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
fikka has quit [Ping timeout: 264 seconds]
<beach>
fourroot: How is learning Common Lisp going?
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
<jmercouris>
I would say "not so well" based on our conversation :D
<beach>
Which conversation?
quazimodo has quit [Ping timeout: 240 seconds]
<jmercouris>
They pm'd me
<beach>
Oh!
damke_ has joined #lisp
Arcaelyx has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<beach>
fourroot: What constitutes "a Lisp", or "a dialect of Lisp" is not well defined, and there is no widespread agreement of the issue. That is why this channel is dedicated to Common Lisp, which is well defined by the standard.
<rme>
When conversations include both Clozure CL and Clojure, I end up calling Clojure "clojure with a J". A very regrettable name conflict, but it's too late to change now.
s1detracking has joined #lisp
<jmercouris>
rme: The best time to plant a tree was 20 years ago, the second best time is today
fikka has quit [Ping timeout: 240 seconds]
vtomole has joined #lisp
<jmercouris>
Shinmera: I like your humor: "Surprisingly enough, the static folder is where statically served files go, and template is for template documents, if you happen to use a template system"
BitPuffin has quit [Remote host closed the connection]
fikka has joined #lisp
Lycurgus has quit [Quit: Ex Chat]
Lycurgus has joined #lisp
fikka has quit [Ping timeout: 268 seconds]
knobo1 has joined #lisp
makomo has joined #lisp
vtomole has quit [Quit: Page closed]
Kundry_W_ has quit []
antgreen has joined #lisp
smasta has quit [Ping timeout: 264 seconds]
fikka has joined #lisp
Karl_Dscc has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
jmercouris has quit [Ping timeout: 260 seconds]
hhdave_ has quit [Ping timeout: 240 seconds]
smasta has joined #lisp
fikka has joined #lisp
shrdlu68 has joined #lisp
fikka has quit [Ping timeout: 260 seconds]
orivej_ has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
varjag has joined #lisp
fikka has quit [Ping timeout: 240 seconds]
kobain has quit [Ping timeout: 256 seconds]
fikka has joined #lisp
shka has joined #lisp
vtomole has joined #lisp
<shrdlu68>
I'm currently doing (ash (ldb (byte 63 0) n) 1) to shift an (unsigned-byte 64) to the left while discarding the msb, but I feel like there ought to be a better way.
<Xach>
there are many ways but not sure what would make it better
<Xach>
shrdlu68: I would tend to write that with the ldb on the outside.
<Xach>
(ldb (byte 63 0) (ash n 1))
<Xach>
That probably isn't the same.
<shrdlu68>
better = less processing cycles.
mlf has joined #lisp
<Shinmera>
Well, with 64 bits you're already in bignum territory anyway
<Xach>
Not with the magic of SBCL modular arithmetic!
<phoe>
Shinmera: unless you're doing stuff in specialized arrays
<shrdlu68>
Xach: (ash n 1) would make it a bignum in some cases.
<phoe>
SBCL handles ub64 arrays properly
<shrdlu68>
Shinmera: Really?
<Xach>
shrdlu68: the masking would take care of that in sbcl.
<Shinmera>
shrdlu68: fixnums are less than 64 bits due to tag bits.
<shrdlu68>
Shinmera: _signed_ fixnums, I think.
<Shinmera>
(log most-positive-fixnum 2) ; => 62
<phoe>
...or does it?
<phoe>
I need to check
<Xach>
Anyway, with sbcl, and some declarations, and masking, you can work with (unsigned-byte 64) integers in unboxed ways for a while.
_cosmonaut_ has quit [Ping timeout: 252 seconds]
<shrdlu68>
I'm consulting the SBCL manual increasingly often these days.
<shka>
hello
<shka>
Shinmera: hey, you there?
<Shinmera>
No
<shka>
that's sad
fourier has joined #lisp
<Shinmera>
I am a sad man
<shka>
me too, but i am good at pretending
<shka>
seen my merge request at documentation-utils?
<Shinmera>
Yes, haven't had time to look at it in depth yet, sorry.
<shka>
no problem
<Shinmera>
Been busy with thesis and ELS, and clasp stuff.
<shka>
that's fine with me, just let me know what do you think eventually
<Shinmera>
Sure, I'll do a review on github when I have the time
<shka>
cool
<shka>
no rush
<shka>
also
<shka>
happy valentines day :PPPP
<drmeister>
I just ran into a problem with esrap. Previously I specified it in my .asd :depends-on (:version :esrap "0.15") ...)
<drmeister>
Now I'm getting the error that quicklisp can't find version 0.15 but it finds esrap version 0.14.
<drmeister>
More distressing - parser.common-rules isn't found at all.
<drmeister>
scymtym: Ping^
<phoe>
drmeister: (ql:update-all-dists) ?
<phoe>
this sounds like less of an esrap problem and more of an ASDF/QL problem
<drmeister>
Oh yeah - that cleaned things up - thanks
<phoe>
<3
* shrdlu68
checks out how clasp is going.
jibanes has quit [Ping timeout: 256 seconds]
jibanes has joined #lisp
specbot has quit [Disconnected by services]
EvW has joined #lisp
minion has quit [Disconnected by services]
minion has joined #lisp
minion has quit [Disconnected by services]
shrdlu68 has quit [Ping timeout: 248 seconds]
fourier has quit [Ping timeout: 265 seconds]
specbot has joined #lisp
minion has joined #lisp
nullman has quit [Ping timeout: 248 seconds]
nullman has joined #lisp
smasta has quit [Ping timeout: 248 seconds]
smasta has joined #lisp
Sauvin has quit [Read error: Connection reset by peer]
solyd has joined #lisp
ckonstanski has quit [Ping timeout: 255 seconds]
EvW has quit [Remote host closed the connection]
jmercouris has joined #lisp
<jmercouris>
is there a way to tell emacs to load a system by specifiying the path of the asd?
<jmercouris>
or must I put it in the appropriate dir?
<Bike>
...emacs?
<jmercouris>
Bike: Well, I usually type slime-load-system, and it'll load it into my inferior lisp
<Bike>
it defers to lisp pretty immediately, i would think
fourier has joined #lisp
<Xach>
jmercouris: (asdf::load-asd "/path/to/file") is what to use.
<jmercouris>
Bike: probably, that would make sense
<phoe>
^
<phoe>
or ql:quickload if the system is quickloadable
<Xach>
that will make the system known
<jmercouris>
Xach: Okay, that makes sense, thanks
<phoe>
because all of my sytems are quickloadable
fourier has quit [Changing host]
fourier has joined #lisp
<Xach>
then you have to load it as a separate step
<jmercouris>
Xach: was just hoping for some emacs thing so I could bind it to a "find-file" like dialog
<jmercouris>
I guess I could do some sort of find file and then pass it into the slime-repl buffer?
<Bike>
you could write an emacs function that takes a filename and has swank evaluate the appropriate load-asd form
<Bike>
if i was doing this very often i'd just add the system to the search path though
<jmercouris>
I know, but it might be cool to just be able to clone a repo anywhere on your system and load it
<jmercouris>
just for one off things
<jmercouris>
I often find myself inspecting the source code of other people, and I don't necessarily want to put it into my search path
<jmercouris>
Bike: there's slime-eval, that could work
<jmercouris>
if I write a function I'll post it here
<Xach>
asdf:*system-definition-search-functions* might be fruitful as well.
<Xach>
it is a fantastico escape hatch for finding systems in new ways.
<Bike>
well, usually i'd clone it wherever, and then put a symlink in the search path
* dlowe
wonders if the piping is generic enough to put a "pathname to a system" search function in there
bhyde has quit [Quit: Terminated with extreme prejudice - dircproxy 1.2.0]
<jackdaniel>
I thought `the' is reserved for singular
fikka has quit [Ping timeout: 264 seconds]
nowhereman_ has quit [Ping timeout: 260 seconds]
<yaroe>
Well I was thinking of the garbage collector for those Lisp implementation (uLisp, microscheme , armpit). But you are right that my writing was too short.
<jackdaniel>
I think its easy to look it up. I'm not sure what do you mean by "realtime programming" too
<stacksmith>
yaroe: this is a Common Lisp forum...
<jackdaniel>
there is concept of real-time garbage collectors, but I don't think that's what you mean
smurfrobot has joined #lisp
<fourier>
rt gc provides hard guarantees of collection time, not sure if any of those have one
<jackdaniel>
yes, I don't think he meant rt gc though
<yaroe>
I was not thinking about hard realtime programming
<dlowe>
if you're interested in exploring different kinds of lisp dialects, you're invited to converse in ##lisp
nosaj88 has joined #lisp
<yaroe>
But only that gc is not on the way when you try to handle time constraint
* jackdaniel
doesn't understand, but gets silent because it is indeed offtopic here :)
<fourier>
i guess you just need to go and study their gcs
dddddd has joined #lisp
smurfrobot has quit [Ping timeout: 248 seconds]
<yaroe>
ok nevermind. Thanks anyway : I have good readings to look at :) !
eschatologist has quit [Ping timeout: 276 seconds]
eschatologist has joined #lisp
solyd has quit [Quit: solyd]
quazimodo has joined #lisp
minion has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
lucasb has joined #lisp
shrdlu68 has joined #lisp
smurfrobot has quit [Ping timeout: 265 seconds]
smurfrobot has joined #lisp
knicklux has joined #lisp
kundry_wag has quit [Remote host closed the connection]
shrdlu68 has quit [Read error: Connection reset by peer]
kundry_wag has joined #lisp
yaroe has left #lisp ["ERC Version 5.3 (IRC client for Emacs)"]
smurfrobot has quit [Ping timeout: 276 seconds]
Cymew has joined #lisp
shrdlu68 has joined #lisp
kundry_wag has quit [Ping timeout: 276 seconds]
smurfrobot has joined #lisp
fikka has joined #lisp
Cymew has quit [Ping timeout: 248 seconds]
smurfrobot has quit [Ping timeout: 248 seconds]
mjl_ has quit [Ping timeout: 256 seconds]
fikka has quit [Ping timeout: 248 seconds]
wxie has joined #lisp
shrdlu68 has quit [Ping timeout: 268 seconds]
smasta has joined #lisp
fisxoj has joined #lisp
vap1 has quit [Ping timeout: 240 seconds]
fortitude has quit [Read error: Connection reset by peer]
fourier has quit [Ping timeout: 268 seconds]
arbv has quit [Ping timeout: 256 seconds]
<jmercouris>
Is there a way to serialize hashtables to a human readable string?
shka has quit [Ping timeout: 240 seconds]
<jmercouris>
pprint? or something like that?
<jackdaniel>
hash tables doesn't have printable representation
<Bike>
it's not built in.
fortitude has joined #lisp
<jackdaniel>
(in CL standard)
<Bike>
you can write something out pretty easily with maphash, i do that a lot.
<jmercouris>
I see something alexandria that looks good
arbv has joined #lisp
<jmercouris>
I guess that is what it'll have to be, thanks
arbv has quit [Client Quit]
<jmercouris>
in alexandria*
<jackdaniel>
Bike: does it count as serialization though?
<Bike>
i focused on 'human readable'
<jmercouris>
does pprinting count as serialization? why would it not?
<jmercouris>
you are serializing to a format that humans can process
<Bike>
usually if you're "serializing" something you'll want to deserialize it later
<jmercouris>
"serialization is the process of translating data structures or object state into a format that can be stored (for example, in a file or memory buffer) or transmitted (for example, across a network connection link) and reconstructed later (possibly in a different computer environment)"
<Bike>
right, reconstructed
<jmercouris>
it would be reconstructable in a human readable format, I don't see why not
<jmercouris>
I actually did want something that was human readable AND reconstructable
<jmercouris>
because I would like to look at the data, but also reload it at a later time
<jackdaniel>
that's abusing words, what waters them down
<phoe>
jmercouris: one moment
<Bike>
then you're going for something more scrupulous than i had in mind
<fisxoj>
has anyone tried to use cffi's :static-program-op?
<fisxoj>
for compiling a static binary of a program
<phoe>
this is what I use. crazy, but works for most of the simple cases.
pillton has joined #lisp
<jmercouris>
phoe: looks good enough for me, the problem will be reserialization, but thanks anyway :)
<phoe>
you just read this object.
<jmercouris>
and it works?
<Bike>
is this crazy...?
<phoe>
yes, thanks to the #. notation.
<Bike>
using ~a instead of ~s i guess, but whatever
<stacksmith>
phoe: nice stuff.
<phoe>
Bike: ~A where?
<jmercouris>
phoe: nice!
<phoe>
oh wait, in :TEST?
<Bike>
yes
<phoe>
hm hm, does it matter here?
<phoe>
I think it might, in packages that don't use CL.
<Bike>
probably not, but ~a is not necessarily lisp readable
smasta has quit [Ping timeout: 240 seconds]
<jackdaniel>
fisxoj: in most implementations when you save-lisp-and-die you in fact have a statically linked program
<jackdaniel>
ah, cffi
<jackdaniel>
nvm me, I've read ASDF
<fisxoj>
it does not seem to be the case with sbcl
<fisxoj>
it still depends on a few libraries
<fisxoj>
and probably not anything linked by cffi
<phoe>
stacksmith: thanks.
Mandus has quit [Quit: Changing server]
Mandus has joined #lisp
Mandus has quit [Client Quit]
ludston_ has joined #lisp
attila_lendvai has quit [Read error: Connection reset by peer]
attila_lendvai has joined #lisp
smurfrobot has joined #lisp
ludston has quit [Ping timeout: 260 seconds]
attila_lendvai has quit [Read error: Connection reset by peer]
warweasle has quit [Quit: rcirc on GNU Emacs 24.4.1]
nowhereman_ has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has joined #lisp
attila_lendvai has quit [Changing host]
smurfrobot has quit [Ping timeout: 268 seconds]
fourroot has quit [Read error: Connection reset by peer]
angavrilov has quit [Remote host closed the connection]
Murii has quit [Quit: WeeChat 1.4]
smasta has joined #lisp
vap1 has joined #lisp
vaporatorius has joined #lisp
<jasom>
If I do a setf of a slot of a standard-object, is a concurrent read guaranteed to return either the previous or new value?
<Shinmera>
I think you'll find the standard says nothing about concurrency, so the answer will be implementation (and possibly version) dependent.
<jackdaniel>
clos doesn't say anything about concurency, because it's not part of cl
fikka has joined #lisp
<jackdaniel>
in case of structure references it is possible to do a cas operation
<jasom>
same question, for: sbcl, ecl, ccl
* jasom
doesn't need CAS, just safe concurrent access
<Bike>
well... on sbcl, slots are casable, at least
<jackdaniel>
I would be suprised if any of them gives such guarantees
<jackdaniel>
without explicit atomic operations
<jasom>
so no sharing data without locks, period?
<aeth>
I always just use bt:with-lock-held
<jasom>
that seems ... unusual
<jackdaniel>
on ccl only structure references are casable (class slots are not, and mechanism is not extensible)
kobain has joined #lisp
<jackdaniel>
ecl doesn't have atomic operations interface exposed at all at time being (though underneath some operations use atomicity)
<Shinmera>
Also, if you have a custom metaclass it's probably gonna go through slot-value-using-class, in which case it is most definitely not going to be atomic (and could end up being whatever value that method deems appropriate).
Karl_Dscc has quit [Remote host closed the connection]
<jackdaniel>
but ECL has rwlocks, which are more efficient if you do frequent reads and rare writes
<Bike>
oh, yes, i was assuming standard instance ness was implied
sebastien_ is now known as svillemot
jmercouris has quit [Ping timeout: 276 seconds]
<jasom>
so (setf (slot-value foo 'bar) 1) (bt:make-thread (lambda () (setf (slot-value foo 'bar) 2))) (slot-value foo 'bar) could yield some value other than 1 or 2?
<Bike>
and not having s-v-u-c methods and so on
<jasom>
to be clear, I'm not asking for any ordering whatsoever, just that reading a shared slot value will never return any value that was never written to it.
<jackdaniel>
hm, in this particular example it wil lbe either 1 or 2, sure
<Bike>
I would expect it to be one or the other, but I don't know of an implementation specifically guaranteeing so.
<Shinmera>
I don't think any implementation has slots that are bigger than a word in memory, so yeah.
<jackdaniel>
but if you have two concurrent threads doing incf 100 times you have no guarantee, that result will be 200 higher
<jasom>
jackdaniel: naturally
<jackdaniel>
unless you use atomic-incf or other cas op
<Bike>
yeah, i think jasom is just worried about the possibility of getting some corrupted result.
<jackdaniel>
(I think such things usually lead to a corrupted result, this example is just a simple illustration)
<jackdaniel>
either way, I've got to go, good night! :)
<jasom>
I suspect a corrupted result could occur if the class itself were being modified, but not a slot of an instance of a class
<Shinmera>
If the class is redefined then yes slot accesses are invalid for a short amount of time in SBCL
<Shinmera>
I know so because redefining stuff while my game is running at 60fps often triggers an error about slot access.
smurfrobot has joined #lisp
<aeth>
I solve that by copying, which isn't entirely ideal because that gets rid of a lot of the live coding aspect that people enjoy.
<aeth>
(higher order functions will still work if they're 'foo and not #'foo)
python476 has quit [Ping timeout: 240 seconds]
smurfrobot has quit [Ping timeout: 240 seconds]
fikka has quit [Ping timeout: 260 seconds]
makomo_ has joined #lisp
makomo has quit [Ping timeout: 256 seconds]
vap1 has quit [Quit: Leaving]
knicklux has quit [Quit: Leaving]
vtomole has quit [Ping timeout: 260 seconds]
fikka has joined #lisp
borei has joined #lisp
<borei>
hi all !
smurfrobot has joined #lisp
z3t0 has joined #lisp
smurfrobot has quit [Ping timeout: 240 seconds]
mishoo has quit [Ping timeout: 276 seconds]
vlatkoB has quit [Remote host closed the connection]
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
earl-ducaine has joined #lisp
quazimodo has quit [Ping timeout: 240 seconds]
s1detracking has quit [Remote host closed the connection]
s1detracking has joined #lisp
<k-hos>
does common lisp or sbcl in particular make any guarantees about bit size for integers?
<Shinmera>
integers are unbounded.
<k-hos>
is there a type that isn't
<stacksmith>
fixnum
<Shinmera>
Infinitely many.
<aeth>
integers are unbounded, but integers are fixnums and bignums. fixnums are bounded.
<stacksmith>
or any type you define so
<aeth>
Additionally, you can restrict the integer size like (unsigned-byte 32)
<k-hos>
ok
<Shinmera>
Or (integer 0 1) or (integer 0 123) or (integer 3 321) or ...
<aeth>
ub32 may or may not work. It will almost certainly work in 64-bit Lisps, and might work in 32-bit Lisps, if you work around some limitations.
<aeth>
And, yes, you can also set arbitrary ranges with (integer 0 1) (integer 3) (mod 360) etc.
<aeth>
And, of course, there are signed-bytes.
lucasb has quit [Quit: leaving]
<aeth>
The primary advantage of rounding to something like (unsigned-byte 32) is that it will (probably) be supported in specialized arrays (everything except bit and character are implementation-specific, but single-float, double-float and (unsigned-byte 8) are nearly universally supported)
varjag has quit [Quit: ERC (IRC client for Emacs 25.2.1)]
antgreen has quit [Ping timeout: 256 seconds]
<k-hos>
are specialized arrays different than 'simple arrays' made with make-array?
whoman has quit [Ping timeout: 256 seconds]
<Shinmera>
Note that "simple-array" means something very specific.
<aeth>
they're simple-arrays that can only hold one type, which has potential advantages in allocating the array, and it tells the implementation that if you access an element it has to be of that type (so it helps type inference)
<Shinmera>
Whether it's contiguous or not is not specified.
<aeth>
e.g. (make-array 3 :element-type '(unsigned-byte 32) :initial-element 0) or (make-array 3 :element-type 'single-float :initial-element 0f0)
<aeth>
Both those are unspecified, but very likely to be supported.
<Shinmera>
But it doesn't matter anyway because you don't get direct memory access.
<aeth>
The most likely implementation-specific one is probably (unsigned-byte 8)
<earl-ducaine>
k-hos: To some extent it depends on what you mean by 'bit size' Do you mean the underlying representation or do you how a CL integer is seen by other non-cl components, e.g. when exported through cffi.
<k-hos>
I was going to do some bit manipulation on them in lisp
<aeth>
The underlying representation when a fixnum is *probably* a signed byte with one or more leading bits reserved (SBCL reserves one, so fixnum is (signed-byte 63))
<aeth>
But implementations can probably optimize more.
<earl-ducaine>
In particular cffi provide a portability layer for exporting CL data in exactly the format you want, including integer representation.
attila_lendvai has quit [Quit: Leaving.]
<k-hos>
hmm
<Shinmera>
You can do bit twiddling on any integer.
<aeth>
But it probably won't be efficient unless the compiler knows it's a fixnum (it could still be efficient if it's slightly larger than a fixnum in some restricted circumstances, though)
<Shinmera>
Not everything needs to be efficient.
smurfrobot has joined #lisp
<k-hos>
it's generally something you want when making games :p
<Shinmera>
I've been doing just fine doing things inefficiently.
<Shinmera>
Premature optimisation fanaticism is especially bad in gamedev is my opinion.
Bike has quit [Ping timeout: 260 seconds]
<aeth>
Shinmera: of course not everything needs to be efficient
<aeth>
Some optimizations are easier than others, though.
smurfrobot has quit [Ping timeout: 260 seconds]
<earl-ducaine>
k-hos: CL's primary mechanism for making numerical computations fast is through the declare mechanism. The way that that works was somewhat counter intuative for me....
<aeth>
And it's nice to be aware of some potentially easy optimizations (although with integers it is often tricky to keep them fixnum)
<aeth>
Being aware of the fast route doesn't mean always do the fast route.
<earl-ducaine>
Basically CL doesn't make the promises, the programmer does. In particular to keep integers within a certain range.
<k-hos>
people like to confuse good design as being optimization
<earl-ducaine>
By making that declaration, the compiler is then, theoretically free, to make certain optimizations based on that.
<aeth>
Imo sometimes hard premature optimizations are actually the right thing to do, like in game engine architectures where rewriting things will require rewriting half (or more!) of the engine if you suddenly need to do it in a fast(ish) way later on.
GuilOooo has quit [Ping timeout: 240 seconds]
<aeth>
Usually that can be avoided by modularizing things heavily. It doesn't take a lot of work to optimize later if you can do that. Unfortunately, it doesn't always seem to work with a game engine.
<aeth>
Imo, the core of your game engine runtime probably needs to be 'prematurely optimized' or it will never be optimized because rewriting it means essentially rewriting the entire game engine runtime. This is a very special case, though. Usually, ignoring optimizations early on is the right thing.
z3t0 has quit [Remote host closed the connection]
<aeth>
(Feel free to be as lazy a programmer as possible outside of your game loop as long as you keep it modular so tiny components can be rewritten if needed.)
z3t0 has joined #lisp
quazimodo has joined #lisp
<White_Flame>
modularization can slow down you runtime, too, if things can be done faster by the code doing more at once, instead of keeping functionality separate
<White_Flame>
however, with CL you can mash code at compile-time to interact how you want, if you want to put the work in
<aeth>
White_Flame: That's one of the problems with trying to engineer a game loop. The modules will probably need to be rewritten when it's time to optimize even if you did separate things into nice, clean modules.
<aeth>
White_Flame: I do agree, though. Try to do as much outside of the game loop as possible, and ideally as much at compile time as possible.
shrdlu68 has joined #lisp
<aeth>
My latest approach is essentially: The game loop is going to be a coupled mess that needs to be prematurely optimized... so try to contain that and do as much outside of it as possible.
z3t0 has quit [Ping timeout: 268 seconds]
blackwolf has quit [Remote host closed the connection]
shrdlu68 has quit [Ping timeout: 248 seconds]
Lycurgus has quit [Ping timeout: 268 seconds]
Fade has quit [Ping timeout: 256 seconds]
quazimodo has quit [Ping timeout: 255 seconds]
sjl has joined #lisp
wxie has quit [Ping timeout: 260 seconds]
<stacksmith>
Is there a format directive that prints keywords with a colon, but does not quote strings?
shifty has joined #lisp
al-damiri has quit [Quit: Connection closed for inactivity]
rumbler31 has quit [Remote host closed the connection]
Bike has joined #lisp
fisxoj has quit [Quit: fisxoj]
nirved has quit [Quit: Leaving]
kundry_wag has joined #lisp
Kaisyu has joined #lisp
orivej has quit [Ping timeout: 248 seconds]
kundry_wag has quit [Remote host closed the connection]
wxie has joined #lisp
Fade has joined #lisp
z3t0 has joined #lisp
peterhil has quit [Quit: Must not waste too much time here...]
kundry_wag has joined #lisp
peterhil has joined #lisp
moei has quit [Quit: Leaving...]
wxie has quit [Ping timeout: 240 seconds]
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
kundry_wag has quit [Ping timeout: 248 seconds]
knobo1 has quit [Ping timeout: 256 seconds]
smurfrobot has joined #lisp
smurfrobot has quit [Remote host closed the connection]
dieggsy has quit [Remote host closed the connection]
sjl__ has joined #lisp
White_Flame has quit [Remote host closed the connection]
sjl has quit [Ping timeout: 240 seconds]
White_Flame has joined #lisp
z3t0 has quit [Remote host closed the connection]
z3t0 has joined #lisp
z3t0_ has joined #lisp
z3t0 has quit [Read error: Connection reset by peer]
eug_venalainen has joined #lisp
DeadTrickster_ has joined #lisp
eug_venalainen has left #lisp [#lisp]
fisxoj has joined #lisp
DeadTrickster has quit [Ping timeout: 260 seconds]