contrapunctus has left #lisp ["Disconnected: closed"]
rumbler31 has joined #lisp
jeosol has joined #lisp
contrapunctus has joined #lisp
abhixec has quit [Remote host closed the connection]
Kundry_Wag has quit []
<loke[m]>
moon-child is that wj guy still posting there?
<moon-child>
no idea, I stopped frequenting it
<moon-child>
(still in my newsrc, though--should probably get rid of that)
phantomics has joined #lisp
abhixec has joined #lisp
<loke[m]>
moon-child I was almost impressed with by his consistency. How can you spend years doing that stuff over and over again.
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Spawns_Carpeting has joined #lisp
<no-defun-allowed>
wj guy?
zooey has joined #lisp
<Bike>
the few times i've looked at c.l.c this guy wj made a ton of posts about how CL sucked.
<Bike>
like a ton of posts. some kind of bot i guess.
<moon-child>
the main ~spammers I remember are rick c hodgin (religious propaganda) and prof. fir (all-around fun times)
<moon-child>
oh, also suresh
<no-defun-allowed>
raisins CL sucks 1. Only common why would you not use items with higher rarity 2. No abelian groups for pure IO 3. Too fast, can't overcharge people for rewriting in C
<semz>
wait a second, what is c.l.c? i assumed comp.lang.c, but anti-CL posts sound out of place
<Bike>
is the IO monad abelian
<Bike>
semz: again, this was spammy
<semz>
oh i see. wild stuff
<Bike>
oh, sorry, iw as thinking of c.l.l
<Bike>
i don't know what c.l.c is
<no-defun-allowed>
Bike: no, else IO would be commutative and that wouldn't help with "sequencing" IO
<Bike>
makes sense
<no-defun-allowed>
I think that's how it is, I dunno and only came up with Abelian IO for the joke.
GZJ0X_ has joined #lisp
gzj has quit [Ping timeout: 252 seconds]
semz has quit [Ping timeout: 250 seconds]
<dieggsy>
is there a concise way to say "1e6 as an integer" short of flooring it
<Bike>
Do you mean you want a shorter integer literal syntax?
<Bike>
or do you have some float at runtime and you want an integer.
asarch has joined #lisp
<dieggsy>
Bike: The former, I think. I want to be able to type "the integer 1e6" without 1000000 or (floor 1e6)
thinkpad has quit [Ping timeout: 240 seconds]
<Bike>
i see. there's no built in way. if you wanted you could probably write a reader macro fairly simply.
<Bike>
i wanna say i've seen "1r6" as an extension before, but i don't remember
<dieggsy>
fair. thanks!
<edgar-rft>
what about (expt 10 6)
<Bike>
that's more characters than 1000000
<Bike>
though i'm going to imagine dieggsy is more concerned about 1e27 or suchlike
<edgar-rft>
"the integer 1e6" is also more characters than 1000000
<dieggsy>
edgar-rft: lol, certainly an option actually. Bike right.
<dieggsy>
edgar-rft: that wasn't literal though, just what i *meant*
<dieggsy>
scheme (don't kill me) has #e1e6
<dieggsy>
suppose it could just be implemented with a reader macro as mentioned
<edgar-rft>
expt is what I am using for huge bignums, you're of course free to use something different
semz has joined #lisp
semz has joined #lisp
semz has quit [Changing host]
<Bike>
oh, it's actually really easy because of how dispatching macro characters work
<Bike>
(defun sharp-e (stream sub num) (declare (ignore sub)) (* num (expt 10 (read stream t nil t))))
<Bike>
(possibly with more error checking)
<no-defun-allowed>
So that would read #1e10?
<Bike>
yeah
<edgar-rft>
using 1e<n> is rather seldom, you usually need numbers like 127364538463e16278364536372 and I doubt that this can be shortened by a read macro
mmontone has quit [Ping timeout: 240 seconds]
thinkpad has joined #lisp
ikrabbe|2 has joined #lisp
ikrabbe has quit [Ping timeout: 240 seconds]
thinkpad has quit [Ping timeout: 240 seconds]
thinkpad has joined #lisp
GZJ0X_ has quit [Read error: Connection reset by peer]
GZJ0X_ has joined #lisp
lotuseat` has joined #lisp
ikrabbe has joined #lisp
mmmattyx has quit [Quit: Connection closed for inactivity]
lotuseater has quit [Ping timeout: 250 seconds]
ikrabbe|2 has quit [Ping timeout: 240 seconds]
asarch_ has joined #lisp
asarch has quit [Ping timeout: 260 seconds]
Oladon has quit [Quit: Leaving.]
indathrone has quit [Quit: Leaving]
mindCrime has quit [Ping timeout: 252 seconds]
asarch_ has quit [Quit: Leaving]
Jesin has joined #lisp
amerigo has quit [Quit: Connection closed for inactivity]
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
mindCrime has joined #lisp
_jrjsmrtn has joined #lisp
__jrjsmrtn__ has quit [Ping timeout: 240 seconds]
jeosol has quit [Quit: Connection closed]
<beach>
Good morning everyone!
Alfr is now known as Guest31604
Alfr has joined #lisp
Guest31604 has quit [Ping timeout: 250 seconds]
mindCrime has quit [Ping timeout: 252 seconds]
klltkr has joined #lisp
klltkr has quit [Client Quit]
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
wooden has quit [Ping timeout: 268 seconds]
karlosz has joined #lisp
jeosol has joined #lisp
waleee-cl has quit [Quit: Connection closed for inactivity]
frost-lab has joined #lisp
abhixec has quit [Ping timeout: 240 seconds]
torbo has quit [Remote host closed the connection]
lotuseat` has quit [Remote host closed the connection]
<splittist>
If we're suggesting alternative numeric literal syntax, python allowing #\_ as a separator seems nice. 1_000_000 or #b1001_1001_1111 or #xDE_AD_BE_EF (:
<moon-child>
splittist: agreed
gioyik has quit [Quit: WeeChat 3.0]
tophullyte has quit [Ping timeout: 240 seconds]
g0d_shatter has joined #lisp
thinkpad has quit [Ping timeout: 268 seconds]
Nilby has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
aartaka_d has joined #lisp
thinkpad has joined #lisp
surabax has joined #lisp
random-nick has joined #lisp
<fiddlerwoaroof>
splittist: although, I sort of like the model used by the "numderline" font patching tool: make display conventions for numeric literals a font feature rather than actual source characters
<moon-child>
hmmm. I'm not really a fan of things like that
<moon-child>
(nor ligatures.) From the rendering side, I want my texteditor to be a relatively dumb grid of characters. Plus some colour, maybe
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
<fiddlerwoaroof>
I agree about ligatures
attila_lendvai has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof>
I think formatting numbers readably is more like syntax highlighting than ligatures, though
<fiddlerwoaroof>
The issue with a python-style 1_000_000 is, now I have all sorts of issues when I want to copy the numbers from my source code somewhere else
contrapunctus has joined #lisp
anticrisis has quit [Quit: Leaving]
<fiddlerwoaroof>
And similar issues if *PRINT-PRETTY* decides to include the grouping character
<fiddlerwoaroof>
I sort of wonder if the issue could be solved with a font-lock rule for which characters to color slightly differently
ljavorsk has joined #lisp
<moon-child>
colouration could work, but I think I prefer inline _. Copy-pasting--is that really such a concern? I almost never do that. In particular, I don't think it's particularly reasonable to expect forms from one language to be compatible with forms from another, as a general rule
* White_Flame
slowly slides the term "presentation" into the conversation
[mark] has joined #lisp
mrchampion has quit [Ping timeout: 240 seconds]
<Nilby>
There's this 10̦000̦00 or this 10̲000̲00 but I think they're more trouble than they're worth.
<fiddlerwoaroof>
White_Flame: exactly
<White_Flame>
dead text chars are an anti-pattern
<moon-child>
White_Flame: do you avoid whitespace, then?
<fiddlerwoaroof>
moon-child: copy-pasting isn't a huge concern, but I find it irritating when I have to reformat basic data types between langauges
<White_Flame>
solving these issues necessarily means replacing ecosystems
<fiddlerwoaroof>
Print syntax is more important here than read syntax, though
<fiddlerwoaroof>
Anyways: Excel and other spreadsheet tools have all sorts of nice number formatting options
<fiddlerwoaroof>
It'd be great for me to be able to set such display options on a variable-by-variable basis :)
hendursaga has joined #lisp
<White_Flame>
hmm, but when copying a cell (at least in libreoffice), you get the presentation form, not the raw form
<fiddlerwoaroof>
White_Flame: that's sort of a bug, though
<Nilby>
Now you just need a thing to show it.
<fiddlerwoaroof>
And, I don't think Excel has that limitation: at least, you can choose whether to paste the display formatting or the values at paste time
<Nilby>
There have been Lisp systems where symbols have special presentation.
<White_Flame>
I mean pasting into a text editor
<fiddlerwoaroof>
Well, that's because of limitations of the normal copy/paste protocols
<fiddlerwoaroof>
And/or the application's use of them
<White_Flame>
yep. The general problem IMO is the Unix/C model of naked char buffers for everything
<fiddlerwoaroof>
macOS, at least, has typed clipboards
<fiddlerwoaroof>
And you can request data of a certain type from the clipboard
GZJ0X_ has quit [Remote host closed the connection]
<moon-child>
sounds like COM
<White_Flame>
pretty sure such things are in windows & linux, too
GZJ0X_ has joined #lisp
<White_Flame>
but in the latter, the stars have to align through the bazaar
<fiddlerwoaroof>
In fact, macOS's biggest technical advantage is that it's _not_ based on the Unix/C model of text everywhere for the user-facing parts
GZJ0X_ has quit [Remote host closed the connection]
<White_Flame>
yep
<fiddlerwoaroof>
It's based on the Objective-C runtime, which is basically a limited Smalltalk
GZJ0X_ has joined #lisp
<splittist>
The most important syntax is the one I'm presenting to myself in my source code: did I just type one hundred million or a billion? Let me move my cursor over the number as I count... 100_000_000 makes it obvious to my most important reader - me (:
<jdz>
splittist: #.(truncate 1.0e8)
<jdz>
But yes, I sometimes struggle with numbers like these, too.
<jdz>
Usually by moving cursor to position 3 from the right, and then selecting 3 next digits left.
<White_Flame>
##Eleventy_Billion
<jdz>
And hoping that counting the rest will not be a problem.
<White_Flame>
(ah, ## is already taken)
<jdz>
#r should be extended to accept #\" as the base, so then: #r"one hundred million billion".
<moon-child>
haha
rudi has joined #lisp
<fiddlerwoaroof>
this is sort of interesting, in Emacs: (gui-get-selection 'CLIPBOARD (intern "text/html"))
<fiddlerwoaroof>
e.g. copy from LibreOffice Calc and then run that
<fiddlerwoaroof>
(gui-backend-get-selection 'CLIPBOARD 'TARGETS) shows all the possible target formats
aartaka has joined #lisp
semz has quit [Ping timeout: 250 seconds]
<Nilby>
The natural way of representing numbers is of course recursive, so any linearization into bits is somewhat fake.
<Nilby>
and hard to type
aartaka_d has quit [Ping timeout: 265 seconds]
<moon-child>
'hard to type' I would rather type 7 than (S (S (S (S (S (S (S Z)))))))
<Nilby>
You
<Nilby>
You'd only have to type the last S, since you'd have the others hanging around;
<Nilby>
Exceopt in the very early or non-viable universes.
<Nilby>
Also 1e6 is quite composite.
f4r5 has joined #lisp
mrchampion has joined #lisp
Necktwi has joined #lisp
skapata has quit [Ping timeout: 260 seconds]
kevingal has joined #lisp
skapata has joined #lisp
<jdz>
The problem with "scientific notation" is that it only works for many trailing zeroes.
<moon-child>
right
<no-defun-allowed>
1e#.1e100
<moon-child>
1.273849e6 isn't better than 1273849
skapate has joined #lisp
skapata has quit [Ping timeout: 260 seconds]
<Nilby>
And worse, they aren't really zeros in binary.
<moon-child>
well, they can be
<moon-child>
100 is 1100100b--both of them have 2 trailing zeroes ;)
<contrapunctus>
Shinmera: it seems you changed the licenses for some of your projects from Artistic to zlib, but the accompanying web pages still name the former as the license. I figured you might want to update them, to avoid confusion.
ech has joined #lisp
<Shinmera>
I might want to, but it's very low on my priority list.
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
skapata has joined #lisp
skapata has quit [Remote host closed the connection]
<contrapunctus>
Shinmera: is your website not in a repo I can make a PR for? 🤔 I couldn't find a repo. Or, wait, are those generated docs?
skapata has joined #lisp
<Shinmera>
each repo has a docs/ folder. That's where the sources are for those. And yes they're generated, but once per repo, so it's a pain in the ass.
skapate has quit [Ping timeout: 260 seconds]
skapate has joined #lisp
skapata has quit [Ping timeout: 260 seconds]
amb007 has quit [Read error: Connection reset by peer]
amb007 has joined #lisp
JohnMS_WORK has joined #lisp
ljavorsk has quit [Remote host closed the connection]
ljavorsk has joined #lisp
lotuseat` is now known as lotuseater
heisig has quit [Quit: Leaving]
l1x has quit [Quit: Connection closed for inactivity]
GZJ0X_ has quit [Remote host closed the connection]
vegansbane6963 has joined #lisp
GZJ0X_ has joined #lisp
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
<Nilby>
You could use #+(or swank slynk) . I'm not sure what you mean by import though. It's probably best to make it work without special code.
<Demosthenex>
Nilby: i'm trying to make it so that i can eval my buffer to load it into repl, and there are assumptions made about the path... so i'd like to wrap that in some code wwhich detects that i'm running in swank/sly/slime so i can address the mising data
conjunctive has quit [Quit: Connection closed for inactivity]
<Nilby>
Ah. There's lots of ways to address the issue. #+ conditionals are the simplest, but maybe most brittle. You could also use logical-pathname-translations, to make a path prefix, then say (load "my-stuff:foo.lisp") But, loading with asdf or quicklisp is probably the most usual.
<Demosthenex>
maybe i need to wrap my final code in a main function, and then only call that when i use --script
terpri has joined #lisp
ech has quit [Ping timeout: 240 seconds]
thinkpad has quit [Ping timeout: 240 seconds]
thinkpad has joined #lisp
<Demosthenex>
is there a way i can say "call (main) only if called from sbcl --script, ie: not sly?"
<Nilby>
If you're using reader conditionals, you can use the negative: #-(or swank slynk)
<Demosthenex>
Nilby: cool, i'll try that
<Nilby>
But perhaps it's best to put whatever you want to do only interactively in separate function.
<Nilby>
Or what you want to do only in a script in separate file.
hendursaga has quit [Quit: hendursaga]
hendursaga has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
rumbler31 has quit [Remote host closed the connection]
xkapastel has joined #lisp
rumbler31 has joined #lisp
X-Scale` has joined #lisp
X-Scale` is now known as X-Scale
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
thinkpad has quit [Ping timeout: 252 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
GZJ0X_ has quit [Remote host closed the connection]
thinkpad has joined #lisp
GZJ0X_ has joined #lisp
galex-713 has quit [Ping timeout: 260 seconds]
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
GZJ0X_ has quit [Remote host closed the connection]
GZJ0X_ has joined #lisp
galex-713 has joined #lisp
charles` has quit [Ping timeout: 258 seconds]
ebrasca has joined #lisp
thinkpad has quit [Ping timeout: 246 seconds]
thinkpad has joined #lisp
APic has quit [Ping timeout: 268 seconds]
<rumbler31>
Xach: I don't know if this would be useful to have in quicklisp, but I wrote a function to copy a single local project into the bundle directory. Problems that I see with adopting it are that I don't yet account for dependencies that might need to be pulled in from other local projects, and discovery of the bundled location on the user's behalf (which might be impossible)
<rumbler31>
the goal is to reduce the amount of code that makes it into the bundle, I don't want all of my local projects to get pulled in
APic has joined #lisp
<rumbler31>
are you aware of any other problems with this approach that I might have missed?
<Xach>
rumbler31: how does it copy things?
<rumbler31>
you mean what library does it use?
APic has quit [Ping timeout: 240 seconds]
<rumbler31>
I'm not in front of the code but I think I use asdf to find the named package locations, make pathnames for each of the .lisp and .asd files found in that directory to the location of the bundle/local-projects/myproject folder and does a uiop file copy
<Xach>
quicklisp does not depend on UIOP
<rumbler31>
I think I can just crib the code and write it myself
<rumbler31>
unless there are licensing issues
<rumbler31>
but isn't uiop brought in by asdf?
GZJ0X_ has quit [Remote host closed the connection]
APic has joined #lisp
<Xach>
Sure. But I don't put references to UIOP into quicklisp client code.
brandflake11 has joined #lisp
amk has quit [Ping timeout: 252 seconds]
<Xach>
rumbler31: I'd look at what ql-minitar does, I think, except copying from filesystem files rather than a tar stream.
amk has joined #lisp
<brandflake11>
Hello all. Have you worked with extremely large datasets in lisp before? I'm trying to load in a huge list to use with lisp (800000+ lines), but it seems like sbcl freezes everytime I do that. Do I just have to wait for it to load in, even though sbcl says it's not taking any cpu? What has been your experience with large datasets in lisp?
<Xach>
brandflake11: sometimes the freeze is when it tries to print the result, not loading or working with it. one option is to set *print-length* to something like 100.
<Xach>
brandflake11: using too much memory results in a different symptom (landing in ldb or crashing outright)
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
<brandflake11>
Xach: I see. Let me test limiting *print-length* and see what happens
<Nilby>
I've used much bigger datasets and the important thing is set --dynamic-space-size high enough, and don't print it.
rumbler31_ has joined #lisp
<brandflake11>
Nilby: I don't know anything about dynamic-space-size. Do you set this when loading sbcl, or can you set it with a global variable?
<Xach>
brandflake11: it's a command-line argument
<Xach>
brandflake11: cannot be adjusted at runtime
<brandflake11>
Xach: Okay, I'll look at the man page to see more about it
ljavorsk has quit [Ping timeout: 240 seconds]
<brandflake11>
If *print-length* is nil, does that mean there is no limit?
<phoe>
yes
<brandflake11>
Thanks!
<phoe>
CLHS says, "If [*PRINT-LENGTH*] is false, there is no limit to the number of components printed."
docl_ is now known as docl
<brandflake11>
Oh, I didn't know the hyperspec had info about global variables that are important.
<phoe>
it's the full rendition of the standard, it must have all the variables
<brandflake11>
Yep, that makes more sense. Thanks a lot all for the helpful advice!
<Nilby>
As you may know, a list isn't the best data structure for huge data sets.
zenandroid has joined #lisp
<phoe>
Nilby: huh?
<beach>
Nilby: That totally depends on the operations that are expected.
<Nilby>
Yes. Like anything except traversing it in order.
<phoe>
Nilby: I mean, what's the context?
<Nilby>
Also takes too much space.
<brandflake11>
Nilby: I took a .csv file and converted it into one big list of lists to then parse out later as OSC commands. At this point in my lisp journey, it seemed like the simplest option.
<brandflake11>
But I'm still having trouble getting the list to even load. I need to try to dynamic-space-size option
<phoe>
oh, I see the context now
<phoe>
brandflake11: how does it hang? if you're using slime/sly, check the inferior-lisp buffer
<phoe>
maybe you need more heap to be able to load this much at once, if you get an error about heap exhausted in there
<brandflake11>
I use a (with-open-file) function to load the file with just the list in it
<beach>
brandflake11: 800000 lines doesn't sound like much, depending on what a "line" is of course.
<brandflake11>
I'll check that buffer
<phoe>
yes, but how do you run Lisp? with slime/sly from emacs? just from the terminal?
<brandflake11>
With slime+emacs
<phoe>
in the former case, you can get the REPL to "hang" if the inferior lisp crashes hard
<phoe>
e.g. due to OOM
<brandflake11>
phoe: You are so right, I get this "Heap exhausted during garbage collection: 48 bytes available, 64 requested. "
<jdz>
Also it might be a good idea to process lines as they are parsed from the file (say by providing a callback function to run on each parsed line) instead of doing it in two stages.
<brandflake11>
I don't know how to mitigate the heap exhausted error!
<jdz>
Another option is to use two threads with a size-limited "line buffer".
<brandflake11>
jdz: Well, the list is a dataset with times of events and the events themselves. So, I want to be able to replay these events in order
<jdz>
And in the file they may be out-of-order?
<brandflake11>
jdz: No they are all in order
jonatack has quit [Quit: jonatack]
theothornhill has joined #lisp
<phoe>
brandflake11: run SBCL with a larger heap, if you have enough RAM
<brandflake11>
phoe: What command line option can you use to do that?
<phoe>
$ sbcl --dynamic-space-size $((8 * 1024))
<phoe>
that'll give you a 8 GB heap
zenandroid has left #lisp ["Leaving"]
<brandflake11>
phoe: Oh it's the same one, thank you and sorry for my lack of understanding!
<jdz>
I use a couple tricks when doing this on SBCL: a) if the text does not have any unicode characters coercing each line into SIMPLE-BASE-STRING, and b) if there are fields that may have duplicate (string) values longer than 8 characters then using a hash-table to de-duplicate them.
<brandflake11>
When doing this option with slime, do you just set the option in emacs's inferior-lisp-program variable?
<jdz>
brandflake11: Run slime a prefix argument.
<jdz>
I.e., C-u M-x slime
<phoe>
brandflake11: my elisp variable, inferior-lisp-program, is "ros dynamic-space-size=8192 -Q run"
<phoe>
so it sure takes multiple arguments
<brandflake11>
Oh nice.
<phoe>
(the only difference is that it runs SBCL via roswell)
<Nilby>
I just tested reading a 800+k line 217.3M csv with the naive list reader with --dynamic-space-size 4096 and it was fine. (The slow part is guessing the column data types)
<brandflake11>
I just set it to "/usr/bin/sbcl --dynamic-space-size 2048". I'll see what happens
<brandflake11>
I just set inferior-lisp-program I mean
Guest89487 has joined #lisp
<phoe>
should work
<phoe>
increase it further if 2GB is still too low
<phoe>
(you might need to download more RAM if you start swapping though)
<brandflake11>
lol, I have a fast internet connection, downloading more ram should be no problem XD
<brandflake11>
Where can you check the heap size at of sbcl while it's running?
Guest89487 has left #lisp [#lisp]
<brandflake11>
Will it just take more ram?
<phoe>
SB-EXT:DYNAMIC-SPACE-SIZE
<phoe>
it won't auto-expand, unlike e.g. CCL
<brandflake11>
I get DYNAMIC-SPACE-SIZE is unbound, so I'm guessing setting it where I did with the emacs variable didn't work
<phoe>
oh! it's a function
<phoe>
(SB-EXT:DYNAMIC-SPACE-SIZE) ;=> 8589934592
<brandflake11>
Okay, so here is what I got 3223322624
<Nilby>
also (room)
<brandflake11>
From room: Dynamic space usage is: 153,945,456 bytes.
<brandflake11>
That's not right, it should be 3GB
<phoe>
that's the used space
<phoe>
not the free one
<phoe>
but, 3223322624 === (* 1024 1024 3074)
<phoe>
which is just a wee bit above 3gb
<brandflake11>
Oh okay, so it did work.
<brandflake11>
Oh man, I'm glad you all helped me with this. I would not have been able to figure this out on my own
theothornhill has quit [Remote host closed the connection]
<brandflake11>
I was really worried lisp just wasn't able to handle huge datasets, but i'm glad that it was just a matter of increasing the ram allowed to it
leeren has joined #lisp
<Xach>
Lisp can handle all kinds of nutty stuff
<beach>
brandflake11: Either way, it would not be a language limitation, but a limitation on specific implementations.
ldbeth has joined #lisp
<ldbeth>
good evening
<brandflake11>
beach: I always forget about that too. I love how it is just a standard
<beach>
brandflake11: Also, it is not RAM that you are assigning, it is just heap size. If you have virtual memory, that would work too, but more slowly.
leeren has quit [Client Quit]
<brandflake11>
beach: Oh, that makes more sense
<Nilby>
There is even hope on the horizon that sbcl will be able to increase it's own memory.
<phoe>
yes, some of that heap can (and likely will) get swapped to disk by the OS
jonatack has joined #lisp
<phoe>
so you can have a 32G heap on 8G of RAM, if that is what you want and need
<brandflake11>
I'll have to give a shoutout to ssds then. They are a lifesaver
<ldbeth>
is it possible to transparently store lisp datum on disk via mmap
<brandflake11>
6gb wasn't enough yet for the list, so I'm trying 7 now!
<beach>
ldbeth: Probably not. You would somehow have to teach the garbage collector where to find it. Plus, the way a lisp object is represented is not standardized.
<Nilby>
Acutally there's a lisp mmaped databse
wsinatra has joined #lisp
<brandflake11>
I just got the database list assigned as a variable. You guys all rock. Thank you so much for the help and teaching me something
<brandflake11>
It's taking 9gb of space. Yikes!
<Nilby>
It's not totally transparent though
<brandflake11>
*memory
<ldbeth>
a list? :)
<Nilby>
brandflake11: What was the size of your file?
<ldbeth>
it it likly to save some memory if it is an array
<brandflake11>
The file itself as just text was about 800mb
<brandflake11>
That's pretty big for a plain text file isn't it?
ramHero has quit [Remote host closed the connection]
<jcowan>
back to numeric representations: in Scheme, #e forces a float-style syntax to be implemented as an exact number: thus #e1e20 is the integer 1^20, and #e1.5 is 3/2.
<jcowan>
Note that this is not just a coercion: 1e400 is normally infinity, but #e1e400 is the integer 10^400.
<phoe>
I don't think there's a standard CL way other than #.(* 1 (expt 1 20)) for integers and #.(rational ...) for ratios
<ldbeth>
make-load-form something
<Nilby>
9gb seems like something is taking too much seeing for a 800mb file
<jcowan>
s/1^20/10^20
<ldbeth>
Yes, ideally it should be around 1GB if applied some clever encoding
<brandflake11>
Nilby: maybe I did something wrong. I got it all loaded in though, so that's what I'm happy about
andrei-n has quit [Write error: Connection reset by peer]
<ldbeth>
for example, a trie can significantly reduce the space of string data
andrei-n has joined #lisp
ramHero has joined #lisp
<brandflake11>
Maybe I should just use cl-csv instead now. I couldn't get that to load in the .csv file (I didn't know about checking *inferior-lisp* buffer to see that the heap was too low) so I turned the .csv into a list of lists using bash sed.
<brandflake11>
That's when I came here to ask for help
<brandflake11>
Because that was also too big for the heap size
<beach>
brandflake11: What does your data look like?
<beach>
For example, if you have lots of empty strings, then the reader will allocate a separate empty string for each one. That could become quite wasteful.
[mark] has joined #lisp
<brandflake11>
beach: Oh, I wouldn't know how to mitigate that though
ted_wroclaw has joined #lisp
<brandflake11>
beach: Can you just turn "" into nil?
<beach>
You could do that, but if you do it after the thing is read, then you still need as much space, at least temporarily.
heisig has joined #lisp
<beach>
brandflake11: When I asked about duplication, I didn't necessarily mean the full list in your example, but also individual elements such as "1" or "10.50.209.134".
<brandflake11>
beach: Oh, yeah, in that case there is a lot of duplication
<beach>
Then, if those items are immutable, a hash table will do wonders.
<brandflake11>
beach: I'll look into hash tables. I have never used a hash table before. It's not hard to grasp is it?
<phoe>
not at all
<phoe>
ever heard of a data structure called a map?
<beach>
brandflake11: Wow, is Common Lisp your first programming language?
<brandflake11>
phoe: No I've never heard of a map either.
<beach>
brandflake11: Does your file consist of a single huge list, where each element is a list as in the example above?
<brandflake11>
beach: It's pretty much my first serious programming language. I am from the Music and Composition and Linux world, where I learned pure data as my first language. I learned a little bit of C++ on my own time last year, and then discovered common music, which brought me into common lisp. I love the syntax and realtime feeling of common lisp, so I've been learning it now to do other stuff
<phoe>
brandflake11: oh, nice!
<brandflake11>
beach: Yes, exactly, it's just a big list of those lists I showed you
<phoe>
wrt books, you might want to read either Gentle or Practical Common Lisp; I'd recommend that you start with the former, and if you find it too gentle indeed, then switch to PCL
<phoe>
minion: tell brandflake11 about gentle
<minion>
brandflake11: look at gentle: "Common Lisp: A Gentle Introduction to Symbolic Computation" is a smoother introduction to lisp programming. http://www.cs.cmu.edu/~dst/LispBook/
<phoe>
minion: tell brandflake11 about pcl
<minion>
brandflake11: please look at pcl: pcl-book: "Practical Common Lisp", an introduction to Common Lisp by Peter Seibel, available at http://www.gigamonkeys.com/book/ and in dead-tree form from Apress (as of 11 April 2005).
<brandflake11>
phoe: Oh yeah, I've gotten to chapter 3 of practical common lisp (not very far I know). I need to keep working at it
<phoe>
personally I think that the second chapter of PCL is the worst
<brandflake11>
Actually people on here recommend I read Practical Common Lisp. It was all thanks to this IRC channel!
<beach>
brandflake11: Then, what I would do would be to not read the entire thing with a single READ, but to read one element list (as in your example) at a time, then process it by checking whether an element is in a hash table, and if so, reuse it.
<beach>
brandflake11: Your memory use would drop dramatically.
<phoe>
oh wait, it's chapter 3
<brandflake11>
beach: Thank you I really appreciate your suggestion. I'll look into doing that to reduce memory
<phoe>
in my opinion, PCL chapter 3 goes straight into business without explaining that the first practical chapter with disc DB is likely not meant to be fully understood straight away and is rather meant to give the reader an overall feeling of how to work with the language
<phoe>
it's the only explanation I see for "chapter 3 is where we make a database, and chapter 4 is where we actually start explaining what we've done"
<brandflake11>
phoe: I stopped reading it because I was more interested in making music with Common Lisp. I've been reading Heinrich Taube's "Notes from the MetaLevel" at the moment instead to get more music making done
<brandflake11>
phoe: Thank you though, I plan on keep going with it. I want to be able to do cool stuff with lisp
<phoe>
oooh, I see
<phoe>
does this book use common music?
<brandflake11>
Yes, the old Common Music 2.0 that still used common lisp
<phoe>
TIL!
* phoe
memorizes
<brandflake11>
phoe: There is a version of Common Music that integrates a realtime midi out using incudine. That's the version I'm using now
<brandflake11>
I'm able to use emacs as my music composition tool, which is really cool and spit out midi through jack to my synths and other toosl
<brandflake11>
C-t toosl
contrapunctus has joined #lisp
rumbler31_ has quit [Ping timeout: 240 seconds]
rumbler31 has quit [Ping timeout: 260 seconds]
brandflake11 has left #lisp ["ERC (IRC client for Emacs 27.2)"]
<Bike>
it's not as sophisticated, but you could also suspend the emacs process with probably control z
bjorkintosh has joined #lisp
cosimone has quit [Remote host closed the connection]
<CL-ASHOK>
but would that stop Hunchentoot?
<Bike>
i don't remember
<CL-ASHOK>
No worries, thanks for your help. I will use screen
rumbler31 has quit [Remote host closed the connection]
rumbler31 has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
jeosol has quit [Quit: Connection closed]
vv8 has quit [Ping timeout: 265 seconds]
f4r5 has quit [Ping timeout: 240 seconds]
CL-ASHOK has quit [Ping timeout: 240 seconds]
slyrus has quit [Remote host closed the connection]
slyrus has joined #lisp
contrapunctus has joined #lisp
ramHero has quit [Remote host closed the connection]
ramHero has joined #lisp
f4r5 has joined #lisp
APic has quit [Ping timeout: 265 seconds]
hiroaki has quit [Ping timeout: 260 seconds]
hiroaki_ has quit [Ping timeout: 260 seconds]
CL-ASHOK has joined #lisp
curtosis has joined #lisp
rudi has quit [Quit: rudi]
jorts is now known as nckx
hiroaki_ has joined #lisp
hiroaki has joined #lisp
kpoeck has joined #lisp
mindCrime has joined #lisp
Inline has joined #lisp
Jesin has quit [Ping timeout: 268 seconds]
CL-ASHOK has quit [Ping timeout: 240 seconds]
cosimone has joined #lisp
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
<jcowan>
NOTHING CAN STOP HUNCHENTOOT
eden has quit [Ping timeout: 240 seconds]
mindCrime has quit [Ping timeout: 240 seconds]
supercoven has quit [Ping timeout: 268 seconds]
kini has quit [Ping timeout: 258 seconds]
varjag has joined #lisp
krkini has joined #lisp
jurov has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
jurov_ has quit [Ping timeout: 246 seconds]
akkad is now known as ober
contrapunctus has joined #lisp
curtosis has joined #lisp
hypercube has quit [Ping timeout: 252 seconds]
cosimone has quit [Remote host closed the connection]
Codaraxis__ has joined #lisp
Codaraxis_ has quit [Ping timeout: 240 seconds]
cosimone has joined #lisp
Lord_of_Life_ has joined #lisp
White_Flame has quit [Ping timeout: 252 seconds]
Lord_of_Life has quit [Ping timeout: 268 seconds]
Lord_of_Life_ is now known as Lord_of_Life
nij has joined #lisp
<nij>
Hello, is there any functional "package manager" (or rather, system manager) for common lisp? I'm thinking of it as an analogue of straight.el (for elisp).
<gabc>
Well there's quicklisp
<gabc>
And it's quite functional
<nij>
"functional" in that a declarative file can reproduce all systems
<gabc>
yeah I made a cheap pun of "functional" that "it does its function well"
<Shinmera>
nij: what does it mean to 'reproduce all systems'? Download them? Load them into the image?
<nij>
Shinmera: just to download them.
<nij>
For example, straight.el lets you do this : (el-patch :type git :host github :repo "raxod502/el-patch")
<Shinmera>
just put (ql:quickload '(a b c)) into a file then or is that not declarative enough
<nij>
With this in a declarative file, which is run by the package/system manager, the corresponding package/system will be fetched.
<nij>
Shinmera: yes, that's what I do now.
<nij>
However, can I specify the versions and recipes of the packages/systems?
<Shinmera>
No, quicklisp packages snappshots of the ecosystem so that all the libraries are versioned as one thing at once, since usually systems do not specify versioned dependencies.
<nij>
E.g. I might want ql to fetch the system from a specific repo (maybe even local!).. and I might want a specific version/commit.
<nij>
Shinmera: "systems do not specify versioned dependencies"... really?!
slyrus has quit [Remote host closed the connection]
<Shinmera>
yes.
<nij>
Uh oh..
<Shinmera>
ASDF cannot deal with knowing multiple versions of the same system at once. It'll only accept one.
<waleee-cl>
nij: if you put it in ~/common-lisp or the appropriate subdir of ~/quicklisp it will be preferred
slyrus has joined #lisp
<waleee-cl>
(before the version in quicklisp)
<Shinmera>
So you'll have to either manage the system registry manually, or replace ASDF wholesale.
dtman34_ has quit [Ping timeout: 252 seconds]
<Shinmera>
I want to do the latter at some point and have some fun ideas for it, but am wholly lacking in time lately.
<nij>
waleee-cl: yeah.. but that doesn't feel functional and declarative :-(
long4mud has quit [Read error: Connection reset by peer]
<waleee-cl>
also not declerative since you need to run a separate binary
hypercube has joined #lisp
<nij>
What if A1 and A2 depend on A, and suddenly A has a new version.
<nij>
Say A1 follows and depends on the new A, but A2 does not..
<waleee-cl>
go for guix then?
long4mud has joined #lisp
aeth_ has joined #lisp
<nij>
Tried (trying..). It's very hard.
<Shinmera>
nij: then either it breaks at compile time and quicklisp won't release a new dist until it's fixed, or it breaks at runtime and users will complain until it's fixed.
slyrus has quit [Ping timeout: 260 seconds]
<Shinmera>
usually the former.
<nij>
Wow. So suppose A is what many things depend on.. say Alexandria, and say one day A upgrades.
aeth has quit [Ping timeout: 252 seconds]
<nij>
If one single system doesn't upgrade accordingly, quicklisp won't accept the newer Alexandria?
<Shinmera>
no, quicklisp won't do a release at all.
<nij>
:-O !!!
<nij>
This is so wrong. (sorry if it's offending..)
<Shinmera>
ql doesn't depend on anything, but clpm depends on a lot of things.
<Shinmera>
ql has a much harder target than clpm.
<Lycurgus>
so it's sayin it can depend?
jeosol has joined #lisp
<nij>
Well.. I guess all sorts of package managers suffer from the same issues - except things like nix or guix.
<nij>
So this model has been working for years. I shouldn't say it's so wrong then :-( My apology.
<Lycurgus>
(where ql don't)
<Shinmera>
nij: It's not great, but it's the best Xach can do with the ecosystem we have (particularly ASDF)
<Bike>
multiple versions of the same library can't really exist in the same image, anyway
<Shinmera>
yes but the build system can select the best version to actually load.
<Bike>
i guess if they wanted to they could do things with packages
<fiddlerwoaroof>
I also like that this model encourages people to not make breaking changes :)
<Shinmera>
that would already go a long way to remedying this mess.
<fiddlerwoaroof>
My personal policy is to fork and rename rather than push a breaking version
<Shinmera>
phoe: ping about your verbose issue
<fiddlerwoaroof>
And, I think Rich Hickey's critique of semver is really on the mark here
<Shinmera>
semver does suck.
<nij>
fiddlerwoaroof: what's his critique about?
<fiddlerwoaroof>
In the JS world, there's so much useless time spent fixing breaking version changes
<fiddlerwoaroof>
Very few breaking changes are actually worth it, if you account for the cost to your users
<fiddlerwoaroof>
Especially for libraries
<nij>
Why not using guix/nix then?
<fiddlerwoaroof>
Because those don't actually solve the problem
aeth_ is now known as aeth
<fiddlerwoaroof>
When I pin a guix/nix version, I'm opting out of bug-fixes and security fixes
<nij>
Well.. you can pin an interval of versions..
<nij>
And in the classical model as well.. say in the case of ql, if no releases is given, bug/security fixes are out of reach too.
<nij>
;; interval of versions ==> I retract! I'm not actually sure about this.
<fiddlerwoaroof>
What I mean is just that, if library authors rename rather than introduce breaking changes, updating libraries becomes relatively safe
<fiddlerwoaroof>
And breaking changes become reportable bugs
<Shinmera>
This assumes that packages are actually self-contained and don't have changes that influence other parts
<fiddlerwoaroof>
What do you mean by "packages"?
<mfiano>
oh the whole accretion vs concretion talk?
<fiddlerwoaroof>
I think this is the spec talk
<Shinmera>
fiddlerwoaroof: lisp packages?
White_Flame has joined #lisp
<Shinmera>
fiddlerwoaroof: a system can affect other parts than the packages it declares and modifies though.
<fiddlerwoaroof>
Cool, yeah: two systems modifying the same Lisp package seems like a bad practice
<mfiano>
Depends what you mean by modify.
cage_ has quit [Quit: Leaving]
<fiddlerwoaroof>
Yeah, actually implementing this completely ranges from difficult to impossible, but I think it's useful to approach distributing libraries with this mindset
<fiddlerwoaroof>
I think Rich Hickey's ideal world involves something like a spec/test registry inside your library manager (QL, or such) that rejects updates that cause existing tests/specs to fail
<Shinmera>
mfiano: for instance systems can offer generic functions to extend, or hook lists that another system might latch on to. Just making two packages won't resolve the conflict, then.
<fiddlerwoaroof>
So, quicklisp would refuse to update a package unless all the pre-existing tests past, as well as any newly added tests
<Shinmera>
Anyway, the point being that it's not always that easy to allow multiple versions at once.
<fiddlerwoaroof>
I sort of think of the goal is to make the idea of "versioning" obsolete
Necktwi has quit [Quit: Lost terminal]
<fiddlerwoaroof>
Every change to the code of an existing symbol is backwards compatible and backwards incompatible changes force a rename
Lycurgus has quit [Quit: Exeunt]
<fiddlerwoaroof>
mfiano: thinking about it, the talk also talks a lot about accretion
<mfiano>
yes, hickey's stance on semver talked a lot about "accretion" and "concretion"
<fiddlerwoaroof>
"any breaking change (i.e. a major version bump in semver) might as well be considered another product/package/lib and should better choose another name instead of pretending to be the same thing with a bumped number."
tom-bsd has joined #lisp
<mfiano>
I don't agree with a lot of it, but he makes _some_ good points
<fiddlerwoaroof>
Whether or not this is practical, it's extremely appealing for someone who's dayjob is all JS/React stuff
<Odin->
Practical is usually the first thing out the door when computer ideas evolve.
<fiddlerwoaroof>
Also, I think people who force themselves to always keep their dependencies up to date find themselves rejecting libraries that exhibit a pattern of breaking changes
<fiddlerwoaroof>
I know I do
<mfiano>
My solution it the Lisp curse. I rarely find libraries that are production ready/suitable for my needs, so I write my own :x
<mfiano>
is8
<mfiano>
is*
<fiddlerwoaroof>
mfiano: I generally try to fork and PR
<no-defun-allowed>
Well spooked my prototypes
<fiddlerwoaroof>
or just fork
<nij>
mfiano: respect
<mfiano>
Not good at understanding someone else's thought processes with heravy macros and protocols that I would have never designed.
<fiddlerwoaroof>
But, the Lisp curse isn't really a lisp-only thing
<mfiano>
Lisp is tyoo flexible in that it has a larger burden for onboarding new collaborators due to that
<nij>
mfiano: how do you do versioning of your own code?
<fiddlerwoaroof>
A lot of people I've worked with are really unwilling to take a dependency because of the ongoing maintenance cost the dependency's lifecycle imposes
dtman34 has joined #lisp
<tom-bsd>
Hey guys. I'm on FreeBSD trying to install some quicklisp libraries with SBCL and it gives me errors like `Can't create directory /usr/local/lib/common-lisp/alexandria/sbclfasl/`. It's probably a permissions problem but isn't there a way to install these libraries to my home?
<fiddlerwoaroof>
mfiano: yeah, although I tend to find that just forcing myself to fix the problem I find in a library really helps
<mfiano>
For my own stuff, I haven't ever got to what the script iddies call 0.1.0
<mfiano>
So i odn't have any users
<Odin->
The "every tiny task a dependency" mentality is quite recent, too.
slyrus has joined #lisp
<Odin->
So its absence can't really be a Lisp-specific thing.
<Odin->
At the very least it should effect Fortran, too. :p
<mfiano>
My software is always pre-0.1.x, use at your own risk. Mostly because gamedev and support libraries are hard.
<Odin->
tom-bsd: I thought the default way of install Quicklisp did that...
<fiddlerwoaroof>
As far as I can tell, "NIH syndrome" cuts both ways
<mfiano>
I recently moved them to my own private host and stoped releasing to QL
<fiddlerwoaroof>
It's a choice between an ongoing maintenance cost for in-house tools, or an ongoing maintenance cost whenever some random person decides to update the tool
anticrisis has joined #lisp
<nij>
mfiano: ?! How about the old versions?
<nij>
What if some systems depend on your codes?
<mfiano>
What is released is still pulled by Xach each month
<tom-bsd>
Odin-: quicklisp is installed locally but loading libraries complains about making the aforementioned folder
<no-defun-allowed>
Imagine complaining about flexibility and being able to do things yourself, this meme made by "who the fuck actually believes in the Lisp 'curse' lmao" gang
<mfiano>
That was requersted by Xach and phoe iirc. I don't mind I guess, but I'm not interesting in developing for others. My code is MIT and anyone can use/fork do whatever, and I don't have to "fix" it for their strange use cases
andrei-n has quit [Quit: Leaving]
<no-defun-allowed>
Man, your head is haunted, you have bats in your belfry!
dtman34 has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
<nij>
mfiano: can i still see your code online?
<mfiano>
I liked it best when I wrote code before code on the internet was a thing. Nobody likes my code, but I do, so problem solved.
<Odin->
no-defun-allowed: That reads like something Max Stirner would have written.
<fiddlerwoaroof>
The lisp curse thing is Mark Tarver, right?
<no-defun-allowed>
Odin-: Nope, never heard of this Max Stirner :)
<no-defun-allowed>
fiddlerwoaroof: W*nestock
<nij>
mfiano: do you work in tech? How do you stick with just cl?
<mfiano>
nij: yes, git.mfiano.net
shka_ has quit [Ping timeout: 268 seconds]
<Odin->
no-defun-allowed: I'll just put it down to endless spooks, then.
<mfiano>
yes usually CL, though not currently, but i heard a clojure contract is coming my way soon.
<no-defun-allowed>
Odin-: Duped egoists? In _my_ #lisp? It's more likely than you think.
<Odin->
Ah, so it _was_ sarcasm. I'll need to recalibrate my meter, then.
<fiddlerwoaroof>
no
<mfiano>
Maybe one day when I actually make something usable, complete with offline documentation, manuals, books, etc, I'll publicize my stuff.
* no-defun-allowed
hoped the :) gave it away
<moon-child>
I don't think the 'lisp curse' thing is _incorrect_, strictly, it just reflects a perversion of sensibilities and morals
<fiddlerwoaroof>
no-defun-allowed: but it was based on "The Bipolar Lisp Programmer" by Tarver
<mfiano>
But I am pretty far from that
<fiddlerwoaroof>
My read on Tarver is that he bought into stuff thinking that it would mean he would get free work on Qi/Shen and then got really annoyed to discover that using the GPL didn't mean that people would be interested in his project
<nij>
:golden-utils <3
<no-defun-allowed>
My own (actual) argument is that for any progress to be made any time soon, you do in fact need to produce half-assed prototypes, and only from there is it reasonable to start talking about a common design based on what information you have.
<mfiano>
Rich Hickey did make one point that has always stuck with me. Most programmers, and especially Lispers, are too focused on code, and not the artifact. Does the code matter if it doesn't provide something innovative or to fill a niche in computing?
<fiddlerwoaroof>
I think this also is behind the whole Lisp Curse thing:.
<fiddlerwoaroof>
I don't find that sort of point all that interesting
<nij>
mfiano: besides of your :golden-utils, do you use other utils often?
<fiddlerwoaroof>
90% of the code I write I write because it solves a problem I or the company I work for has
<mfiano>
nij: Just that, which includes alexandria re-exported
<no-defun-allowed>
So the faster I can crank those out the better. But it's also falsely applied when two projects have similar but incompatible design goals, which annoys me further.
<fiddlerwoaroof>
I think treating "filling a niche in computing" this way has a tendency to create projects that never actually finish
<nij>
mfiano: since 2008? Holly's cow!
<nij>
mfiano: what if alexandria upgrades itself one day?
<no-defun-allowed>
For example, one very clever HN poster complained people made too many array processing libraries. To pick two arbitrarily: one uses lazy arrays which you must manually force computation of. One is feature-compatible with numpy. The latter precludes the former, so it is nonsense to say they are redundant.
<fiddlerwoaroof>
nij: alexandria is probably the last library to do that
<fiddlerwoaroof>
It also has a versioned package scheme
<Odin->
no-defun-allowed: "There is more than one programming language! How wasteful!"
<nij>
fiddlerwoaroof: why?
<nij>
I mean "the last"..
<fiddlerwoaroof>
Because the developers of alexandria are really picky about the code they accept
<fiddlerwoaroof>
The breaking changes, afaict, are all in ALEXANDRIA-2
<mfiano>
fiddlerwoaroof: I am perfectly fine with that. I program to learn, not to create. But I'm not focused on designing new macrology usecases, MOP, or other meta-programming. My current project is roughly 40kloc, and all my brain power is whiteboarding and cranking out code I need for the artifact, not how I can bend the language with more yaks
<fiddlerwoaroof>
:)
tom-bsd has quit [Quit: ERC (IRC client for Emacs 27.1)]
<mfiano>
I would be doing it in any other language if some dude 20 years ago didn't rip Python out of my hands to show me that CL was better at RAD
<no-defun-allowed>
And I think that to make a library which supports both, you would need people aware of compiling either. But if APL implementations weren't doing lazy computation behind the back, or we picked something completely new, I doubt the magical utopia where everyone does one library per concept would have ever discovered that it might be useful.
<fiddlerwoaroof>
Yeah, I've never understood the desire to have _a_ array programming library
<no-defun-allowed>
Odin-: That continues to the "wheels in the head" point, so on and so forth.
<fiddlerwoaroof>
"picky" is probably the wrong word, too negative
<mfiano>
One of the last changes I made was quite a few years ago, admittedly
<no-defun-allowed>
(Then for the actually hard stuff, e.g. compiling pattern matching, you still have few people attempt to do it well, and so there is still approximately 1 pattern matcher used in CL. I'm just remembering what I wrote in the book.)
<fiddlerwoaroof>
The developers of alexandria seem generally committed to a no-backwards-incompatible changes philosophy
<mfiano>
It was rewriting LERP to use the numerically stable method (at the cost of an extra multiply, which smart compilers could fuse it, so the precision is well worth it)
<fiddlerwoaroof>
no-defun-allowed: yeah, trivia
<fiddlerwoaroof>
I've always had mixed feelings about it
<fiddlerwoaroof>
Pattern matching, like CASE and friends, is a static dispatch technique, and I generally try to use dynamic-dispatch wherever possible :)
<Odin->
no-defun-allowed: I'm just always a little interested in how people seem to simultaneously consider software development to follow completely different rules from other productive activity and expect it to function exactly the same.
gaqwas has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
Sure, I am not making a comment on pattern matching though, but there are a few methods to compile it, and they require some effort to make. You can make the language bend as much as you want, but the algorithm has to get in there somehow.
<fiddlerwoaroof>
This might be a sign that I learned to program from 90s books about OOP, but I have an aversion to conditionals that can't be extended without modifying the code
slyrus has quit [Remote host closed the connection]
<mfiano>
eric normand gave a good talk last week about the wrong direction software development is taking, and i have agreed with that for a good 10 years
<fiddlerwoaroof>
Yeah
slyrus has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.2)]
<no-defun-allowed>
Odin-: Absolutely.
<fiddlerwoaroof>
mfiano: one really clarifying thing for me about Lisps/FP/etc. was listening to the episode of Cognitect's podcast featuring Matthew Flatt (of Racket fame)
surabax has quit [Quit: Leaving]
hiroaki has quit [Quit: Leaving]
<mfiano>
I am not familiar with it, but given the number of talks I've seen on FP and the like, and my short-term meory, that isn't surprising
<fiddlerwoaroof>
At one point the host just sort of asserted the Clojure dogma `data > functions > macros` and Matthew Flatt responded, "actually I think functions > macros > data"
mood_ is now known as mood
<mfiano>
I don't see the correlation
<fiddlerwoaroof>
Clojurians like to say "try to solve a problem by representing it with data, then use functions if that doesn't work and finally use macros"
vv8 has joined #lisp
<fiddlerwoaroof>
I've come to think that one should almost always prefer functions and macros to data representations (especially raw data literals in code)
<mfiano>
I tend to write functions always, with the ocassional macro function.
<no-defun-allowed>
I found this excellent rule engine called EVAL, you should totally use it with...data yes that's data
<fiddlerwoaroof>
My experience is that a codebase built around domain-specific abstractions ends up being much more maintainable long-run, than a code base built around data
slyrus has quit [Ping timeout: 240 seconds]
<fiddlerwoaroof>
Because when you need to make an architecture change, you don't have to spend as much time tracking down data dependencies, you just re-implement the abstractions
aartaka has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof>
But, I've come to realize that Clojure just isn't designed for me
aartaka has joined #lisp
Jesin has joined #lisp
<mfiano>
Maintainable code comes from understanding the domain. How you use the constructs available matters less.
<mfiano>
and this is the point Normand was trying to hit last week
<fiddlerwoaroof>
I don't think that's really true: your understanding of the domain should be reflected in the language you build to write your software
<fiddlerwoaroof>
Domain knowledge should, almost always, be reified into the constructs of your programming language so you can program in the language of your domain
<fiddlerwoaroof>
Not following this principle creates huge messes for the people that maintain the code
<Odin->
No Turing tarpits for you, then?
<no-defun-allowed>
Something rubs me the wrong way about using maps and sequences for everything. Maybe I don't do the kinds of problems where those are fine.
<mfiano>
The point is general purpose abstractions, like design patterns as they are called in other languages, are just usually the result of one caring too much about the code and not how it should be structured for your domain. Maintainability just sort of falls out from a deep understanding of your field/and lots of whiteboarding.
<fiddlerwoaroof>
The biggest issue is you create an implicit dependency between line 40 with {:a 1 :b 2} and line 80 with {:a 1 :b 2}
<fiddlerwoaroof>
Then you refactor line 40 and nothing tells you line 80 is broken
<no-defun-allowed>
(Though for it to be "everything", we should define #{} to be 0, #{#{}} to be 1, so on and so forth.)
<fiddlerwoaroof>
mfiano: I agree with that, I just think saying "how you use the concepts available matters less" misses the point: understanding the domain is not enough, you need to write code that reflects your understanding of the domain
<mfiano>
There are whole periods of weeks where I can't write code because I'm still understanding the math, logic and how it all permutes to be written in a maintainable fastion. POD, mixins, design patterns...none of that matters until the domain is well understood
<Odin->
What's POD short for in this context?
narimiran has quit [Ping timeout: 240 seconds]
<mfiano>
plain old data
<fiddlerwoaroof>
Yeah, I'm sort of the opposite: I can't understand the domain without having a repl open to mess around with
<Odin->
Ah.
<Odin->
That old myth.
<fiddlerwoaroof>
I learn the domain by writing code in it
<mfiano>
I've had to work on serious projects professionally where we couldn't afford to make these types of mistakes that arise from "just coding"
<fiddlerwoaroof>
Most of the code doesn't actually make it to production
<mfiano>
Software development to me has always been moreso about thinking than coding.
<Odin->
There are still people who think there's really something called "plain text" in computers.
<Odin->
And that processors actually work with numbers. (Shocking, right?)
<fiddlerwoaroof>
It's just that I find iterating with prototypes designed to explore one corner of the search space ends up being more efficient than trying to think through the domain
White_Flame has quit [Ping timeout: 265 seconds]
cosimone has quit [Remote host closed the connection]
<TMA>
I have an experience that is in the middle between fiddlerwoaroof and mfiano. there is the exploration to learn something of the domain, which is usually ill specified and therefore not available with a priori reasoning alone
<TMA>
but there is also the need to pause and whiteboard, to build the model in the head prior to coding
<mfiano>
I'm also old and jadad, so can probably ignore my opinions :)
<fiddlerwoaroof>
TMA: yeah, when talking about these things I find that I occasionally express a position that sounds more extreme than it actually is
<fiddlerwoaroof>
I do spend time whiteboarding/learning, I just have also had the experience of a project where we spent weeks planning only to discover that what we thought was possible wasn't
orivej has quit [Ping timeout: 252 seconds]
<fiddlerwoaroof>
Within like 30 minutes of attempting to execute
<fiddlerwoaroof>
Or, in one case, a team insisting on like a month of onboarding training before I was allowed to write code
<fiddlerwoaroof>
Most of which was basically useless because I didn't really understand the context until I tried to change the code
<mfiano>
I could write a whole book on debunking the ECS paradigm some time...and I probably will. It amazes me how people flock to shiny things that just shift the shift the complexity around (and add new issues because they hadn't considering their design may require a new architectural model coupled to the domain.
<mfiano>
)
<TMA>
mfiano: I will refrain from ignoring your opinions, if I may. There is certainly much to be learned, even if there are minor corrections to be applied.
<no-defun-allowed>
I still need to write my implementation of "ECS" using CLOS for serial parts just to spite someone. But I forgot who I'm supposed to be spiting.
<mfiano>
EC couples with CLOS better than ECS
srandon111 has quit [Quit: leaving]
* Shinmera
wonders if he could find a way to use no-defun-allowed's time for his own projects by coercing her into spiting him for something
<mfiano>
A true ECS is impossible anyway, so can only go so far before you have stateful code
<no-defun-allowed>
Sorry, I have a waiting list of about three months, if you wouldn't mind writing your name and project down here then I'll get back to you then
<mfiano>
what are you working on no-defun-allowed ?
<fiddlerwoaroof>
no-defun-allowed: it sounds to me like you're just saying we have to make you angry enough
nij has joined #lisp
<nij>
If I get a cl system from guix, how do I load it? QL:QUICKLOAD doesn't look at those paths by default after all.
<no-defun-allowed>
mfiano: Right now, I just finished the first part of redoing my regular expression compiler, which was to use (and debug) someone else's technique for submatching with a DFA. Next is to add a protocol for letting the client provide optimisations (e.g. optimising constant string searching). Then I have to look after two lock-free hash table implementations.
<fiddlerwoaroof>
nij: you have to figure out how guix expects you to configure ASDF's registry
<mfiano>
no-defun-allowed: Did I not see a post a couple weeks ago stating you were not contributing to open source anymore or something of the sort?
<no-defun-allowed>
I announced I am taking a break from Netfarm because, wow, I'm actually too fed up with people there to bother improving their lives in any meaningful way. But now I also have a paper on that to edit.
<mfiano>
Is people of Netfarm, CL people?
<no-defun-allowed>
mfiano: Yes, now I've decided to work on other things because otherwise I have too much spare time :)
heisig has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
No, not CL people. The reasons why are off-topic for #lisp.
<mfiano>
The only mention I ever heard of it is from you, so I'm curious who these people are that annoyed you. Getting the torches ready
<mfiano>
Ok then. Well one thing I know all too well is breaks are good. I would never be able to commit to one project and stay sane.
<mfiano>
Mostly because I have to figure out hard problems on my own that require subconscious thinking
<mfiano>
If anyone wants to join me to polish up my game engine, I wouldn't mind
<nij>
fiddlerwoaroof: I guess I should ask #guix then.
<fiddlerwoaroof>
yeah, my guess is that reading guix expressions for something like nyxt might be helpful too
aartaka has quit [Read error: Connection reset by peer]
<fiddlerwoaroof>
my guess is that it involves `guix environment` but, unfortunately, I can't use guix because of their stance on mac support/free software
<no-defun-allowed>
In short, despite many differences of opinion on design, only one CL person has come close to saying that all my work is worthless.
<nij>
fiddlerwoaroof: thanks :)
<mfiano>
no-defun-allowed: all your work was worthless? i see a logic flaw already
nij has left #lisp ["ERC (IRC client for Emacs 27.2)"]
varjag has quit [Quit: ERC (IRC client for Emacs 28.0.50)]
karlosz has quit [Quit: karlosz]
kpoeck has quit [Ping timeout: 240 seconds]
rumbler31_ has quit [Ping timeout: 268 seconds]
lowryder has quit [Ping timeout: 250 seconds]
lowryder has joined #lisp
<Shinmera>
no-defun-allowed: I've had people almost word for word say all my libraries are worthless. The good thing is that doesn't actually matter.
<no-defun-allowed>
Shinmera: That was a slight simplification, they said any free software was worthless. Normally I'd be laughing, but no one there disagreed there. On the other hand, they could have been laughing internally as well.
<mfiano>
All my work is worthless, in the fact that it isn't usable by others, is broken until I finish it, and is unknown by others...but I still think it is very _worthwhile_ to work on given my goals of bettering myself and the hopeful one day it will at the very least be usable to me (and others would be a bonus)
<no-defun-allowed>
Pretty sure there is no network stack (and/or operating system) without any open-source components, including proprietary ones, so I wonder how they didn't contradict themself by being able to write that.
<no-defun-allowed>
What I read was straight slander, and there's no point discussing that in itself, but that it was taken remotely seriously is telling.
<Shinmera>
Yeah, unfortunately even obviously off crazy talk can still really get to ya.
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
<no-defun-allowed>
My thought process went something like "Here's my audience I suppose, if anyone would immediately be interested in e.g collaborative filtering for moderation it'd be them, and they're now saying no open-source program has done anything good for society. And half my time these days is spent cleaning up code and writing documentation. How kind of you!"
IPmonger has joined #lisp
Inline has quit [Ping timeout: 260 seconds]
pve_ has joined #lisp
pve has quit [Ping timeout: 252 seconds]
hendursaga has quit [Remote host closed the connection]
<dim>
that seems to happen a lot with SBCL 2.1.3, here loading list-of
<phoe>
huh, I remember an issue with SIGABRT mentioned somewhere in #sbcl
<dim>
it seems that CCL also just got a sigabort
<phoe>
oh? now that's interesting
<dim>
ccl64 -e '(ql:quickload "pgloader")' to reproduce
<dim>
I just cleaned my cache, too, so that might be related (in that it's trying to compile something?)
<dim>
I have CCL 1.12 for information
<fiddlerwoaroof>
This sounds like an FFI issue
<dim>
anyway I wanted to hack in CL and/or pgloader this vacations, but I guess I'll do something else instead :/
<fiddlerwoaroof>
I don't have that problem in 2.1.0
<scymtym>
SIGABRT is often from uncaught exceptions in C++ code
gitgood has quit [Quit: Probably away to do something really awesome]
<dim>
can I install sbcl 2.1.0 with brew easily?
<fiddlerwoaroof>
dim: I'm not sure, I'm using nix
klltkr has joined #lisp
<dim>
yeah doesn't look like it
<dim>
time to see if ECL can load pgloader these days
<phoe>
dim: actually it does seem so?
<phoe>
brew install sbcl@2.1.0
<phoe>
and/or brew switch sbcl 2.1.0
<dim>
Error: No available formula or cask with the name "sbcl@2.1.0".
<dim>
yeah that's when you have it already locally perhaps
<fiddlerwoaroof>
dim: what are you using? I'm on an x86-64 MBP, my M1 sees a lot more SIGABRTs with sbcl
<dim>
it's still an x64 and Catalina here, didn't make the jump to BigSur yet
<phoe>
huh, seems like you'd need to use an old formula or something... bleh
<dim>
I'm not sure I want to ;-)
<fiddlerwoaroof>
Big Sur is, in my experience, much better than Catalina
<fiddlerwoaroof>
I sort of skipped over Mojave and Catalina
<dim>
yeah except if you use/develop anything that doesn't know how to process EINTR when doing open(2), like Postgres and most of the source code I work with
<fiddlerwoaroof>
I see
<dim>
and except if you have hardware that doesn't support BigSur yet, too (I'm still waiting for drivers updates for an audio interface)
<dim>
but anyway, ECL is compiling, slowly, but making progress
jeosol has quit [Quit: Connection closed]
hjudt has quit [Ping timeout: 240 seconds]
g0d_shatter has quit [Quit: Leaving]
<dim>
Condition of type: SIMPLE-ERROR ; Unable to create pipe C ; library explanation: Too many open files.
<dim>
okay I'm done with hacking in CL for a while
<dim>
I had a nice shot tonight, won't happen again anytime soon if I must first fix all those things
<dim>
gn friends, and thanks for all the help you could provide, much appreciated as always!
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
abhixec has quit [Ping timeout: 252 seconds]
curtosis has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
karlosz has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
bitmapper has joined #lisp
jeosol has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
aartaka has joined #lisp
igemnace has joined #lisp
mindCrime has joined #lisp
contrapunctus has joined #lisp
aartaka has quit [Ping timeout: 246 seconds]
abhixec has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
gzj has joined #lisp
bilegeek has joined #lisp
contrapunctus has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
mindCrime has quit [Ping timeout: 240 seconds]
contrapunctus has joined #lisp
seok has joined #lisp
charles` has joined #lisp
contrapunctus has left #lisp ["Disconnected: Replaced by new connection"]
contrapunctus has joined #lisp
Kundry_Wag has joined #lisp
Kundry_Wag has quit [Client Quit]
Kundry_Wag has joined #lisp
Oladon has joined #lisp
tophullyte has quit [Ping timeout: 252 seconds]
jmiven has quit [Quit: reboot]
curtosis[away] has joined #lisp
jmiven has joined #lisp
mindCrime has joined #lisp
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]