judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
cosimone has quit [Ping timeout: 246 seconds]
Nilby has joined #lisp
florian_ has quit [Ping timeout: 272 seconds]
Jesin has quit [Ping timeout: 240 seconds]
dhil has quit [Ping timeout: 260 seconds]
judson_ has joined #lisp
flazh has joined #lisp
FreeBirdLjj has joined #lisp
skapata has quit [Remote host closed the connection]
flazh has quit [Client Quit]
<mfiano>
I vaguely recall something about lambda's not being compiled. Is this correct?
yitzi has quit [Quit: yitzi]
amb007 has joined #lisp
lucasb has quit [Quit: Connection closed for inactivity]
<no-defun-allowed>
I don't think that's true.
<no-defun-allowed>
When you compile a function, the functions inside it are also compiled.
flazh has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
<lotuseater>
ah now i remember a question i have: if i use LABELS instead of FLET for closures that are not recursive and do not use each other, is this less efficient?
<mfiano>
Ok, thanks. I wonder what I'm thinking of
<mfiano>
That depends on the compiler. There is nothing in Common Lisp that makes it so
<moon-child>
mfiano: (disassemble (lambda (x y) (+ x y))) works fine and gives reasonable output for me
abel-abel has joined #lisp
<no-defun-allowed>
lotuseater: Probably not.
Rengan has joined #lisp
Rengan has left #lisp [#lisp]
Rengan has joined #lisp
fc2020apt[m] has joined #lisp
<jrm>
I asked about this recently, but am still struggling to find a solution. I'm building an OS package using (asdf:oos 'asdf:compile-op :stumpwm :force t), but if the stumpwm package is already install, the fasl files won't be generated in the stage directory and the package build fails. I figured out that if the stumpwm lisp package isn't loaded, then the fasl files will be unconditionally loaded, but that difficult to ensure and causes
<jrm>
other problems.
abhixec has quit [Ping timeout: 272 seconds]
<jrm>
Is there a way to ensure that the fasl files are always built, even if the stumpwm lisp package is loaded?
nowhere_man has quit [Ping timeout: 272 seconds]
<jrm>
If there is a better place to ask this type of question, suggestions would be welcome.
abhixec has joined #lisp
<fc2020apt[m]>
test. i may ask more detailed questions later as soon as i feel ready to start programming, but i've been recommended to learn lisp. i don't know why but it looks far simpler than like C and i'm losing motivation to program these days
<Xach>
jrm: i don't know the answer to your issue - i wonder if there is something stumpwm does specifically relating to how it compiles.
<Xach>
jrm: so maybe a stumpwm forum or list could help. i don't know where that is, though.
skapata has joined #lisp
abel-abel has quit [Ping timeout: 272 seconds]
abel-abe_ has joined #lisp
orivej_ has joined #lisp
<jrm>
Xach: Cheers. I'm building things a little differently than stumpwm proper does. They generate a 60MB bundle instead of the fasl files. But after two days of messing around, I think I just now realize what's going on. The fasl files are indeed being regenerated, but they are placed in a different location depending on whether stumpwm is loaded.
<jrm>
So maybe something with ASDF_OUTPUT_TRANSLATIONS ?
orivej has quit [Ping timeout: 265 seconds]
sm2n has quit [Read error: Connection reset by peer]
sm2n has joined #lisp
notzmv has quit [Remote host closed the connection]
anticrisis has joined #lisp
random-nick has quit [Ping timeout: 256 seconds]
notzmv has joined #lisp
dbotton has joined #lisp
orivej_ has quit [Ping timeout: 260 seconds]
orivej has joined #lisp
abel-abe_ has quit []
EvW has quit [Ping timeout: 264 seconds]
ljavorsk has quit [Ping timeout: 240 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
quazimodo has quit [Ping timeout: 256 seconds]
wxie has joined #lisp
EvW has joined #lisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life has joined #lisp
rumbler31 has quit [Remote host closed the connection]
EvW has quit [Ping timeout: 272 seconds]
judson_ has joined #lisp
orivej has quit [Ping timeout: 265 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
rumbler31 has joined #lisp
orivej has joined #lisp
rumbler31 has quit [Ping timeout: 246 seconds]
karayan has quit [Ping timeout: 260 seconds]
karayan has joined #lisp
* Xach
got the octree quantizer working and has written his first gif from a colorful vecto image!
<Nilby>
Nice. octrees are cool
* Xach
makes a quick animation
Jesin has joined #lisp
dbotton has quit [Quit: This computer has gone to sleep]
<Nilby>
It even works in my viewer. But I'm wondering if I could cut out the gif and just run your animation in real time.
<Xach>
I had something similar long ago, but because I didn't have any ideas about how to quantize the color palette of a PNG, I stuck to grayscale, which is a little boring.
<Nilby>
As you probably know, if you do some hideous tiling thing you can get true color in gifs.
akoana has quit [Quit: leaving]
<jrm>
asdf output translation are not for the faint of heart. Searching shows lots of confusion.
<Xach>
Nilby: right now my 2d drawing stuff is very graphics-file oriented, so it is not so easy to adapt to direct display. I hope to change that in the future.
<Xach>
Visualizing animations by roundtripping through GIF is inefficient
<Xach>
Anyway, I have started following some cool geometric gif artists and they have inspired me to try to make some myself, and of course I want to use my CL libraries to do it.
Stanley00 has joined #lisp
<Nilby>
I have a collection of awesome geometric gif art, which is partially why I wrote a gif viewer. My favorite ones can give you some kind of math intuitions.
semz has joined #lisp
semz has joined #lisp
mbomba1 has joined #lisp
mbomba has quit [Ping timeout: 240 seconds]
zulu-inuoe has quit [Read error: Connection reset by peer]
urek has quit [Ping timeout: 272 seconds]
gloriamdeo[m] is now known as solideogloria[m]
kagevf has quit [Ping timeout: 272 seconds]
kagevf has joined #lisp
<lotuseater>
how is the situation of void safety (aka null-pointer dereferencing) in CL?
shifty has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 264 seconds]
karayan has quit [Read error: Connection reset by peer]
karlosz has joined #lisp
karayan has joined #lisp
rumbler31 has joined #lisp
rumbler31 has quit [Ping timeout: 240 seconds]
Jeanne-Kamikaze has quit [Quit: Leaving]
Josh_2 has quit [Ping timeout: 240 seconds]
aindilis has quit [Remote host closed the connection]
karayan has quit [Remote host closed the connection]
karayan has joined #lisp
Rengan has quit [Quit: Leaving]
karayan has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
You can't make arbitrary pointers without CFFI or unsafe code, so quite good.
karayan has joined #lisp
<lotuseater>
yeah :)
Aurora_v_kosmose has quit [Ping timeout: 240 seconds]
Aurora_v_kosmose has joined #lisp
<fe[nl]ix>
lotuseater: code compiled with SAFETY 0 can go awry and corrupt the image
<lotuseater>
yes safety is for some serious stuff much more important than perfomance
<lotuseater>
i read on the Eiffel website and it states: "Eiffel is the only modern, widely available programming language that has solved null pointer dereferencing once and for all."
<fe[nl]ix>
its author is not very honest
<lotuseater>
but i think one can have very safe, elegant AND performant programs with CL or Haskell, Rust, Ada. or fault tolerant with built in to the language, see Erlang
aaaaaa has joined #lisp
mbomba1 has quit [Quit: WeeChat 3.0]
aartaka has joined #lisp
<moon-child>
I mean, bascially all ml dialects are safe, performant, and lead to robust code. Haskell, rust, ocaml, sml, f#, ats...
mbomba has joined #lisp
<davros>
are you calling rust an ML dialect
<moon-child>
all of rust's good ideas come from ocaml
<davros>
it is a little ML inspired isn't it , but i woulnd't go that far
<davros>
i gather the first rust compiler was written in ML ? (or ocaml? not sure of the difference)
<moon-child>
rust isn't a great language, but the influence is definitely there. And yeah before bootstrap their compiler was in ocaml
<davros>
depends on goals.. i think rust is amazing (as a c++ replacement)
<davros>
i place a big dividing line between "things that can replace C++ in it's nichces , i.e. no runtime GC etc" and everything else
<moon-child>
sure. Rust is an acceptable implementation of c++. The question is, when do you need a c++ replacement?
<davros>
most people dont need it, thats true - but certain niches remain for it IMO
<davros>
embeded, gamedev , probably more
<no-defun-allowed>
"We believe that it is the case that common SML idioms tend to work better under GC than under regions." - http://www.mlton.org/Regions
<moon-child>
davros: gamedev can work around gc (or use rc) and frequently wants regions explicit regions anyway. Embedded you don't need the complexity - c is fine
<no-defun-allowed>
Standard ML also has exceptions.
Alfr_ has joined #lisp
<davros>
i've heard the claim that gamedev *could* use gc, but all the engine people gravitate back toward c++
<oni-on-ion>
depends indie vs. triple-A
<davros>
"the big resources are static" "there isn't much tracing for the GC"
<davros>
yeah indie i can well imagine getting by
<no-defun-allowed>
If you don't allocate, then there is indeed nothing to GC.
<moon-child>
unity is the most popular game engine out there
<davros>
and of course GC didn't stop minecraft entertaining everyone
<oni-on-ion>
AAA are generally in competition, like hollywood or youtube
<lotuseater>
what about unreal?
<no-defun-allowed>
GC pauses are only mildly annoying while playing Minecraft, and I obliterated those by using an incremental collector.
<moon-child>
and, high-quality concurrent GCs are fairly new. But as of just a couple of years ago, java (and all jvm languages) have a GC with heapsize-independent pause times <1ms
<oni-on-ion>
no-defun-allowed, did you let the devs know that
<lotuseater>
and in unity you have to see sharp *urgs*
<no-defun-allowed>
oni-on-ion: I have not, but I feel it would be common knowledge to "just use ZGC"
<moon-child>
but anyway, reference counting is an acceptable form of GC which the c++ engines do frequently use
<no-defun-allowed>
Or Shenandoah cause ZGC crashes on my Raspberry Pi; but there the main cause of lag is world generation.
<oni-on-ion>
yay RC =)
quazimodo has joined #lisp
<davros>
just wondering if i should mess with an embedded lisp in a little engine i'm writing now
<oni-on-ion>
what Pi do you have ndf?
Alfr has quit [Ping timeout: 260 seconds]
<moon-child>
davros: do it!
<no-defun-allowed>
A Raspberry Pi 4 with 4GB of memory.
<moon-child>
my engine is in d, but embeds a little scheme. It's been really nice
<davros>
its a recurring itch
<oni-on-ion>
noices
<davros>
not entirely sure what i even need an embedded language for lo
<davros>
lol
<oni-on-ion>
many or most of us seem to doing lil embedded lisps
<no-defun-allowed>
davros: You could use the Boehm collector if you are embedding in C. It has an incremental mode, and I think Unity uses that.
<davros>
enemies that rewrite their own code
<no-defun-allowed>
At one point, I wanted a simple language for an AI that I could use "worlds" with, so I could do state space search with imperative code, but still roll back the state after I evaluated it.
<beach>
Good morning everyone!
<moon-child>
beach: morning
<davros>
i kind of liked the idea that simple lisp syntax could be parsed in and out of art tools maybe (you kwow all the flowchart type tools designers use for gamelogic)
<no-defun-allowed>
Good morning beach!
<oni-on-ion>
hmm. gm beach
<davros>
the other lispy itch i have is lisp for procedural generation
<edgar-rft>
let's make gmb the official good-morning-beach acronym
<oni-on-ion>
davros, yeah and shaders, geometry definition, and also AI as said. s-exp is great format for many purpose. even OCaml has most tools using it --- also it and haskell's type system are strong enough to use that 100% when read()'ing for a powerful enough language for most things. (ive examples)
<davros>
the most lisp i've ever written is... elisp
<no-defun-allowed>
Ungar declared generational garbage collection to be superior to reference counting back in 1984, but I guess a Smalltalk system has softer constraints than a video game.
<banjomet>
We showthat, at large heap sizes and under no memory pressure, the runtimeperformance of some garbage collection algorithms is competitivewith the Lea memory allocator and occasionallyoutperformsit byup to 4%. However, our results confirmthat garbage collection re-quires six times the physical memory to achieve this performanceand suffers order-of-magnitude performance penalties when pagingoccurs
<no-defun-allowed>
I like how TeX papers screw up the spaces.
<oni-on-ion>
in haskell engine years ago, all stuff defined in s-exp format directly by haskell read() and show(), no need to parse or check or anything. them type systems be powerful
<moon-child>
emery berger is great. Does lots of really cool research
<davros>
i can imagine a GC being superior to refcounting, but isn't there something like refcounting being more predictable (hence apple's choice)
<oni-on-ion>
im doing refcount for my toy embedded lisp
<davros>
ultimately for engine type coding i'm happy with the C++/rust idea of stack+single-ownership + refcounting as a last resort , to be minimized
<no-defun-allowed>
But I would ask what performance drop you get for GCing with a smaller heap. Suppose performance/heap has exponential decay, then you might only see a 5% performance decrease with 2x instead of 6x or something like that.
<oni-on-ion>
done a bunch in obj-c and smalltalk , never a problem. managing memory and data structure are very underrated for good programs and delicious code
<davros>
the claim i hear r.e. refcounting and games is "the GC'd bits would be a small amount of memory.. the majority of memory is graphcis, out of reach of the GC"
<moon-child>
davros: the main advantage of reference counting is that you can elide the rc through optimizations in a lot of cases. Meaning, very close performance to single-owner
<oni-on-ion>
nda i still feel that a tree of heaps/pools is a possible solution. rather than global GC.
<davros>
anyway i see a big dividing line in languages between these two cases
<no-defun-allowed>
Empirically, I have only seen up to 10% GC time with sane heap sizes.
<davros>
for *most* programming.. GC is fine, i accept that
<moon-child>
oni-on-ion: *tree* of pools is what talloc does, and it's very bad for performance. But pools are great
<banjomet>
totally unrelated, but I remember reading about this library and not being able to stop fantasizing about using it: https://github.com/cosmos72/stmx
<oni-on-ion>
setting limits and availability to predict storage+lifetimes, goes a long way. especially for [soft] real time. allowing everything is where we start looking to magical GC-everything solutions. like windows defragmentor lmao
<davros>
ive done gamedev on older consoles with fixed memory layouts (not even malloc/free -just level stack allocator + custom pools for entities)
<no-defun-allowed>
I wrote something about "for _most_ programming ..." and how "most" is an understatement, but I am not going to repeat that here.
<banjomet>
but sadly tsx in an intel cpu is never available for a laptop, and only in the few high end desktop cpus
<oni-on-ion>
Ultimate Solutions are really only applicable to Ultimate Problems.
quazimodo has quit [Read error: Connection reset by peer]
<mfiano>
Game development in CL is difficult for other reasons, not GC.
<oni-on-ion>
like if i just scroll reddit for 10 minutes, no account or anything fancy, just regular website: it starts eating swap like its gone mad. hooray GC !! So Solutiony
<moon-child>
that's not gc, that's a shitty website
<moon-child>
old.reddit.com is nice tho
<lotuseater>
banjomet: yes Software Transactional Memory is a good idea for some things to do safe and reasonable concurrency :)
<davros>
hmm maybe i cuold sneak in a lispy thing for my particle definitions as a starting point
<oni-on-ion>
moon-child, other websites do about the same, but after 30m-1hr. reddit is just doing a lot more so its more noticeable
<no-defun-allowed>
Well, just throw Boehm at all your interpreter allocations, and see if it's a problem. I bet it won't be.
matta has joined #lisp
<mfiano>
Cache coherency is an issue with "real" games in Common Lisp. For small-scale indie games, you don't need to worry about it though.
<davros>
right if you're using linklists all over the place.. lisp can do arrays aswell thought can't it?
<no-defun-allowed>
If I may mess with everyone's minds for a minute, I remember reading about a GC which did very low overhead profiling of which objects pointed to which, and then used that to move those objects closer to each other.
<mfiano>
It's hard to avoid CLOS or otherwise pointer indirection in CL. upgraded-array-element-type is and other things don't help either.
<mfiano>
Not to mention that game development is inherently filled with all sorts of tree data structures, and everyone knows trees are a quick way to ruin cache coherency
<moon-child>
no-defun-allowed: interesting! Sounds like a variant of compacting gc
<beach>
no-defun-allowed: Most copying collectors do that.
<no-defun-allowed>
See ftp://ftp.cs.wisc.edu/wwt/ismm98_cache_gc.pdf
<beach>
Oh, based on run-time?
<beach>
I hadn't seen that.
<no-defun-allowed>
beach: Do they do some profiling at runtime?
<beach>
I shouldn't intervene before I had my morning coffee.
<no-defun-allowed>
Yes, this one does runtime profiling. I think depth-first copying has been done at least on Genera and some proprietary implementation I forgot the name of (Franz?)
<davros>
banjomet, its hard to map *existing* gui APIs to rust. but you can design a GUI within its trait-object idea
aaaaaa has left #lisp [#lisp]
<banjomet>
davros: that is a fair point. But I also remember reading about the difficulties the conrod guy had, but my google-fu is weak tonight
<fe[nl]ix>
there are lots of ideas in GC literature that haven't been implemented because of industry dynamics
<moon-child>
banjomet: I didn't have any trouble making a gui in c. As long as you can do basic runtime polymorphism (single dynamic dispatch), you should be fine
<davros>
some things gui api's tend to do with inheritance you can do by composing traits using generics , i've found. it's definitely "different", but doable
<fe[nl]ix>
like game companies relying on existing game engines and never making their own stack from scratch
<no-defun-allowed>
The paper compares the design to the Wilson-Lam-Moher algorithm, which tries to keep objects on the same pages.
<beach>
I agree with fe[nl]ix. I think the debate is over. GC, if done right, is always more efficient than manual memory management and reference counters.
<fe[nl]ix>
few can afford to write their own language to implement the game in
<lotuseater>
fe[nl]ix: i thought some do like ID or CD Project Red
<banjomet>
the main reason games disappoint me after the 360 era is that they went for 'high-resolution' everything. I would much rather prefer collision-based dynamic animations and destructible environments/vehicles.
<moon-child>
fe[nl]ix: naughty dog did, though; Goal Oriented Action Lisp was neat
<fe[nl]ix>
I said "few"
<fe[nl]ix>
not "nobody"
<davros>
heh yeah its even hard to get Rust into commercial gamedev because of reliance on established C++ engines.
<no-defun-allowed>
The program runs 6% slower because of profiling overhead, but the improved cache usage improves performance by around 15-35%.
<oni-on-ion>
i am morally against auto GC for soft real time
<beach>
no-defun-allowed: So I have read about "data-oriented programming", and what you are describing seems to be the automatic version of that idea.
<beach>
oni-on-ion: Why?
<fe[nl]ix>
beach: there's a solid consensus among GC implementors that if you can statically determine allocation patterns, then manual management outperforms GCs
<no-defun-allowed>
I agree with beach and fe[nl]ix, but I will also (possibly redundantly) add that most language implementations with garbage collection usually are pretty acceptable by default.
<moon-child>
davros: right you are; I was mixing up with Goal Oriented Action Planning
<lotuseater>
moon-child: yes but be interesting to see the source
<beach>
fe[nl]ix: I can believe that. But that's a big "if".
<banjomet>
do you guys know any languages that support incremental compilation?
<fe[nl]ix>
but that's quite hard, which is why as the complexity of a C++ program increases, it asymptotically needs a GC
<davros>
oh i do remember ABUSE now you mention it
<no-defun-allowed>
beach: I've heard of that too, but it was because someone tried to tell me that I wasn't making good use of cache in cl-decentralise2, so I said, "Well, I never wanted to do different things with different objects anyway."
<mfiano>
Yes, and Naughty Dog no longer even uses Lisp, except Scheme for scripting. It was part of their Sony contract to aid sharing resources with their other studios
<oni-on-ion>
beach, i was mentioning about how global-auto-GC being basically unsolved, cannot truly be done, because the number of possible configurations and strategies are endless
hendursaga has joined #lisp
<fe[nl]ix>
mfiano: cutting costs is another facet of the "industry problem"
<no-defun-allowed>
banjomet: Common Lisp, Smalltalk, Self, Erlang at least do incremental compilation (and replacement of classes and code) well.
<oni-on-ion>
beach, in that there is no magical "just use Flex Tape on it all!"
<davros>
do people in this room mostly use CL or Scheme or what
<lotuseater>
oni-on-ion: thx i add ABUSE to my list of points if someone annoys me the next time with the question how parentheses can be useful for anything
<oni-on-ion>
lotuseater, nice =)
<no-defun-allowed>
Liveness is a global property (if I want to write modular code, I shouldn't assume how the client will use my objects) and undecidable anyway.
<banjomet>
no-defun-allowed: really? I did not know that.
<beach>
davros: This channel is dedicated to Common Lisp.
<no-defun-allowed>
davros: Due to historical stuff, #lisp is about Common Lisp, so most people here use that.
<oni-on-ion>
also if it indirectly counts: N64 games especially Mario 64, used SGI machines of course. but the software 'Mirai' from Nendo was done in Common Lisp. i think someone told me that was from ancient lisp graphics heritage.
<lotuseater>
oni-on-ion: But I have the feeling most people don't listen anyway. So be it.
<davros>
does anyone here use CL as their main go-to language (i mean language they go to mostly, not language with go-to statements lol)
<beach>
davros: I would think most of us.
<davros>
and does anyone try to recreate or design real LISP machines on FPGA :)
<moon-child>
davros: I don't think I have a go-to language, but cl is definitely up there
<lotuseater>
I recognized Mirai as a Blender like tool
<no-defun-allowed>
banjomet: There is a larger set of languages that will allow you to replace code and class definitions at least, including Python and Java, but they don't update instances like the list I provided. And there is another set that wants to redefine "incremental compilation" to be compiling modules with per-file granularity...
<beach>
davros: There is no real point. You will lose an order of magnitude in performance compared to stock hardware, and Common Lisp runs fine on such hardware today.
<fe[nl]ix>
beach: are you on the pro@common-lisp.net mailing list ?
<davros>
what compiler backends to lisps have these days
<no-defun-allowed>
davros: The causes of the "death" of Lisp machines are still present...as beach said. But I will consider designing a processor which would arguably be "specialised" to my programs and uses, most of which involve Lisp.
<lotuseater>
davros: yes i found something for that and also had the idea it will be a good thing. would do it myself but I've not enough knowledge about the hole thing
<beach>
fe[nl]ix: I am, but I don't usually read it.
<oni-on-ion>
lotuseater, not when they are busy trying to get other people to listen to them or making a point for themselves. "Whenever i use my own words, no one else understands me" =)
<fe[nl]ix>
beach: I'd love to implement a modern GC for SBCL but I can't find funding
<no-defun-allowed>
If there are store barriers already, would it hurt that much to use generational scavenging?
<fe[nl]ix>
we're talking about at least one year of work if not more
<beach>
fe[nl]ix: I have a design for SICL, but it has not been tested yet.
<beach>
fe[nl]ix: But it is probably not applicable to SBCL because it relies on the layout of SICL objects.
<no-defun-allowed>
I'm bored with my incremental conservative collector, and I want to revise it to use two generations. It would basically be the Liebermann-Hewitt incremental generational copying collector, but with replication copying, and with my own modifications to allow for pinning.
<fe[nl]ix>
no-defun-allowed: I'm not sure what you mean by "hurt". the newer GCs are not generational, although some work modes can approximate a generational GC
shifty has joined #lisp
<fe[nl]ix>
no-defun-allowed: what do you work on ?
<oni-on-ion>
nda what are you actually making
<beach>
Wow, an IRC client without completion!
<no-defun-allowed>
fe[nl]ix: Sorry, I meant if it would decrease throughput to implement the requisite write barrier for tenured->nursery pointers, when there already is a write barrier apparently.
<fe[nl]ix>
beach: plugging in the layout should be relatively easy
<no-defun-allowed>
Do I get to make a joke about non-disclosure agreements now?
<beach>
fe[nl]ix: Yes, but SBCL maintainers would not accept the SICL layout.
<pfdietz>
I remember when stock hardware caught up with Lisp Machines. The LMs evaporated pretty quickly. I think Lucid had something to do with closing the gap.
<davros>
is it "eval" or something where a lisp program can invoke a jit to run code it generates itself
<mfiano>
I read that pro thread the other day, and have used Julia quite a bit. It tries too much to be like CL in my opinion, but completely struck out on packages.
<no-defun-allowed>
EVAL may or may not compile. COMPILE will compile.
<pfdietz>
There was a while after that when commercial lisps on stock hardware were a thing, but then they fell as well.
<mfiano>
packages in julia do not have identity. You can reload a file and have a completely distinct version of the package defined in your "image", making repl testing really confusing.
<fe[nl]ix>
these new GCs have a 15-20% throughput overhead
<no-defun-allowed>
fe[nl]ix: However, a generational collector should not scan as much, so could that reduce the overhead?
<fe[nl]ix>
the generational hypothesis does not hold very well
<oni-on-ion>
everything eventually goes toward General Purpose. GPU soon will mean just that eh =)
narimiran has joined #lisp
<fe[nl]ix>
the nemesis of the generational hypothesis is the LRU cache
<oni-on-ion>
specialization however is left in the dust
<fe[nl]ix>
and LRU caches are very typical on backend servers
<no-defun-allowed>
A good point.
<oni-on-ion>
mfiano, afaik something to do with types. so a new function is created for add(Int32, Int32) when used that way
<davros>
heh yeah thats the other question , are people running lisp code on GPUs (generating compute kernels, cuda equivalent)
<mfiano>
Why two packages of the same name in Julia are two distinct symbol tables is beyond me, and makes having a REPL completely useless to me.
<no-defun-allowed>
But you don't mutate the values stored in cache, so they shouldn't pose a problem for a generational collector? Maybe if you swap out values quickly, it becomes a problem as you don't perform major collections as often.
<mfiano>
You can't live recompile a function without creating a duplicate package...
<oni-on-ion>
mfiano, what version ? afaik reloading packages were fine for me. the REPL was impressive, about on level with OCaml's utop
<no-defun-allowed>
davros: There are a few packages for generating GPU code, but there's no way you'll be doing list processing on a GPU.
<mfiano>
Well I have been using it for about 5 years, and things have not gotten better since about 3 months ago was the last I used it.
<fe[nl]ix>
no-defun-allowed: old discarded objects pose a problem because they only get scavenged in a full GC
<mfiano>
CL is my goto in practically all my coding. I do use Julia for some of its math libraries to compare against my CL code though.
<no-defun-allowed>
Right.
<fe[nl]ix>
which means your memory usage balloons
<fe[nl]ix>
increasing pauses because a full GC scans the entire heap, etc...
<oni-on-ion>
mfiano, hmm. there must be a better way to do that, especially REPL for julia because there is still no clean/smart way to build binaries
<no-defun-allowed>
fe[nl]ix: But surely you aren't replacing cache values that frequently. Or maybe you are, I dunno.
<mfiano>
I'm not complaining, really. CL is all I will ever need. It's just ausing how languages have been borrowing and crippling CL features for years.
<oni-on-ion>
why can't i (defstruct A (defstruct A_x ...) (defstruct A_y ...)) ?
<davros>
anyone use CLOS multiple dispatch here?
<fe[nl]ix>
no-defun-allowed: it's not uncommon for backend software to have a fixed cache in the order of X million objects which should account to e.g. 70G of RAM
<oni-on-ion>
^
<no-defun-allowed>
Yes and yes. I use multiple dispatch fairly frequently, and I do have a caching-mixin that lets me pick some cache size.
<oni-on-ion>
predictable software vs. general purpose anything-can-happen-need-magic-garbage
galex-713 has joined #lisp
<fe[nl]ix>
but if that causes an additional 20-30G of unreachable but not collected objects to stick around
<fe[nl]ix>
your server starts runnning out of RAM quickly
<oni-on-ion>
once a binary is made, there are only so many patterns it can run through, give or take external data, and this is exhaustable. don't need "anything can happen" solutions for that.
<fe[nl]ix>
and you can't even use memory pressure signals to evict objects from the cache because those unreachable old objects would still not be collected in time to avoid the OOM killer
rumbler31 has joined #lisp
<no-defun-allowed>
Also, with my scheme, you still have incremental major collections. Maybe scanning the stack is a bit slower if you have to also copy tenured roots, but it hopefully isn't worse than non-generational collection.
Nilby has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
oni-on-ion: Now write an analyser that will decide what's live where for an arbitrary program. There are many programs for which you'll never know.
<oni-on-ion>
'arbitrary' is the thing, not predictable
<oni-on-ion>
program should not be arbitrary. same reason IRL the laws and social cues and culture things keep changing
<no-defun-allowed>
Programs are very arbitrary.
<oni-on-ion>
general programs
rumbler31 has quit [Ping timeout: 264 seconds]
<no-defun-allowed>
What's a general program?
<pfdietz>
davros: I use multiple dispatch. I even use method combination.
Nilby has joined #lisp
<oni-on-ion>
no-defun-allowed, given all the power to do anything in whatever way, however often, etc
<no-defun-allowed>
Yes, the liveness of a general program is undecidable.
<oni-on-ion>
in contrast to say a DSL (example, css)
kagevf has quit [Ping timeout: 256 seconds]
<oni-on-ion>
yea. my againstness of magic-GC is precisely because the programs i make are not general at all. the tools i use to make them are however, sure
<oni-on-ion>
CL is easily one of the best for this, but once something is set in stone, it should be able to leave the factory
<oni-on-ion>
and where prediction comes in (given external data) due to a binary or stone'd program can only run so many combinations of patterns
<no-defun-allowed>
Maybe I just don't write "general programs".
kagevf has joined #lisp
<oni-on-ion>
im thinking no one does, except of course compilers and operating system and web browser
<oni-on-ion>
"sandbox" programs
<oni-on-ion>
to actually write a program/app/game/website is very particular and not general
<no-defun-allowed>
Oh, okay. "General" in generality, not a synonym "normal".
<no-defun-allowed>
Then my programs are very general; a regular expression compiler, a distributed object system, ...
<oni-on-ion>
yeah =) in sense of General Purpose [programming language, processor, etc]
<oni-on-ion>
yep =) i've a feeling thats called Systems programming ?
<no-defun-allowed>
And I don't know anyone that hasn't written a few general programs.
<no-defun-allowed>
No, systems programming is a scam made to sell more oxidisation processes.
<oni-on-ion>
of course - done some 3d modeler and map editors and etc. Tools
<oni-on-ion>
ah system is a general enough word
<oni-on-ion>
about Genera , comes from:: Genus (n) "kind or class of things" (biological sense dates from c. 1600), from Latin genus (genitive generis) "race, stock, kind; family, birth, descent, origin," from suffixed form of PIE root *gene- "give birth, beget,"
<oni-on-ion>
(genera is plural of genus)
<oni-on-ion>
and General -- "of wide application, generic, affecting or involving all" (as opposed to special or specific), from Old French general (12c.) and directly from Latin generalis "relating to all, of a whole class, generic"
<mfiano>
A systems programming language means different things to different people. Some people consider it a language that you can write an OS in. It won't be long before CSS fits that, since it is already Turing-complete. Others think of it as working with severely constrained resources. Others think of it as just manual memory management. It's really a term that nobody should use. Just state exactly what
<mfiano>
you are talking about.
<oni-on-ion>
as a term its very ahem general
<oni-on-ion>
but capitalized to use the one particular to context
<oni-on-ion>
oh.... Gender. i have some thoughts about gendered software, but wont discuss it here i've spammed quite enough =)
mange has joined #lisp
johnjay has quit [Ping timeout: 240 seconds]
<beach>
davros: Yes, of course. Multiple dispatch is used all the time.
<beach>
davros: You have some very strange questions, in my opinion.
<mfiano>
Yes, I find it hard to believe anyone here doesn't use that daily.
<beach>
davros: What was the reason for that particular question of yours?
waleee-cl has quit [Quit: Connection closed for inactivity]
<davros>
just curious how many people actively use that stuff
<beach>
davros: And what would the answers suggest to you?
kagevf has quit [Ping timeout: 240 seconds]
<oni-on-ion>
best is to search in github, search by prog lang (CL), then sort by popularity and whatnot. browse the source code of the programs. (explaining code in english is kind of backwards from the reason we have made proglangs in the first place.)
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
judson_ has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 246 seconds]
kagevf has joined #lisp
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
judson_ has joined #lisp
kagevf has quit [Ping timeout: 240 seconds]
kagevf has joined #lisp
Fare has joined #lisp
aartaka has joined #lisp
aartaka_d has quit [Ping timeout: 272 seconds]
ibinderwolf has quit [Remote host closed the connection]
aartaka has quit [Ping timeout: 246 seconds]
ebrasca has joined #lisp
shka_ has joined #lisp
bilegeek has quit [Quit: Leaving]
gaatsby has joined #lisp
johnjay has joined #lisp
gaatsby has quit [Remote host closed the connection]
gasby has joined #lisp
skapata has quit [Remote host closed the connection]
Codaraxis__ has joined #lisp
hhdave has quit [Read error: Connection reset by peer]
achilles has joined #lisp
hhdave has joined #lisp
frgo_ has joined #lisp
astronavt has quit [Remote host closed the connection]
astronavt has joined #lisp
Codaraxis_ has quit [Ping timeout: 240 seconds]
frgo has quit [Ping timeout: 244 seconds]
gasby has left #lisp ["ERC (IRC client for Emacs 27.1)"]
beach` has joined #lisp
beach has quit [Ping timeout: 272 seconds]
andreyorst` has joined #lisp
beach` is now known as beach
treflip has joined #lisp
toorevitimirp has joined #lisp
florian_ has joined #lisp
diamondbond has quit [Ping timeout: 244 seconds]
wxie has quit [Quit: wxie]
johnjay has quit [Ping timeout: 272 seconds]
wxie has joined #lisp
johnjay has joined #lisp
loli has quit [Ping timeout: 256 seconds]
aartaka has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
florian_ has quit [Quit: Leaving]
Cymew has joined #lisp
toorevitimirp has quit [Remote host closed the connection]
toorevitimirp has joined #lisp
hahawang has joined #lisp
diamondbond has joined #lisp
Fare has quit [Ping timeout: 260 seconds]
aartaka has joined #lisp
loli has joined #lisp
<hahawang>
Hi, I'm a newbie in lisp and I've found the macro quite hard to learn, what's the most effectively to learn it?
<mange>
Is there anything in particular you're having trouble understanding?
<beach>
hahawang: There is not much to understand. A macro is just a function that takes code and returns some different code.
<hahawang>
Thank you, I've found the most hard part is do some evaluation in macro body and it always generate some messy code and bug prone...
<beach>
hahawang: It is typical for beginners to use macros when they shouldn't.
<hahawang>
espically mixed with `(,), quasiquote
<beach>
hahawang: Macros should not be used when functions will work.
galex-713 has quit [Quit: No Ping reply in 180 seconds.]
<hahawang>
Yes, I have found I can't tell the real difference between macro and function
<hahawang>
When to use function and when to use macro
<beach>
hahawang: It's fairly simple. A function always evaluates its arguments before being applied to the values of those arguments. If that is acceptable semantics, then you should use a function.
<no-defun-allowed>
You couldn't implement something like WITH-OPEN-FILE without using a macro.
<phoe>
hahawang: always use functions, except for when a function won't do very well.
<phoe>
which is e.g. when you want to introduce some new syntax.
<hahawang>
I found when I want to write some macro, I can't tell which part will be evaluate at the macro expansion time and which part will be evaluated after expansion
rumbler31 has joined #lisp
<Cymew>
Do some stupid examples and expand them to test it out, is probably a good idea.
<hahawang>
It's hard to imagine what will be evaluated after macro expansion, when I try to expand it, it always generate some messy and nested list which is hard to debug and read
<hahawang>
Oh, forget to say thank you!
<no-defun-allowed>
You can use MACROEXPAND (or MACROEXPAND-1) so you don't have to imagine the expansion.
<beach>
hahawang: The entire expression resulting from the macro expansion is evaluated using the normal evaluation rule.
<no-defun-allowed>
e.g (macroexpand '(incf x)) => (SETQ X (+ 1 X)) ; or something like that
<hahawang>
@beach Thank you! Inspiring idea!
rumbler31 has quit [Ping timeout: 246 seconds]
<beach>
Pleasure.
<phoe>
hahawang: re "It's hard to imagine" it's actually easier when you do slime-macrostep
<phoe>
macrostep mode is amazing because it expands macros inline
<hahawang>
@no-defun-allowed Thank you too.
Fare has joined #lisp
<hahawang>
@phoe Thank you, I will have a try.
<hahawang>
Thank you all! I will watch the recommanded video, read that book and practise more!
<phoe>
hahawang: good luck with that
<phoe>
#clschool is also a good channel to ask questions if #lisp is busy for whatever reason
<phoe>
and #lispcafe is for more off-topic discussions
<phoe>
feel free to ask if you're curious about stuff.
hdasch_ has joined #lisp
<beach>
phoe: Heh! "good luck with that" sounds like "there is no way you are ever going to understand it that way".
amb007 has quit [Read error: Connection reset by peer]
lad has quit [Read error: Connection reset by peer]
hdasch has quit [Ping timeout: 256 seconds]
<phoe>
oh
<phoe>
:(
esotericalgo has quit [Ping timeout: 260 seconds]
<phoe>
I did not mean it that way
kbtr has quit [Ping timeout: 256 seconds]
lad has joined #lisp
<beach>
I know.
* phoe
blames English, as always
<phoe>
hahawang: good luck! sorry fo the mixup
kini has quit [Read error: Connection reset by peer]
hiredman has quit [Ping timeout: 265 seconds]
hiredman has joined #lisp
kbtr has joined #lisp
amb007 has joined #lisp
esotericalgo has joined #lisp
<beach>
"`Good luck with that' is a set phrase that people say when you're going to try something that they think will be hard or impossible."
<phoe>
yes, I see it now
<beach>
English is hard.
galex-713 has joined #lisp
liberliver has joined #lisp
kini has joined #lisp
zacts has joined #lisp
zacts has quit [Client Quit]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
<hahawang>
@phoe It doesn't matter. I am not a native speaker and also try my best to learn English now.
random-nick has joined #lisp
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
gxt has joined #lisp
<beach>
hahawang: The @ convention is not used on IRC. Just so you know.
mbomba has quit [Quit: WeeChat 3.0]
<beach>
hahawang: Just type the nick followed by `:'. Your IRC client should complete for you.
<hahawang>
beach: Let my try.
<hahawang>
Oh, that not works.
<beach>
Worked! :)
<beach>
Oh?
<hahawang>
I am using IRC in emacs.
<beach>
Me too.
<phoe>
and I'm not
<hahawang>
I can't see the highlight of your nickname in the message I have typed.
<phoe>
hahawang: well
<beach>
hahawang: You see your own nickname highlighted.
<phoe>
that's client-dependent
<phoe>
I see mine highlighted in irssi
<no-defun-allowed>
I see mine highlighted over Matrix on the web client, too.
pillton_ has quit [Quit: WeeChat 3.0]
<madnificent>
phoe lost one street credit
<phoe>
madnificent: :(
<phoe>
this is so I have an IRC session that is not lost on machine reboots and is instead sitting on a tiny VPS
Fare has quit [Ping timeout: 264 seconds]
<madnificent>
phoe: I was joking :) I found out it's trivial to set up znc and am now using znc-erc for that purpose. The default configuration doesn't replay enough to be super nice, but I'm sure a few hours of searching for configuration would resolve that too. Nothing wrong with irssi though :D
<flip214>
phoe: the only remaining question is.... screen or tmux? ;)
<phoe>
madnificent: :D
<phoe>
flip214: I'll answer on #lispcafe
<madnificent>
took me years far too long to figure out there's something like znc. if i'd have known, i likely wouldn't have left this channel.
<flip214>
phoe: my irssi channel bar is already too long, don't think I want another entry there ;)
<phoe>
flip214: okay then, tmux
luna_is_here has quit [Read error: Connection reset by peer]
luna_is_here has joined #lisp
hendursa1 has joined #lisp
jprajzne has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
pve has joined #lisp
<lotuseater>
hahawang: sorry but don't start with Let over Lambda. it's too much for a beginner
hhdave has quit [Ping timeout: 272 seconds]
hhdave_ has joined #lisp
<phoe>
^
<phoe>
if anything, start with On Lisp to start understanding Lisp macros; Let Over Lambda is an advanced macrology title
<lotuseater>
try to implement something like += from other langs first as a function and think about why that can't work. then macros are needed
<phoe>
and I'd advise you to start with Practical Common Lisp or Graham's ANSI CL (or Touretzky's Gentle if you haven't programmed before at all) to understand Lisp basics first
<lotuseater>
phoe: do you agree if i say macros can be viewed as functions which take lists and produce new lists?
<phoe>
lotuseater: can't agree with that
<phoe>
macros can take any Lisp data and produce any Lisp data - not just list
<phoe>
lists*
<beach>
They take code and produce new code.
<hahawang>
I have some experience with Lisp, I have implement a simple bittorrent client(yet not full-fledged) in Emacs Lisp and have written my own Lisp interpreter.
<phoe>
(defmacro foo () "foo") - a valid macro, no lists taken, no lists produced
srandon111 has joined #lisp
<hahawang>
But Lisp macro seems so hard for me :(
<beach>
Even better, a macro function takes a form and produces a new form.
<phoe>
hahawang: oh, good - then PCL should be a good suit
<srandon111>
guys i am starting with common lisp on linux, should i install sbcl and quicklisp from my package manager or it is more suggested to install them externally from the package manager?
<hahawang>
Anyone interested with that bittorrent client?
<lotuseater>
na ok maybe it isn't clear what i meant
<srandon111>
is there something similar to pyenv for clisp ?
<phoe>
hahawang: maybe #emacs - #lisp is about Common Lisp
<beach>
srandon111: CLISP?>
<beach>
srandon111: CLISP is not that well maintained these days.
<phoe>
beach: he likely uses "clisp" as the invalid acronym for Common Lisp
<hahawang>
There is so much thing I want to implement but I have no time since there are so much details.
<beach>
srandon111: CLISP is an implementation of Common Lisp.
<phoe>
srandon111: I install SBCL from debian's apt repositories and then install quicklisp from outside.
<no-defun-allowed>
Well, there aren't multiple incompatible versions of Common Lisp to switch between.
<phoe>
I don't install *ANY* CL software other than SBCL from OS repositories because they clash with Quicklisp-provided stuff in various really awful ways.
<phoe>
no ASDF, no slime, no alexandria, no nothing; I grab those from Quicklisp (and I upgrade ASDF manually).
<beach>
srandon111: If you assume people know what pyenv is without describing it, you will likely get fewer answers than if you told us what pyenv does.
ljavorsk has joined #lisp
<srandon111>
beach, sorry i meant common lisp
<hahawang>
phoe: sorry, I don't know that.
<phoe>
hahawang: now you do :D
<phoe>
no worries
<hahawang>
phoe: Thank you.
<srandon111>
phoe, ok thanks... so your suggestion is to install sbcl from official OS repos and quicklisp externally ?
<phoe>
srandon111: yes
<phoe>
install SBCL from the official OS repos and then download and install quicklisp separately
<phoe>
and use that to setup everything else.
<srandon111>
ok thanks phoe
<hahawang>
I want to learn how macro works and have implemented a lisp interpreter in C++ followed Peter Novig's toturial, but In my opinion, although understanding how it works helps to learn how to use it, but using it well is quite anthor story.
<beach>
Wow.
<hahawang>
Something like you know what chess rules are and how chess works, but you can't it well.
<phoe>
hahawang: macros have rules of their own, too
<hahawang>
can't play it well.
<phoe>
and there's tactics and strategies for macro usage, just like with chess. :D
<mfiano>
Such as only use them for the two things they are used for. Use functions whenever you can
<beach>
hahawang: Maybe you should look at the first few presentations I made for the online Lisp meeting, entitled "Creating a Common Lisp implementation".
<hahawang>
Maybe it's what lisp intrigues me, building complex and beautiful program by a few of clean rules, quite elegant.
<hahawang>
phoe: Yes, I think I'm missing some tactics and strategies.
<phoe>
srandon111: yes
hnOsmium0001 has quit [Quit: Connection closed for inactivity]
<beach>
hahawang: Did you write that interpreter mainly to learn how Common Lisp works?
<hahawang>
No, It's not common lisp interpreter. Common lisp is a big one, I just implement a lisp dialect for my own reasearch, a DSL for my reasearch, adding some syntax borrowed from Perl.
<phoe>
beach: I would assume more like learning how Lisp interpreters/environments/evaluators work in general; this assumptions may not be true because it follows my story back when I implemented Graham's Roots of Lisp
<phoe>
s/assumptions/assumption/
<beach>
I see.
<beach>
hahawang: So you are planning to use it for your own work?
<beach>
hahawang: If so, why did you not choose to use an existing implementation. An interpreter written in C++ is likely to be very slow.
<hahawang>
beach. I am research on service architecture on Embedded system, I add some syntax surgar in Lisp to let remote service like a normal lisp function.
<hahawang>
beach: Yes, it's quite slow, I want write a lisp compiler to directly compiling to ARM assembly at spare time.
<srandon111>
but he never says how to launch a CL-USER repl ...
<hahawang>
Sorry, "I want to", bad grammar, sorry.
<phoe>
srandon111: launch slime
<srandon111>
how can i launch it? do i necessarily need slime ??
<phoe>
you can just run SBCL instead
<phoe>
and you'll get a REPL, just a different one
<srandon111>
phoe, ok slime is only within emacs right ?
<srandon111>
so SBCL provides its own REPL accessible by just doing "sbcl" ?
<phoe>
yes
<phoe>
but it is less featureful, because you don't have an external debugger, inspector, cross-references, completions, or ability to easily send in forms or files for compilation
<phoe>
slime is only for emacs, but there are also plugins for other editors
<beach>
srandon111: If you try to use Common Lisp with the bare SBCL REPL, you will hate the experience.
<srandon111>
phoe, is there a more fancy repl outside emacs ? something maybe with syntax highlighting and other fancy stuff ?
<phoe>
that's a very recent discussion.
<phoe>
srandon111: yes, see the linked thread
Lord_of_Life has joined #lisp
Lord_of_Life has quit [Changing host]
<srandon111>
thanks phoe very helpful
<beach>
srandon111: I strongly recommend you use Emacs and SLIME.
<lotuseater>
oh yes, not seeing arguments or keywords etc acceptable by functions or else in SBCL REPL was painful
<hahawang>
beach: I choose to write my own mainly for educational purpose. I am curious about how lisp macro works, eval/expand/apply works, garbage collection works, reference counting works, mark and sweep works, so I decide to write my own.
<beach>
hahawang: I understand.
<hahawang>
In addition to that, I want to extend some new syntax to lisp, like #(1 2 3 4) to denote some special list.
<beach>
hahawang: That's already Common Lisp syntax for vectors.
<lotuseater>
ehm that is for vectors
<beach>
hahawang: But I guess you are not that interested in Common Lisp specifically.
<hahawang>
Yes, something like #@() #?() $() $@()
mgr_ has quit [Ping timeout: 260 seconds]
<phoe>
hahawang: might want to visit ##lisp which is for general discussions about various Lisp dialects
<hahawang>
I want extend lisp syntex and called that #? $ `list prefix`
<phoe>
that's doable - in CL it's just reader macros
<srandon111>
and also i don't know what the hell roswell is
<phoe>
roswell is a Lisp implementation manager
<lotuseater>
hahawang: you have basically three stages: read -> compile -> run. and at all stages the other other two can be called too
<phoe>
I don't know if I can recommend it to people who are new to Lisp in general
<srandon111>
beach, oh ok so there are no cool REPL for lisp on command line ?
<beach>
Not that I know of.
<srandon111>
phoe, what's a lisp implementation manager?
<phoe>
srandon111: none that I know of either
emys has joined #lisp
<phoe>
srandon111: something that is capable of downloading/compiling/installing/selecting different versions of SBCL, CCL, ECL, ABCL, and what else exists
<hahawang>
Sorry, I seems arrogant. Too many thoughts I want to share since research is always lonely.
<srandon111>
wow that's sad it's crazy how for a so REPL oriented language nobody developed a cool command line REPL outside the Emacs environment such as Slime
<phoe>
srandon111: there is a command line REPL
<beach>
srandon111: It is unusual to use the REPL for writing code. One typically edits Common Lisp code in an editor buffer, while being assisted with indentation, function signatures, evaluation, etc.
<srandon111>
phoe, ohh that's cool
<hahawang>
Thank you!
<phoe>
it's called slime, and you get it when you run emacs in terminal mode
<phoe>
:D
<srandon111>
beach, i know but it was nice for quick tests with common lisp as i use ipython with python to do that
<phoe>
you can run emacs in a terminal and it works almost the same as in graphical version
<srandon111>
phoe, roswell is another cool thing to have
<srandon111>
since i was used to use pyenv or plenv to manage implementation installation
<phoe>
srandon111: yes, but I cannot recommend it at the moment - it tends to not work sometimes, especially on non-linux
<srandon111>
phoe, i am not confident with emacs, i use vim
<phoe>
srandon111: oh! then use vlime and/or slimv
<srandon111>
phoe, i am on gnu / linux luckily
karlosz has quit [Ping timeout: 240 seconds]
orivej has joined #lisp
<srandon111>
phoe, anyway i am plannin to learn emacs
<hahawang>
Oh, reader-macro is pretty cool!
toorevitimirp has quit [Remote host closed the connection]
<lotuseater>
hahawang: yes it can give you much power (and so much responsibility)
<hahawang>
so that I can extend lisp syntax and write something like $@(...).
<phoe>
read the README, maybe read the code, please never use it in practice
<beach>
hahawang: I think it is fine to implement a Lisp system in C++ for the purpose of learning how Lisp works internally, but I don't think it's a great idea to use such a thing for "production" code. It would be much better to choose one of the maintained Common Lisp implementations that fits your needs.
C-16 has joined #lisp
<hahawang>
thank you, if I have known that half year ago, I could do my reasearch in a more effective way...
iskander has joined #lisp
<phoe>
hahawang: that's the way learning goes
iskander- has quit [Read error: Connection reset by peer]
<phoe>
often you recognize that someone already went in the direction you are going in; minds think alike
<hahawang>
beach: Thank you very much. In practise, I found debugging is quite hard when I want to write something from scratch, especially for non-trivial code. It's better to use exsiting mature one. Thank you very much, very helpful.
frost-lab has joined #lisp
<srandon111>
beach, why you were complaining about cl-repl, once i compiled roswell it was super easy to install it and run
<srandon111>
phoe, cl-repl seems cool
<phoe>
srandon111: again, I never used it
<phoe>
so I cannot say much about it
<beach>
srandon111: I didn't complain about cl-repl.
<beach>
I know nothing about it.
<srandon111>
ok phoe i installed it and works flawlessly i wonder why it is not on quickisp
<beach>
But I can't imagine how a command-line REPL would be a substitute for SLIME.
<srandon111>
beach, sorry maybe i misread some of your messages
<srandon111>
beach, it is not... i just wanted to explore some repls
<phoe>
srandon111: likely because it has roswell as a prerequisite
gxt_ has joined #lisp
<beach>
srandon111: For example, I rely on instant feedback to see the lambda list of a function that I am about to write a call for.
<srandon111>
so that e.g., if i am in my terminal without emacs open and i want to test my short lisp code it is useful to have
<phoe>
srandon111: I usually have emacs running in another window so I can test my stuff there
<beach>
srandon111: I find I can't even work well if I have (say) Clouseau running (which then prevents that feedback) in the same thread.
<phoe>
like, leave it open for days or weeks
<beach>
srandon111: It is not as useful as you might think. As phoe says, you would typically have an editor window and a REPL in the same process, and they would talk to each other, so that you get instant feedback and other help.
hahawang has quit [Remote host closed the connection]
gxt has quit [Ping timeout: 240 seconds]
<beach>
srandon111: In your case, how would you get code from your editor to your REPL?
<beach>
srandon111: Use the mouse to copy-paste?
<beach>
srandon111: If that's what you are used to, I strongly recommend you upgrade to something better.
shifty has quit [Ping timeout: 240 seconds]
sgibber2018 has joined #lisp
<beach>
srandon111: Also, as phoe says, there is absolutely no reason not to have Emacs running.
<phoe>
beach: well not exactly
<phoe>
sometimes it hangs on me or has a memory leak and I gotta restart it, you know
Stanley00 has quit []
cosimone has joined #lisp
<beach>
phoe: That was a pedagogical first-level approximation.
skapata has joined #lisp
<beach>
Sorry I didn't make that clear.
ldb has joined #lisp
<ldb>
good eve
<beach>
Hello ldb.
<phantomics_>
Evening ldb
<ldb>
someone other day told me there's a book Building Problem Solvers that uses common lisp but I didn't know
<phantomics_>
A question: I have a function that creates a software package with a given name, and then creates some dynamic variables in the package
<phoe>
a software package - you mean a Lisp package?
<phantomics_>
It creates the dynamic variables like this (setf (symbol-value '*symbol-name*) value)
<phantomics_>
Yes, a Lisp package
<phoe>
that is not enough
<phoe>
PROCLAIM it SPECIAL beforehand
<ldb>
you can build symbol on the fly using INTERN
<beach>
phantomics_: Why would you do it that way rather than using DEFVAR or DEFPARAMETER?
<phantomics_>
Intern is that I actually use
<phoe>
beach: at runtime, I guess
<phantomics_>
Yes, at runtime
<ldb>
if your problem is that lisp read cannot recognize the package
<phoe>
so using PROCLAIM SPECIAL + SETF SYMBOL-VALUE would be equivalent to EVAL DEFPARAMETER
<phoe>
or COMPILE NIL LAMBDA DEFPARAMETER
<phoe>
just fully at runtime.
<phoe>
and phantomics_ is free to pick his poison over which one to use
<ldb>
*lisp reader
<ldb>
there might be a very unique need for that
<phoe>
err, also FUNCALL that COMPILE'd function
<phantomics_>
so (progn (proclaim (special 'package::*var*)) (setf (symbol-value 'package::*var*) value)) will do it?
<splittist>
ldb: I like the conditionals in the Building Problem Solvers code: Lucid, Symbolics, MCL, ACLPC, RT, RIOS, IRIX, ILS, PARC (:
<phoe>
ldb: I assume it's for april
<phantomics_>
Yes, it's for April
<phoe>
phantomics_: yes, as long as PACKAGE exists
<phantomics_>
April creates packages on the fly to use as its workspaces
<phoe>
otherwise the reader will explode
<phantomics_>
APL has a concept of workspaces roughly analagous to Lisp packages
<phoe>
nice
<ldb>
I guess workspace is very different from lisp package, it is more like a heap image
C-16 has quit [Ping timeout: 272 seconds]
wxie has quit [Ping timeout: 265 seconds]
<phantomics_>
Yes, from an implementation standpoint
<phoe>
"The workspace is a fundamental concept in APL. It enables you to develop a project as a series of small pieces of program logic. These are organized into functions, operators and classes, as described below. (...)"
<phantomics_>
APL is very unlike most languages in that it still carries many mainframe-era conventions
<ldb>
splittist: like how people wrote C in the old days :D
<phoe>
I assume that these can be named by CL symbols, at which point a package sounds like a decent choice
<phantomics_>
The norm for APL is to develop software directly in an APL REPL, writing all functions there. Those functions are saved in the workspace
<phantomics_>
In modern APLs you can save those workspaces to binary files and then load them later
<phoe>
as in, functions, operators, classes - these are nameable in CL, except functions and operators become kinda melded into one
<phoe>
phantomics_: nice! that's the equivalent of Lisp FASLs
<phoe>
(more or less)
<phantomics_>
The use case isn't quite the same
<sgibber2018>
REPLs are the best. Interactive programming ftw
<phantomics_>
It's like if you had no lisp files and typed all your functions into the REPL, can you generate a FASL after doing that?
<ldb>
no
<phoe>
phantomics_: it's possible to dump the whole Lisp image, but not parts of it
<phantomics_>
Didn't think so
<phoe>
I assume it could be possible with enough implementation support, or even written in portable Lisp though
<emys>
is there something like a CLASSPATH environment variable to tell ASDF where to look for installed packages?
<phantomics_>
April allows you to load APL source from files, currently the only REPL is invoking (april) calls through a Lisp REPL but I'm looking into building an Emacs-based pure APL REPL for it
<phoe>
emys: asdf:*central-registry*
shifty has joined #lisp
<ldb>
phantomics_: will you support some exotic extentions (probably some from NARS2000) other than ISO APL?
<phantomics_>
Also, the traditional way to write APL functions is to use an in-REPL line editor mode that works a bit differently than the regular REPL. It wasn't until the 80s that the concept of an inline function definition existed in APL
<beach>
The famous "del" editor?
<phantomics_>
Yes
<ldb>
Del is fun to use, from a text editor hobbist point of view
<phantomics_>
Part of the reason APL stuck with these conventions is that they worked so well on the original APL mainframes, it was an incredibly efficient environment to work in
<phantomics_>
ldb: ISO APL is fulfilled by APL/2 and GNU APL, right? I have almost all of the lexical functions and operators in Dyalog APL, along with some features from k
<phantomics_>
I have the ∘, @, ⍨, ⍤, ⍥, ⍣, ⍸, and others not included in APL/2
<phantomics_>
There are also k-style if-statements like $[oneorzero;1;0] and n-argument functions: g←{[a;b;c] a+b×c} ⋄ g[2;3;4] => 14
urek has joined #lisp
<ldb>
phantomics_: what about trains and atops?
<phantomics_>
Have those too
* ldb
needs to update quicklisp dists
<phoe>
∘, @, ⍨, ⍤, ⍥, ⍣, ⍸
<phoe>
to me, a person who never used APL, they are, thought-provoking, amusing, and look like emoji and/or emoji parts
<phoe>
which is IMO a good reason to finally learn APL someday!
<phantomics_>
To my knowledge I have the most complete implementation of the ⍣¯x function inversion feature aside from Dyalog, and later I'll be able to expand it to support arbitrary user-defined functions within a narrow set of criteria
<phantomics_>
Something you might notice is that some APL characters are used as components in others: ¨ ∘ ⍤ ○ ⍥ _ ⍸ ~ ⍨
<ldb>
Last time I tried April, the (2∘⊥⍣¯1) was not yet working
<phantomics_>
Back in the teletype terminal days, those characters were entered by typing two symbols over each other
<phoe>
was APL the reason Unicode was created?
<ldb>
guess not
<phantomics_>
Using APL required a custom typeball from IBM, and there was only space for so many characters on it, so they created a bunch of overstruck character variations to support more symbols
<phoe>
the choice of characters in APL is really fascinating
<ldb>
actually you can think you have sacrificed lower case letters for those symbols
<phantomics_>
Yes, the original APL typeball had only italic uppercase
<phantomics_>
Looks like (2∘⊥⍣¯1) still doesn't work correctly, I'll check into that
<phantomics_>
A binary encoder?
iskander- has joined #lisp
iskander has quit [Ping timeout: 260 seconds]
<ldb>
yes, it was because I want to working on a very large number that typical APL cannot support
<ldb>
like 123*55
<sgibber2018>
That really does sound like a neat language
<phantomics_>
You can do stuff that takes a dozen nested loops in a regular language in one line
<phantomics_>
Hmm, I seem to be mistaken about the nature of ⊥⍣¯1
<phantomics_>
I thought that (2∘⊥⍣¯1) 5 was the same was (2∘⊤) 5, but it isn't
C-16 has joined #lisp
<sgibber2018>
What is the difference?
<ldb>
if it is just ⊤, it needs to write APL code calculate the length of the result array
<phantomics_>
(2∘⊥⍣¯1) 5 => 1 0 1 , (2∘⊤) 5 => 1
<sgibber2018>
Oh that's neat.
<ldb>
(2 2 2∘⊤) 5 => 1 0 1
rumbler31 has joined #lisp
<phantomics_>
Oh, so it calculates the length of the resulting array from (2∘⊥) 5, and then extends the length of the scalar left argument to ⊤ to match that length?
<phantomics_>
phoe: Unicode wasn't created for April, actually due to the lack of character support the APL creators released another vector language in the 90s called J that used only ASCII
<ldb>
for an optimized implementation, calculate the length only needs a few machine instructions on the right arg
<phoe>
phantomics_: yes, sorry; the question was a poor joke
<phantomics_>
What's really funny is that in the 80s, there was an APL solution for IBM PCs in the form of a custom graphics card. It had a physical switch on it that you would flip to change between APL characters and the regular MS-DOS character set
rumbler31 has quit [Ping timeout: 256 seconds]
<phoe>
phantomics_: you give me the same kind of mad scientist vibe that drmeister gives me; dunno, maybe it's the tendency to have advanced Lisp interoperability with other programming languages, maybe it's just the same hair style
<phantomics_>
Hadn't looked much into Clasp before, has he done any videos?
<lotuseater>
phantomics_: yes two awesome talks, one from 2015 and one from 2018
<lotuseater>
it's much about the molecule design aspect
<srandon111>
guys how can i search documentation for a function with SLIME ?
<phoe>
I always do (describe 'foo) in the REPL
<no-defun-allowed>
phantomics_: Silly question, have you looked at heisig's Petalisp compiler? That was also (partly) inspired by APL\3000 from memory, and so it /could/ be a backend for April.
<beach>
phoe: for a SLIME function?
<beach>
Oh, for a Common Lisp function, using SLIME. I get it.
C-16 has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Well, there are a lot of APL programs that can't be expressed in Petalisp, but it'd be good for a lot of array churning.
<phantomics_>
no-defun-allowed: I have, it's AGPL which is pretty limiting, I saw another one a while back that wrapped numpy for large operations and used optimized Lisp for smaller things
Codaraxis__ has quit [Ping timeout: 256 seconds]
<ldb>
might just open the backend and let the user customize
<phantomics_>
Yeah, multiple backends are another idea
<no-defun-allowed>
numcl? That is all Common Lisp though, so it's unlikely.
<phantomics_>
From what I've found the ultimate optimization may be to use SBCL's define-vop macro to write array operations directly in ASM
<phantomics_>
Not numcl, something different
<lotuseater>
no-defun-allowed: ah this petalisp with JIT compiling?
<phantomics_>
Numcl from what I saw isn't so focused on efficiency
<srandon111>
phoe, ok i tried... https://bpa.st/N3FA wow this is very difficult to understand i would say
<srandon111>
where can i i learn how to interpret that output ?
<no-defun-allowed>
lotuseater: Yes, that Petalisp (as opposed to the Petalisp that is used as a DSL by an American animal rights organisation).
<phantomics_>
Haha, PETA-lisp
hahawang has joined #lisp
Codaraxis__ has joined #lisp
<no-defun-allowed>
srandon111: Well, you see the lambda-list (loosely "the arguments it takes"), what the compiler has inferred the argument types to be, and then the documentation string.
<phantomics_>
The define-vop method would only support SBCL, though, which is the biggest shortcoming
<lotuseater>
yes, "unportable but fun"
<phantomics_>
Other CLs don't seem to care much about speed, though, so most speed-focused users would be using SBCL anyway
<srandon111>
no-defun-allowed, ok if i want to explore a function ,to understand how it works how can i do? for example let's take this process-input
<srandon111>
is there a way to find examples ?
<beach>
srandon111: Read the documentation.
<phantomics_>
srandon111: the other way to get a function's documentation, for * for example, is (documentation '* 'function)
<beach>
srandon111: What you see there is what the SBCL maintainers happened to produce.
<srandon111>
beach, the documentation it's difficult to understand from the (describe) function
<beach>
I meant the online HTML documentation for SBCL.
<beach>
srandon111: What you are looking at is a so-called "documentation string" which is (or shouldn't be) the real documentation.
<beach>
srandon111: It is only meant as a reminder if you already have an idea what you want.
<beach>
srandon111: Also, like I said, you are at the mercy of the (volunteer) SBCL maintainers, and you get what they happened to produce.
hahawang has quit [Remote host closed the connection]
<beach>
srandon111: That function, by the way, is not a standard Common Lisp function. For those, you have the Common Lisp HyperSpec.
<srandon111>
ok thanks beach
<beach>
Sure.
notandinus has quit [Quit: rcirc on GNU Emacs 27.1]
Codaraxis__ has quit [Remote host closed the connection]
<srandon111>
i am ok with the default i was just wondering the reason
<jackdaniel>
backward compatibility
<lotuseater>
imo its "motivation" is for elegance
aartaka_d has joined #lisp
<jackdaniel>
I have always wondered, why the readtable case :invert is present - what's the purpose of it?
<jackdaniel>
something like an easter egg putting burden on the implementers? :)
<lotuseater>
oh that can be just for fun? :D
<srandon111>
jackdaniel, what's the readtable case :invert ?
<srandon111>
inverting the case when reading a table by default?
kagevf has quit [Ping timeout: 240 seconds]
<jackdaniel>
if your reader is set to invert the case of symbols, then when you type 'zebra, the symbol name is "ZEBRA", if you type 'ZEBRA, it's name is "zebra"
<Xach>
srandon111: all-lowercase symbol tokens are converted to uppercase, and vice-versa. Mixed case is preserved.
<Xach>
So you can have a symbol token of FooBar and its name becomes "FooBar"
aartaka has quit [Ping timeout: 256 seconds]
<jackdaniel>
s/it's/its/
<Xach>
Lowercase input code is compatible with CL, and mixed case can be used if you are using it in a situation where mixed case is helpful.
<Xach>
Maybe writing macros to generate code in camelCase environments?
<jackdaniel>
perhaps
<ldb>
I guess the invert is for some terminals that use upper case as defualt "lower case" and still has lower case present
kagevf has joined #lisp
<Xach>
I mean, if you are working with some external system where symbolic manipulation of mixed-case tokens is important.
<Xach>
ldb: no
galex-713 has quit [Ping timeout: 272 seconds]
<Xach>
It postdates that by a long time.
<jackdaniel>
Xach: preserve would be much better fit then, no?
<Xach>
jackdaniel: why? then you would have to write the rest of the code as (DEFUN fooBar () (CONS 'mySymbol 42))
<jackdaniel>
hm
<Nilby>
IT'S SO IT WORKS ON A TELETYPE MODEL 30.
shifty has quit [Ping timeout: 272 seconds]
<Xach>
Actually, I should not say that about :invert history with certainty. It is only my strong impression. It would be nice to know the story from one of the designers.
<Xach>
I don't think I have seen that before, I have only seen second-order rationalizations of the feature. It's nice to see the primary reference.
iskander has joined #lisp
iskander- has quit [Ping timeout: 264 seconds]
emys has quit [Ping timeout: 260 seconds]
emys has joined #lisp
<phantomics_>
I don't see a point for case-sensitive Lisp readers, it's more of an annoyance than a help
<phantomics_>
If you're doing mixed cases in a language, it should follow a consistent pattern, like camelCase variable names
<madnificent>
phantomics_: connecting with external stuff, it helps in that regard.
<phantomics_>
In that case the capitals serve to separate sections of a symbol; in Lisp this is done with dashes
<madnificent>
phantomics_: We have a lisp file with a DSL to specify a JSON:API compliant glue. Not having casing confuses people (they input dasherized and that kind-of works fine)
<phantomics_>
madnificent: in that case I'd usually opt to convert dashes to camel-case
<phantomics_>
That's what I do in April and in a few JSON conversion situations
<madnificent>
phantomics_: we do that, but non-lisp devs forget. Would be handy if we could even warn about it.
<Xach>
What is the dash version of VMKitDashUI?
<no-defun-allowed>
Case insensitivity lets you write sarcastic code like (wHeN (nUlL nUmBeRs) (ErRoR "maximum of zero numbers is undefined"))
<jackdaniel>
common lisp (unlike many other languages), is not very opinionated regarding how you should write things (i.e it doesn't impose on the programmer a particular style of programming)
<Xach>
no-defun-allowed: i like that
<jackdaniel>
that's how I usually explain to myself features I do not use or like
<Xach>
lol
<no-defun-allowed>
Xach: I think most camelcasing people would make you write acronyms the wrong way, like VmKitDashUi or HttpRequest
<Nilby>
"no worse than character macros" With great power comes great potential unreadability.
<splittist>
xml v XML v Xml ...
<phantomics_>
Those examples may be incorrect but they're actually more readable
<no-defun-allowed>
If you wrote them the right way, then you'd be done for; I know my Minecraft FFI has wonders like find-entities-in-a-a-b-b.
<madnificent>
I think you can make something unreadable in both approaches. Having the freedom could help, though I like lowercase dasherized form currently used I would like to have the case-sensitive option for integrations.
<phantomics_>
I have to do lots of find-entities-in-a-a-b-b when generating Javascript and React code from Lisp
<Xach>
My solution is to avoid working with camelcase systems rather than embrace :preserve or some other system.
<phantomics_>
*stuff like find-entities-in-a-a-b-b
<Nilby>
tHEnEXTwINDOW or TheNeXTWindow O_o
<no-defun-allowed>
But if you use the first kind of camel casing, then vm-kit-dash-ui translates correctly.
<phantomics_>
Hard to get around using Web frameworks when you want an accessible interface
vegansbane has joined #lisp
<Nilby>
I have found it efficacious to have a de-camelcaserizer bound to a key.
mgr_ has joined #lisp
<no-defun-allowed>
In 70 LOC of mostly FFI stuff, I only have one annoying name (the forementioned minecraft:get-entities-within-a-a-b-b). But it is a really annoying name.
<no-defun-allowed>
I also need to strip off the get- and set- prefixes one day, but that creates some name collisions.
<lotuseater>
oh cool you're coding minecraft stuff with CL?
<no-defun-allowed>
Well, I haven't for a while, but I have a library to poke around with ABCL.
mange has quit [Remote host closed the connection]
surabax has joined #lisp
jprajzne has joined #lisp
johnjay has quit [Ping timeout: 256 seconds]
johnjay has joined #lisp
lotuseater has quit [Remote host closed the connection]
dhil has joined #lisp
<phantomics_>
What kind of data models are you using for Minecraft content? 3d arrays?
EvW has joined #lisp
urek__ has joined #lisp
urek has quit [Ping timeout: 246 seconds]
urek has joined #lisp
urek__ has quit [Ping timeout: 246 seconds]
kaftejiman has joined #lisp
emys has quit [Read error: Connection timed out]
lxsameer has quit [Ping timeout: 260 seconds]
emys has joined #lisp
karayan has quit [Read error: Connection reset by peer]
karayan has joined #lisp
dhil has quit [Ping timeout: 240 seconds]
nowhere_man has joined #lisp
Josh_2 has joined #lisp
<ldb>
hashset of triples
C-16 has joined #lisp
vegansbane6 has joined #lisp
ljavorsk has quit [Ping timeout: 256 seconds]
vegansbane has quit [Ping timeout: 256 seconds]
vegansbane6 is now known as vegansbane
emys has quit [Ping timeout: 260 seconds]
lxsameer has joined #lisp
renzhi has quit [Ping timeout: 260 seconds]
bitmapper has quit [Quit: Connection closed for inactivity]
emys has joined #lisp
<phantomics_>
ldb is the Minecraft interface source available somewhere? Can't find it
wsinatra has joined #lisp
lxsameer has quit [Ping timeout: 256 seconds]
C-16 has quit [Ping timeout: 260 seconds]
EvW has quit [Quit: EvW]
<splittist>
"Compared to the explosive growth of the 1980s, the trend for the 1990s seems to be a continual, quiet propagation of artificial intelligence techniques into mainstream computing."
<splittist>
(Forbus and De Kleer, Building Problem Solvers (1993))
johnjay has quit [Ping timeout: 256 seconds]
lucasb has joined #lisp
lxsameer has joined #lisp
johnjay has joined #lisp
Fare has joined #lisp
Bike has joined #lisp
ldb has quit [Quit: ERC (IRC client for Emacs 26.1)]
cosimone_ has joined #lisp
aartaka has joined #lisp
cosimone has quit [Ping timeout: 272 seconds]
cosimone_ is now known as cosimone
aartaka_d has quit [Ping timeout: 260 seconds]
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 246 seconds]
cosimone has quit [Remote host closed the connection]
cosimone has joined #lisp
C-16 has joined #lisp
hendursa1 has quit [Quit: hendursa1]
hendursaga has joined #lisp
rumbler31 has joined #lisp
<pfdietz>
In the bleak AI winter, long ago.
EvW has joined #lisp
Nilby has quit [Read error: Connection reset by peer]
dhil has joined #lisp
rumbler31 has quit [Ping timeout: 256 seconds]
loli has quit [Quit: WeeChat 2.9]
wsinatra has quit [Ping timeout: 256 seconds]
wsinatra has joined #lisp
loli has joined #lisp
<phantomics_>
no-defun-allowed: since you brought up Petalisp, here is the other library I was looking at as a potential accelerator for April: https://github.com/digikar99/numericals
aartaka_d has quit [Read error: Connection reset by peer]
aartaka has joined #lisp
<shka_>
is there a way to convince local-time to handle PM/AM format of hours?
frost-lab has quit [Quit: Connection closed]
EvW has quit [Ping timeout: 268 seconds]
treflip has quit [Ping timeout: 256 seconds]
treflip has joined #lisp
gxt_ has quit [Remote host closed the connection]
gxt_ has joined #lisp
treflip has quit [Ping timeout: 240 seconds]
<shka_>
regex it is!
yonkunas has joined #lisp
waleee-cl has joined #lisp
<splittist>
shka_: format-timestring has :hour12 and :ampm (or did you mean actual uppercase AM/PM?)
<flip214>
qqq
hendursaga has quit [Ping timeout: 240 seconds]
<flip214>
sorry, tried to escape less
hendursaga has joined #lisp
emys has quit [Ping timeout: 246 seconds]
emys has joined #lisp
emys has quit [Ping timeout: 265 seconds]
jprajzne has quit [Quit: Leaving.]
harlchen has joined #lisp
emys has joined #lisp
scymtym has quit [Ping timeout: 264 seconds]
abhixec has quit [Ping timeout: 240 seconds]
abhixec has joined #lisp
andreyorst` has quit [Quit: andreyorst`]
housel has quit [Ping timeout: 260 seconds]
ljavorsk has joined #lisp
emys has quit [Ping timeout: 272 seconds]
andreyorst has joined #lisp
scymtym has joined #lisp
emys has joined #lisp
spal has joined #lisp
<spal>
join #python
<beach>
Hmm.
<spal>
oops! sorry about that.
<jackdaniel>
I didn't know that cmu compiler has a dedicated channel
<pyc>
jackdaniel: what's the channel name? I guessed #cmucl but it has only one member.
<jackdaniel>
pyc: I was making fun of #python - cmu compiler /internal/ name is "python"
<pyc>
#sbcl has 92 nicks, so that seems like a dedicated channel. what's the one for CMU CL?
<jackdaniel>
cmucl doesn't have a dedicated channel afaik
<jackdaniel>
on freenode that is
<pyc>
oh! I didn't know cmu cl is also known as "python"
<jackdaniel>
its compiler is known as 'python', not the implementation per se
<pyc>
From Wikipedia article on CMU CL: "A native code compiler named "Python" (not to be confused with the Python programming language)."
<_death>
when people say python is slow, you can point them to sbcl ;)
<_death>
that will either (i) show them python is fast or (ii) show them lisp is fast
kaftejiman_ has joined #lisp
kaftejiman__ has joined #lisp
<pfdietz>
cmucl has been largely superseded.
emys has quit [Ping timeout: 246 seconds]
kaftejiman has quit [Ping timeout: 260 seconds]
emys has joined #lisp
kaftejiman_ has quit [Ping timeout: 240 seconds]
hnOsmium0001 has joined #lisp
matta has quit [Ping timeout: 246 seconds]
bitmapper has joined #lisp
C-16 has quit [Ping timeout: 256 seconds]
_jrjsmrtn has quit [Ping timeout: 256 seconds]
__jrjsmrtn__ has joined #lisp
zcheng3 has joined #lisp
matta has joined #lisp
emys has quit [Ping timeout: 264 seconds]
emys has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
abel-abel has joined #lisp
jprajzne has joined #lisp
Cymew has quit [Ping timeout: 240 seconds]
villanella has joined #lisp
abel-abel has quit [Ping timeout: 260 seconds]
abel-abel has joined #lisp
phantomics_ has quit [Quit: Ex-Chat]
phantomics has joined #lisp
cosimone has quit [Quit: cosimone]
abel-abel has quit []
EvW has joined #lisp
Misha_B has quit [Ping timeout: 256 seconds]
EvW1 has joined #lisp
EvW has quit [Ping timeout: 244 seconds]
EvW1 is now known as EvW
<jmercouris>
phoe: I’m sure you’ve seen the most majestic thread on Github
<jmercouris>
phoe: what are your thoughts?
iskander has quit [Ping timeout: 260 seconds]
iskander has joined #lisp
<phoe>
jmercouris: there are hundreds of majestic github threads and I don't know which one you are refering to
<Bike>
each more majestic than the last
<jmercouris>
phoe: the most majestic of all
<phoe>
oh!
<jmercouris>
the one which will realize is a revolution in Lisp
<jmercouris>
architected by the master architect himself!
<phoe>
must be the thread the one where I suggest adding quicklisp-quackload to quicklisp repos
<phoe>
somebody just link my analysis and/or Twitter threads there, because I'm too dangerous for the Common Lisp community and therefore blocked from posting there
<jmercouris>
lol, he will just delete it
<aeth>
I mean
judson_ has joined #lisp
EvW has quit [Ping timeout: 244 seconds]
<aeth>
how much would it annoy Hexstreamsoft if someone set up a Common Lisp Patreon or something along those lines, but splitting the money among the "Common Lisp mafia"?
<aeth>
so phoe mfiano Xach beach and so on.
<aeth>
It would have more of an impact, too
<jmercouris>
lol, that would be hilarious
<jmercouris>
but probably insufficient for a meaningful support
<aeth>
Another thing you could do is come up with a cryptocurrency written in Common Lisp, but instead of having a fixed supply or using miners, every year (or month or whatever), it would go to such people in the CL community. Probably not even worth cashing initially, but there's always a chance it'd explode in popularity.
<phoe>
aeth: impersonation is not legal you know
<aeth>
phoe: ?
<phoe>
oh wait
aartaka has joined #lisp
<phoe>
I terribly misread
<phoe>
you want a *Common Lisp* Patreon
<aeth>
phoe: My point was, it would be aimed only at people Hexstreamsoft hates, ideally with their consent (since otherwise, there's no guarantee that they could cash out) since they tend to actually, legitimately contribute to the community
<phoe>
sorry, I'm too annoyed by this #<error printing object> as of late.
<aeth>
the Patreon would be more practical, but the cryptocurrency would be more entertaining
<aeth>
imagine having #<money 42>
aartaka_d has quit [Ping timeout: 260 seconds]
KREYREEN has quit [Remote host closed the connection]
<aeth>
(and actually idk if hexstreamsoft hates beach yet)
KREYREEN has joined #lisp
<phoe>
I assume so, Xach flicked his magic wand at beach and turned him into a member of the lisp mafia
<beach>
aeth: Giving me money wouldn't help anything.
<beach>
aeth: He probably does. He created what he says is an improvement on my MOP pages, and demanded that I take down mine and promote his version here (among other places).
<phoe>
aeth: I no longer care about annoying him; I care about minimizing whatever spam and lies he throws out there into who seems to be literally everyone in the Lisp community.
<beach>
aeth: I just told him that he could promote his as much as he wants, but that my work in that domain was done.
<aeth>
phoe: I mean, he was playing the long game, but now we see what it really was for the whole time. Money.
<_death>
this channel is deteriorating by the minute
<phoe>
yes
<phoe>
and, honestly, this is what the "just ignore him" approach leads to
<jackdaniel>
there is a fine line between ignoring someone and staying on topic
<phoe>
I'll take an evening off
judson_ has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
matta has quit [Ping timeout: 265 seconds]
<aeth>
the problem is that there's no room for this sort of off-topic thing in #lispcafe because it's currently on-topic
<aeth>
talking about optimizing arithmetic
matta has joined #lisp
housel has joined #lisp
dbotton has joined #lisp
emys has quit [Ping timeout: 268 seconds]
<jeosol>
I just recently became ware of the issues with hexstream and reading phoe's link. Is there away to mediate this and resolve these issues or it has gone beyond that point. Hoping there is some kind of common ground to put all this behind
<jeosol>
phoe: you wrote that analysis and compiled the stuff in that link?
<jackdaniel>
to put it bluntly, hextream is a bat shit crazy and there is no reasoning. I appreciate phoe's work on that and I pity him - not something he'll get much kudos for. that said, I'd rather keep the topic of this channel related to technicalities of common lisp
judson_ has joined #lisp
* jackdaniel
waves his moderator badge
<jeosol>
jackdaniel: I do agree completely apart staying on point. These arguments aren't very helpful and a bit shocked to see what the hexstream posted with the insults. Anyway, I'd leave this since I don' t have much context
<phoe>
jeosol: yes, I compiled this stuff, I analyzed this contents, and now let's go into private messages because jackdaniel does have a point.
<jeosol>
ok
<jackdaniel>
thank you, I appreciate that
* phoe
quietly goes to #lispcafe because that's where he has a moderator badge
emys has joined #lisp
akoana has joined #lisp
emys has quit [Ping timeout: 240 seconds]
emys has joined #lisp
abhixec has quit [Ping timeout: 272 seconds]
codewaffle has quit [Remote host closed the connection]
<pve>
Is there anything I need to consider besides a symbol-macrolet possibly shadowing a parameter?
wsinatra has joined #lisp
<pve>
Can something go wrong if the body starts with a declare form, and it also gets wrapped by the symbol macrolet?
<_death>
yes.. check out alexandria:parse-body
housel has quit [Ping timeout: 240 seconds]
<Bike>
yeah to avoid most of that i'd honestly just put the symbol-macrolet on the outside, probably
<pve>
_death: aha thanks
<Bike>
it's only different if the symbol macros could be used in &key defaults or something
<dbotton>
Is there a standard program for generating documentation in html from lisp sources?
<pve>
Bike: the idea is I need to pass the lambda expression to make-method-lambda, and it doesn't seem to like having the symbol-macrolet on the outside
<Bike>
oh, yes, in that case you do need an actual lambda expression.
makomo has joined #lisp
<pve>
alright, well alexandria:parse-body seems to take care of this.. thanks
<_death>
dbotton: there is no standard one.. there are legion.. me, I use texinfo and a slightly modified copy of sb-texinfo
<dbotton>
I'll take a look thank you
<dbotton>
That looks good, although I am looking for something that combines the docstrings with comments in the sources sort of thing more
<_death>
oh.. I dislike markup in code.. I remember old attempts like atdoc and there are definitely newer ones as well
<_death>
I think there was a recent blogpost on planet lisp about mgl-pax
<dbotton>
I'll take a look. Not looking for much just something that would collect the comments Introducing sections of code and then operator syntax and doc string sort if thing
spxy[m] has joined #lisp
<dbotton>
I'll take a look at those
Inline has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
nij has joined #lisp
housel has joined #lisp
McParen has joined #lisp
<spxy[m]>
Hello!
<spxy>
Hey!
urek has quit [Remote host closed the connection]
<phoe>
hellooooo
urek has joined #lisp
housel has quit [Ping timeout: 240 seconds]
luna_is_here has quit [Read error: Connection reset by peer]