<contrapunctus>
Does anyone know how to specify a foreign key using CLSQL's `create-table` ? I tried `(create-table [table-name] '(([col] integer :not-null :references other-table [col])))` but got `The value #<CLSQL-SYS:SQL-IDENT-ATTRIBUTE COL> is not of type SYMBOL` 🤔️
<Bike>
lisp critic mostly looks like style issues, and just uses a pattern matcher rather than an involved analysis
semz has quit [Ping timeout: 250 seconds]
<Bike>
"A variable used in a closure is defined in a loop. This will result in all closures using the same value for the closed-over variable." boy, that's familiar
<beach>
Heh.
asarch has joined #commonlisp
<Nilby>
contrapunctus: I used to just specify them using the :constraints keyword, but I was probably using a different database that worked that way.
<asarch>
How would print a value using the currency format (e.g (format t "Your debt is: …"))?
<beach>
asarch: What is a "currency format"?
<asarch>
Money?
<beach>
You don't care what currency it is?
<Bike>
(format t "Your debt is: ¤~d.~d" (floor ncents 100) (mod ncents 100))
<Bike>
assuming this is decimal currency and not 1700s pounds or something
yauhsien has quit [Ping timeout: 260 seconds]
<contrapunctus>
Nilby: I see, thanks again 🙂️
<Bike>
oh, make the second one ~2,'0d
<beach>
Some currencies write the currency sign (if there is one) before the amount. Most of them after it.
<Bike>
would get funky with negative cash, also...
yauhsien has joined #commonlisp
<beach>
That's why I was asking "what is a `currency format'", because I don't think there is such a thing.
<Alfr>
Bike, if you place two cash units on that table, then the table will be empty?
<Bike>
table...?
<asarch>
Thank you!
<asarch>
Thank you very much! :-)
<Alfr>
Bike, furniture!
asarch has quit [Quit: Leaving]
<contrapunctus>
Nilby: say, since you seem to have worked with CLSQL - is there any way to prevent it from upcasing table names? e.g. `create-table` as used above would create a table called "TABLE_NAME" rather than "table_name"...the only workaround I know of is to use `(execute-command <SQL string>)` 🤔️
<Nilby>
contrapunctus: Perhaps you can just use a string for the table name? The [foo] syntax ususually converts to upper case.
<contrapunctus>
Nilby: aha, that works, thanks! :D
<Nilby>
contrapunctus: I find a useful thing is to see what strings it ends up generating with start-sql-recording
<contrapunctus>
didn't notice that it accepts strings too
rawley has quit [Remote host closed the connection]
<Nilby>
btw, I think you can probably do (create-table [table-name]'(([col] integer :not-null)) :constraints "references other-table (col)") in something like postgresql
<lisp123>
contrapunctus: why not use sqlite?
<lisp123>
for most cases its much better imo
<contrapunctus>
lisp123: that's just what I'm using, via `clsql-sqlite3` ...or do you mean `cl-sqlite` ? 🤔️
<lisp123>
oh, i use cl-sqlite, sorry didn't fully follow and though you were using MySQL or Maria
<Nilby>
the nice thing about using clsql is you can potentially switch from sqlite to something with a trillion rows sharded across datacenters without chaning much code
<lisp123>
Good point
yewscion has quit [Ping timeout: 272 seconds]
pillton has joined #commonlisp
Bike has quit [Quit: Connection closed]
<lisp123>
quick quesiton for anyone using hunchensocker
<lisp123>
how to send a message to a single peer? Say I receive a message from a particular user
<lisp123>
via something like (defmethod hunchensocket:text-message-received ((room chat-room) user message) ---> how do I get the "peer" to send the message to in something like (hunchensocket:send-text-message peer (apply #'format nil message args))
<hayley>
That would be the USER parameter
<lisp123>
hayley: Thanks!
<hayley>
(hunchensocket:send-text-message user "blah")
<hayley>
...I hope. I'm just gleaning off the cl-decentralise1 code, which uses Hunchensocket. And my memory of it isn't great.
<hayley>
The other thing I notice is that it doesn't lock to push and pop off an "event list", which also will produce messages out of order. lol, this code is shit.
<lisp123>
lol
<lisp123>
just testing now, but i think it should work
<hayley>
So do I, I recall this code working.
tyson2 has quit [Remote host closed the connection]
<contrapunctus>
lisp123: does cl-sqlite have an s-expression syntax for SQL? Or perhaps there's one that is available separately from cl-sqlite?
<lisp123>
been ages since I used cl-sqlite, ironically enough, I need to use it today/tomorrow so will let you know
x88x88x has joined #commonlisp
<hayley>
("Now, how do you get reminded of _that_?" Well, I'm glad I replaced cl-decentralise1 with...cl-decentralise2, but I never actually bothered with implementing websockets for cl-decentralise2, years later. And I borrowed the documentation template from the Netfarm book for this manual.)
<lisp123>
hayley: Indeed I was trying to make the connection on how you got reminded to update a manual from websockets
lisp123 has quit [Remote host closed the connection]
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 246 seconds]
hashfunce31 has joined #commonlisp
<hashfunce31>
am i better off using SBCL's built-in FFI or the CFFI extension? i'm trying to follow the CFFI tutorial, but i'm finding it incredibly difficult to follow/connect-the-core-ideas
azimut has quit [Ping timeout: 240 seconds]
azimut has joined #commonlisp
<hayley>
As a general rule of thumb, stick to the portable libraries like CFFI.
<hashfunce31>
hayley: from what i'm seeing thus far, CFFI is seeming to be overly-redundant and overly-complex for what it accomplishes
<hashfunce31>
^ as well as the tutorial
<hayley>
I haven't seen that.
yauhsien has joined #commonlisp
lisp123 has joined #commonlisp
<boigahs>
I found it easier to just ignore the tutorial and skim through the docs to find what I need
<boigahs>
Most of it is pretty straight forward, but the tutorial skips to the crazy stuff pretty fast
occ has joined #commonlisp
rotateq has joined #commonlisp
<hashfunce31>
i think i'm gonna go for the pure SBCL approach
<rotateq>
hashfunce31: in which context? :)
<hashfunce31>
rotateq: in the context of me using it haha
<rotateq>
haha okay
<rotateq>
else I would have said try writing as much ANSI compliant code as you can
<rotateq>
there is much for me to discover with just SBCL still
<hashfunce31>
rotateq: yeah i'm definitely gonna aim for that as a primary goal. IMO i feel as if SBCL has solidified itself insomuch as being the future of the language (not so say other implementations will always be relevant as well). sort of akin to how GCC & Clang are to C++
<hashfunce31>
i feel as if C++ isn't really even C++. but more so the question is, "can you program in GCC?" or "can you program in Clang?"
<rotateq>
I thought the part of the "future" is SICL.
<hashfunce31>
i could see that as well
<rotateq>
There is also CLASP which aims to talk directly to C++ and LLVM.
<hashfunce31>
that's true, but that seems to be a niche market
<rotateq>
hashfunce31: so when a new implementation rises the SICL modules can be used to have a well written ANSI-compliant one quickly
<rotateq>
you think so? why that?
<rotateq>
With C++ it may be that it's too complex for even most of the experts. But you know, complexity sells better.
<hashfunce31>
i'm just basing my thought-process on the language being used as a whole, with the primary metric being which language startups are choosing. and based off of what i've read so far, C/C++ are on the list, but definitely not the top of the list
<rotateq>
Yes now you are on another track for a wonderful journey. :)
<hashfunce31>
yeah, i think the one of the primary benefits of C++ is job security. that is for sure
lisp123 has quit [Remote host closed the connection]
<rotateq>
When calling things from the outside we mostly have to go over C but okay, CCL for example offers more for Objective-C. But we're lucky as we can write bindings in CL and have all benefits at hand.
<hashfunce31>
that is why i think lisp has to be the future
<rotateq>
hashfunce31: Yes and if they pay well for the pain, you can say "Sure, I can make a port of my very fast made prototype, but it will be slower and takes five times longer to translate."
<hashfunce31>
if history follows the same pattern, "... there is no new thing under the sun.” then it should come full circle back to lisp
<rotateq>
ahhh okay :) So maybe we can stop here. But if you have a question don't bother to ask in #clschool.
<hashfunce31>
for sure. thanks rotateq. have a nice rest of the day/evening
<rotateq>
Pleasure, you too.
aartaka has quit [Ping timeout: 260 seconds]
aartaka has joined #commonlisp
hashfunce31 has quit [Remote host closed the connection]
attila_lendvai has joined #commonlisp
attila_lendvai has quit [Ping timeout: 240 seconds]
lisp123 has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
yagamisato has quit [Ping timeout: 252 seconds]
yagamisato has joined #commonlisp
yagamisato has joined #commonlisp
yagamisato has quit [Changing host]
Madsy has quit [Ping timeout: 256 seconds]
Madsy has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
igemnace has quit [Quit: WeeChat 3.5]
<contrapunctus>
Is there any Common Lisp equivalent of Emacs Lisp's `add-variable-watcher` ? I use it to update program object slots when the user changes the value of a certain variable...
lisp123 has joined #commonlisp
<rotateq>
contrapunctus: CLOS provides updating instances when things for it changed automatically the next time an object is touched.
<contrapunctus>
rotateq: can I watch a global variable for changes using that?
<rotateq>
Can you show some example code? Then I would have better imagination about what you exactly mean.
<rotateq>
but from what I understand, if you have a global variable (aka parameter) as a dummy instance of your class sure
<rotateq>
But no guarantee I can really be of any help. :)
<lisp123>
contrapunctus: you would want to add some after methods then on the writer function
<lisp123>
Assume you have a class (defclass test () ((key :initarg :key :accessor key))
<beach>
I think you are misunderstanding what contrapunctus wants.
<rotateq>
Yes beach I'm not so sure yet.
<lisp123>
You can store the global variable as a CLOS object no?
<lisp123>
And then add an after method on its writer function
<beach>
contrapunctus: I assume you mean that you want to catch when someone does (setf *var* <mumble>) for some arbitrary variable *var*, yes?
<beach>
contrapunctus: There is no such mechanism in Common Lisp.
<contrapunctus>
beach: exactly that, yes...
<contrapunctus>
...on second thoughts, perhaps I don't I want to support that kind of customization either - it could just as well take place through a dedicated function. Thanks ^^
<beach>
That would be better.
<lisp123>
Is there a syntax for multi-line comments? Like /* */
<hayley>
#| ... |#
<hayley>
However, it doesn't let you write underhanded code by nesting comments.
<lisp123>
hayley: Thanks! I was trying |#
<lisp123>
At how many elements does it make sense to store in a hash table vs. alist?
<hayley>
It depends on your machine, access patterns, hash table implementation, etc, but a rule of thumb is about 10 elements or fewer being faster for alists.
<lisp123>
Thanks
<hayley>
I think I measured the crossover point for SICL's linear probing hash table, and SICL's alist "hash table" to be around 6.
<lisp123>
Nice
<lisp123>
That got me thinking, I wonder if this is a place for automated profiling and adjustments
<lisp123>
i.e. if the data coming in is consistently small in size, the system adjusts to using alists
<hayley>
I've thought about it in the past.
<lisp123>
I am going to do it manually in YASON (JSON parser), because I know a username/password is only 2 elements so better to store in an :alist whereas input data is definitely most likely going to be big
Madsy has quit [Ping timeout: 260 seconds]
<hayley>
Tricky, but the payoff is there. Another option would be to have a hash table which doesn't actually hash, if the table is really small. Instead it would basically do FIND on its keys.
occ has quit [Ping timeout: 260 seconds]
<lisp123>
oh yes, that's likely a better situation
<lisp123>
one problem I can think of is the cost of measuring the size of the data, that could easily outweigh any benefits
<lisp123>
Unless one did it an aggregated level (*hand-waving* - measure total size of data / number of units to get a sense of average size thus far)
<lisp123>
Now I wonder if the dynamic nature of CL makes it perfect for the future of technology and some form of Machine Learning in live systems
<hayley>
Well, another subject for runtime feedback would be sizing hash tables, adjustable arrays, and such. Say every hash table allocated somewhere has roughly the same size. We could guess that the next hash table allocated there will have a similar size, and avoid resizing.
<beach>
Or we could allocate an ALIST hash table and then change the class when it acquires too many elements.
<hayley>
That would also work, yes.
<beach>
I guess not change the class, but have a general hash table which changes the way elements are stored as appropriate.
<hayley>
I suspect using a tiny vector would be better for locality still, but the idea of changing class would still work.
<pjb>
If only somebody had implemented it 12 years ago, we could use it as a library…
igemnace has joined #commonlisp
<hayley>
Reminds me (again) that I've been thinking that I should take runtime feedback for how often a loop in a state machine is taken. If the loop is taken multiple times, it is faster to use SIMD. If the loop is taken very few times, it is faster to use scalar code.
<rotateq>
lisp123: You can remember the #| (to not confuse and start with |#) thing by seeing that #\# is the standard dispatch macro character.
prokhor has joined #commonlisp
<hayley>
I can tell you that there is a constant factor due to generic dispatch in SBCL, which makes all slower than the hash tables in SBCL. And none of the designs are new.
<lisp123>
pjb: Such easy to follow code, masterclass in writing well
<lisp123>
hayley: Any good papers to read on it?
<hayley>
Dispatch or hash tables? I only know of two presentations on hash table design.
<lisp123>
hayley: linear-probing / simd
<hayley>
SIMD-PROBING-HASH-TABLE is Matt Kulukundis's linear-probing hash table from <https://www.youtube.com/watch?v=ncHmEUmJZf4>. LINEAR-P-H-T is also the same hash table, but it uses trickery on normal integers for probing, rather than SIMD.
<lisp123>
Thanks!
nature has joined #commonlisp
s-liao has joined #commonlisp
shka has joined #commonlisp
lisp123 has quit [Remote host closed the connection]
lisp123 has joined #commonlisp
s-liao has quit [Ping timeout: 250 seconds]
s-liao has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
<splittist>
At the previous (?) ECLS, Didier did a presentation on Quickref and/or Declt and gave some recommendations for things to include in an .asd file. Are these captured anywhere? I can't find what I want in the Declt User Guide, for example.
yauhsien has quit [Ping timeout: 272 seconds]
yauhsien has joined #commonlisp
Inline__ has quit [Quit: Leaving]
<splittist>
Judging by clon, it would be :long-name :description :long-description :author :mailto :homepage :source-control :license (sic) and :version
Inline has joined #commonlisp
<CodeBitCookie[m]>
<Shinmera> "one easy way is to throw money..." <- Well, I wish I could...
<CodeBitCookie[m]>
Shinmera: Okay, I will try to make it more popular, but I was looking for some more development, like writing some code.
<beach>
CodeBitCookie[m]: Did you see my link of suggested projects?
<CodeBitCookie[m]>
beach: Oh, I totally missed that! Let me check it out.
random-nick has joined #commonlisp
<CodeBitCookie[m]>
beach: Wow, seems like a lot of Fun! However, what is the purpose of this project and who is making it? How many developers are already working on it?
<CodeBitCookie[m]>
I also was already making a Word Processor.
<CodeBitCookie[m]>
I was making it for commercial use, but I may make it open source now.
<CodeBitCookie[m]>
It's really in the basic stage.
<CodeBitCookie[m]>
Made with Pango, GTK and Cairo.
<splittist>
CodeBitCookie[m]: what formats does it read and write?
<CodeBitCookie[m]>
I made text, which supports all languages (although a bit buggy), a cursor and typing, deleting and stuff like that.
<beach>
CodeBitCookie[m]: That's a very hard question to answer. Why does it matter?
<CodeBitCookie[m]>
No IO, no font selection no nothing yet.
<CodeBitCookie[m]>
It's only really been a week since I started.
<CodeBitCookie[m]>
It's fully made in CL though.
<splittist>
CodeBitCookie[m]: cool. Enjoy!
<CodeBitCookie[m]>
* splittist: No IO,
yauhsien has quit [Remote host closed the connection]
<CodeBitCookie[m]>
beach: I mean, will give me more motivation if I work on something that people will actually use, don't you agree?
<CodeBitCookie[m]>
Atleast one other person uses.
<beach>
Sure.
<beach>
CodeBitCookie[m]: Does your question refer to the LispOS project as a whole?
<contrapunctus>
I'm getting an unbound variable error when trying to ql:quickload my local system, but for some reason I don't see any line/character information about it from SBCL... 🤔️
<beach>
CodeBitCookie[m]: Then you need to count all the collaborators of the SICL project, because the SICL implementation is meant to be the basis of the OS. So then we are talking about 10-20 people, off and on.
<CodeBitCookie[m]>
splittist: Oh you made that? That's so cool!
yauhsien has joined #commonlisp
<beach>
CodeBitCookie[m]: But the OS project, as I wrote, is just a framework for the others. Applications will be individually usable without the OS.
<CodeBitCookie[m]>
beach: Nice.
<CodeBitCookie[m]>
I see.
<CodeBitCookie[m]>
beach: Why SICL though? What's wrong with SBCL?
<CodeBitCookie[m]>
beach: I have seen this robert-strandh guy quite a lot, he seems very interesting.
<CodeBitCookie[m]>
He is very active and has many nice projects.
<beach>
It is good, but not safe enough. I need first-class global environments for instance.
<CodeBitCookie[m]>
beach: So, what is your goal here? To make it a daily-driver, or a replacement for your current OS?
yauhsien has joined #commonlisp
<CodeBitCookie[m]>
If so, would it be able to support all the necessary applications?
<beach>
CodeBitCookie[m]: I mainly want to demonstrate that there are better options than the Unix derivatives that we are now using.
<CodeBitCookie[m]>
Oof, that's quite a big goal.
<beach>
CodeBitCookie[m]: Nah.
<CodeBitCookie[m]>
What do you think can be improved?
<CodeBitCookie[m]>
beach: Sorry, but I have a lot of questions. If you don't mind.
<rotateq>
CodeBitCookie[m]: As I see it SICL itself and then having an OS running on top of Linux that's very safe and very dynamic/interactive to use. Or not, beach?
<beach>
CodeBitCookie[m]: Let me give you some links.
<CodeBitCookie[m]>
rotateq: Not long, only around 2-3 years.
<CodeBitCookie[m]>
Although, I have gotten quite deep into it.
<CodeBitCookie[m]>
beach: Okay, let me check that.
<gjvc>
beach: that is a fantastic explanation of 50 years in 50 minutes and i'm in (slow) dialogue with the author, Liam Proven -- which reminds me, I must finish that email to him
<beach>
CodeBitCookie[m]: It is good that you are interested in the OS ideas, but don't let that distract you from writing some of the code on that list of projects.
<beach>
gjvc: I just had an exchange with him. Very interesting stuff.
<rotateq>
Okay, one often thinks so until discovering it's not like this which doesn't mean anything specific now. :) Just that it's worth being open to new thoughts like you are.
<CodeBitCookie[m]>
contrapunctus: beach: Woah, beach you're quite serious into this project, you have got a full paper on this.
<beach>
gjvc: And he is aware of Mezzano.
<beach>
CodeBitCookie[m]: I am working on SICL full time, pretty much.
<CodeBitCookie[m]>
How long has it been?
<CodeBitCookie[m]>
* beach: How long
<beach>
Since 2008, I think. But I didn't work full time in the beginning.
<beach>
CodeBitCookie[m]: I have had to invent a certain number of new techniques, and that takes time.
<CodeBitCookie[m]>
beach: Okay, just asking, how can I find out how much work has been done on each project on that list?
<gjvc>
beach: good. his talk did demonstrate his wide-ranging research. considering using something like amoeba as a basic i/o layer is a good strategy, and one which has not been tried enough.
<CodeBitCookie[m]>
beach: beach: Woah. That's a loooong time.
<CodeBitCookie[m]>
That project is almost as mature as me.
<CodeBitCookie[m]>
* beach: That project, * as me. 😆
<beach>
CodeBitCookie[m]: Some progress is mentioned on each page, but it is probably better if you look at some you might be interested in, and we can talk about those.
<CodeBitCookie[m]>
beach: Thanks a lot beach!
<beach>
Pleasure. Good luck.
<beach>
CodeBitCookie[m]: We hang out in #sicl too.
<CodeBitCookie[m]>
Ooooh, let me join that.
<CodeBitCookie[m]>
beach: On Freenode?
<CodeBitCookie[m]>
> <@beach:libera.chat> CodeBitCookie: We hang out in #sicl too.
<CodeBitCookie[m]>
* beach: On Freenode?
<beach>
On libera.chat
<hayley>
Freenode is a bit like Ravenholm, in that we don't go there anymore.
<CodeBitCookie[m]>
I actually use Matrix, so was just guessing it might be there.
<hayley>
The Matrix room name is #sicl:libera.chat. (Generally you translate by putting :libera.chat on the end.)
<CodeBitCookie[m]>
Yeah.
tyson2 has joined #commonlisp
<beach>
CodeBitCookie[m]: hayley is one of the participants in the SICL project.
<CodeBitCookie[m]>
beach: Did you create those cute pictures on the website?
<beach>
On metamodular? Yes.
<CodeBitCookie[m]>
beach: beach: Who's hayey?
<CodeBitCookie[m]>
s/hayey/hayley/
<beach>
CodeBitCookie[m]: The one who just told you about accessing #sicl on matrix.
<CodeBitCookie[m]>
beach: Wait, I know that guy from reddit!
<hayley>
I believe we spoke once, yes.
<CodeBitCookie[m]>
hayley: Yes.
razetime has joined #commonlisp
Dynom has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
<CodeBitCookie[m]>
beach: What do you mean, I sent a screenshot.
<beach>
Well, we didn't see anything in the IRC channel.
<CodeBitCookie[m]>
What do I do?
<mfiano>
That is not the channel hayley told you to join.
igemnace has joined #commonlisp
igemnace has quit [Read error: Connection reset by peer]
<CodeBitCookie[m]>
mfiano: Oops, I am sorry. I didn't even know there was a difference in prefixing `irc.`. I falsely assumed since all the channels I joined were prefixed with `irc`.
<mfiano>
I have a function, CONVERT, that generates a function by `COMPILE`ing a lambda expression, that converts between two color spaces if it is not cached in a hash table yet keyed by the given color space pair, and then funcalls the generated/cached function.
<mfiano>
I am wondering if it makes sense to return the function directly without funcalling, so the user can avoid the hash table lookups for potentially hundreds of thousands of pixels, and funcall it themself instead.
<mfiano>
That sort of leaks implementation details though, so I'm not sure. Also it would need to be named something else obviously.
x88x88x has joined #commonlisp
Bike has joined #commonlisp
Oddity has joined #commonlisp
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 272 seconds]
tyson2 has quit [Remote host closed the connection]
<CodeBitCookie[m]>
<mfiano> "Also, it is much more convenient..." <- What are you implying?
<mfiano>
I'm implying that the overhead of relaying IRC across HTTP is unnecessary, and introduces more problems than it solves. Data is best transmitted over the protocol it was designed for. One problem I mentioned above. You may not receive messages for several minutes, and your messages may not be delivered for several minutes. This happens frequently with IRC over Matrix.
<mfiano>
The overhead is just inconvenient in a lot of ways. If you want to use Matrix, I won't stop you, but you will not be receiving the full IRC experience.
<mfiano>
But this is off-topic, so I will stop.
<jackdaniel>
my impression of matrix is that it has a very skilled marketing team ,)
<mfiano>
Seems to be the case with all the Web platforms the kids are using these days.
eddof13 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
waleee has joined #commonlisp
<CodeBitCookie[m]>
mfiano: You are right. This did happen. Will look more into it.
<mfiano>
I once waited a half hour for my message to arrive, and another half hour for the reply to arrive, when I was checking out Matrix to see what all the hype was about. Talk about asynchronous communication.
x88x88x has joined #commonlisp
<jackdaniel>
disturbed computing
cage has quit [Quit: rcirc on GNU Emacs 27.1]
lucie22 has joined #commonlisp
tfeb has joined #commonlisp
Psybur has quit [Ping timeout: 260 seconds]
tfeb has quit [Client Quit]
Psybur has joined #commonlisp
<CodeBitCookie[m]>
<mfiano> "I once waited a half hour for my..." <- Interesting, although I never had delays more than 1 minute.
<CodeBitCookie[m]>
one time it was 5 minutes, but mostly it's instantaneous.
<CodeBitCookie[m]>
beach: If you don't mind, I have a few questions about LispOS
Psybur has quit [Ping timeout: 260 seconds]
<CodeBitCookie[m]>
jackdaniel: Also, how far have you gotten into converting McCLIM into material UI?
rogersm has joined #commonlisp
Psybur has joined #commonlisp
<rotateq>
CodeBitCookie[m]: I think you might have to wait a few more hours for answers. :)
<CodeBitCookie[m]>
rotateq: Yeah, just asking so that they can answer later.
<rotateq>
As I know him by now from here he will answer as he cares about new and motivated people.
hhhh92 has quit [Quit: Leaving]
eddof13 has joined #commonlisp
Lord_of_Life_ has joined #commonlisp
Lord_of_Life has quit [Ping timeout: 256 seconds]
Lord_of_Life_ is now known as Lord_of_Life
yauhsien has quit [Remote host closed the connection]
yauhsien has joined #commonlisp
eddof13 has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
* hayley
wonders when Kandria went three-dimensional
<lisp123>
If I have a list of data (say 50 items) that I need to keep adding to, and I only need to access sequentially, is it better to use a LIST or VECTOR data structure?
<lisp123>
Shinmera: Thanks, will share on all socials
<hayley>
An adjustable vector would be faster for iteration, due to hardware raisins.
<lisp123>
hayley: Thanks
<hayley>
Well, I thought I had fixed a bug in websocket-driver, where it would use 100% CPU after the connection dropped out, but now my process crashes with a double-free. Makes sense, since (subseq "#commonlisp" 0 2) ⇒ "#c"
lucie22 has quit [Quit: Connection closed]
occ has joined #commonlisp
Madsy has quit [Quit: Using Circe, the loveliest of all IRC clients]
Guest74 has joined #commonlisp
yauhsien has joined #commonlisp
yauhsien has quit [Ping timeout: 256 seconds]
Bike has quit [Quit: Connection closed]
lisp123 has quit [Remote host closed the connection]
Guest74 has quit [Ping timeout: 256 seconds]
notzmv has quit [Ping timeout: 250 seconds]
lisp123 has joined #commonlisp
White_Flame has quit [Remote host closed the connection]
triffid has quit [Remote host closed the connection]
triffid has joined #commonlisp
White_Flame has joined #commonlisp
MajorBiscuit has joined #commonlisp
azimut has quit [Remote host closed the connection]
azimut has joined #commonlisp
<mfiano>
lisp123: Cons cells may not be adjacent in memory. I wouldn't say this is a hardware reason.
MajorBiscuit has quit [Ping timeout: 260 seconds]
<mfiano>
Any time you are adding onto a list, if you care about performance, you'll wait to maintain a tail pointer as to not traverse it, if append-semantics are important anyway.
<mfiano>
s/wait/want/
<hayley>
It has effects on cache utilisation (and paging, if your heap is big enough). Though the SBCL GC tries to line up cons cells when it can.
<lisp123>
mfiano: Thanks
robin has quit [Read error: Connection reset by peer]