<White_Flame>
but of course, heed the advice of logging safely
<White_Flame>
and again, this is only if SQL is not worth learning for the scale of your project
<nij>
got it
rumbler31 has quit [Ping timeout: 246 seconds]
<nij>
thanks for all advice ;)
notzmv has quit [Read error: Connection reset by peer]
curtosis[away] has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
aeth has joined #lisp
notzmv has joined #lisp
nij has quit [Quit: ERC (IRC client for Emacs 27.1)]
Alfr has quit [Quit: Leaving]
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
rgherdt has quit [Ping timeout: 246 seconds]
Alfr has joined #lisp
madage has quit [Ping timeout: 240 seconds]
Jachy has joined #lisp
aartaka has joined #lisp
wxie has joined #lisp
Bike has quit [Quit: Lost terminal]
semz has quit [Ping timeout: 276 seconds]
aartaka_d has quit [Ping timeout: 252 seconds]
sxmx has quit [Quit: WeeChat 3.1]
semz has joined #lisp
semz has joined #lisp
Inline has quit [Ping timeout: 246 seconds]
notzmv has quit [Read error: Connection reset by peer]
akoana has left #lisp ["Leaving"]
notzmv has joined #lisp
CrazyPython has quit [Read error: Connection reset by peer]
karlosz has quit [Quit: karlosz]
<copec>
What is the database library that yall tend towards these days?
<aeth>
postmodern (for postgresql) was the general recommendation back in the day. Idk if it still holds
<copec>
That's what I was looking at, and then looking at Mito since it is high on all my searches
quazimodo has joined #lisp
Sheilong has quit []
mindCrime_ has quit [Ping timeout: 240 seconds]
<beach>
Good morning everyone!
Alfr is now known as Guest57499
Alfr has joined #lisp
Guest57499 has quit [Ping timeout: 252 seconds]
orivej has quit [Ping timeout: 240 seconds]
Stanley00 has joined #lisp
indathrone has joined #lisp
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
<Josh_2>
Morning beach
orivej has joined #lisp
klltkr has joined #lisp
klltkr has quit [Client Quit]
aeth has quit [Ping timeout: 268 seconds]
IPmonger has quit [Quit: ZNC 1.7.5+deb4 - https://znc.in]
IPmonger has joined #lisp
aeth has joined #lisp
johnjay has quit [Ping timeout: 265 seconds]
sp41 has quit [Remote host closed the connection]
mindCrime_ has joined #lisp
orivej has quit [Ping timeout: 246 seconds]
johnjay has joined #lisp
mindCrime_ has quit [Ping timeout: 268 seconds]
aeth has quit [Ping timeout: 246 seconds]
aeth has joined #lisp
karlosz has joined #lisp
wxie has quit [Ping timeout: 268 seconds]
jeosol has joined #lisp
long4mud has quit [Quit: WeeChat 3.0.1]
long4mud has joined #lisp
aeth has quit [Ping timeout: 246 seconds]
mindCrime_ has joined #lisp
aeth has joined #lisp
<fiddlerwoaroof>
copec: you'll find a variety of opinions here
<fiddlerwoaroof>
I generally think Postmodern or the sqlite wrappers are a good choice if you need a "Real DB"
<fiddlerwoaroof>
However, most programs work really well with a well-thought-out system of files for persistence
<fiddlerwoaroof>
e.g. logging updates as lisp forms and then replaying the log when your system starts up
<fiddlerwoaroof>
SQLite is useful here, because the developers of SQLite have put a lot of effort into handling the edge cases around "writing reliably to secondary storage"
<fiddlerwoaroof>
Anyways, would it be reasonable for EQL specializers to only hold a weak reference to the object they reference?
mindCrime_ has quit [Ping timeout: 246 seconds]
<no-defun-allowed>
From the protocol level, it makes sense. From the implementation level, I wonder how much having to remove methods which will never be called complicates things, and if having the weak-value indirection slows down things.
<fiddlerwoaroof>
Yeah, you'd probably need to make the GC aware of generic functions or something
wxie has joined #lisp
<no-defun-allowed>
Or you could mess with the discriminator function constant vector and MMU to get similar performance.
<fiddlerwoaroof>
The reason I'm wondering is that it seems like there might be some interesting patterns around implementing protocols inside a LET or a DEFUN
<no-defun-allowed>
When the GC runs, it would have to replace any eql-specializer values that have been collected with some value - nah, we don't do anything with the value other than test it with EQL, so you couldn't use a memory trap to re-compile with dead methods.
<fiddlerwoaroof>
If the GC special-cased generic functions, it could remove the dead methods and collect the method objects
<no-defun-allowed>
Yes, I suppose it could instead clear the cached discrimination function.
<fiddlerwoaroof>
Your method combination would have to be designed to handle dangling references, but that seems relatively easy
aindilis has quit [Ping timeout: 240 seconds]
<no-defun-allowed>
If the function was removed, oh, there could still be mutator threads in the discriminating function, so that's true.
nullheroes has quit [Quit: WeeChat 2.9]
nullheroes has joined #lisp
vsync has quit [Ping timeout: 260 seconds]
narimiran has joined #lisp
aeth has quit [Ping timeout: 246 seconds]
aeth has joined #lisp
<MrtnDk[m]>
nij just tell us; are you raised in a Microsoft Windows environment, complete with Microsoft office, etc?
bitmapper has quit [Quit: Connection closed for inactivity]
<MrtnDk[m]>
Never mind it will get off topic, and it seems you already found a solution for the db-stuff.
long4mud has quit [Quit: WeeChat 3.0.1]
vsync has joined #lisp
long4mud has joined #lisp
galex-713 has quit [Ping timeout: 246 seconds]
_paul0 has joined #lisp
maple has joined #lisp
maple is now known as Guest34366
paul0 has quit [Ping timeout: 260 seconds]
Guest34366 has quit [Client Quit]
orivej has joined #lisp
* beach
wonders why people seem to systematically ignore Clobber for logging and replaying transactions, even though nobody who used it has had any complainants so far.
<loke[m]1>
What is clobber, and why haven't I heard about it before?
galex-713 has joined #lisp
<beach>
It is a very simple system for logging transactions and replaying them. I mention it pretty much every time someone wants an object store, or prevalence, or a data base, or...
<beach>
It's a total of 550 lines of code. Very simple.
<beach>
250 of those lines are demo examples.
aartaka has quit [Ping timeout: 246 seconds]
<beach>
I guess I am ignorant, but I don't see how to use a traditional relational database from Common Lisp.
<loke[m]1>
beach: really? I findusing Postgres from CL quite natural.
<beach>
I mean, what if you store, say, a person (i.e. an instance of the class PERSON). How does the GC know to look in the external database for it?
<loke[m]1>
* beach: really? I find using Postgres from CL quite natural.
<loke[m]1>
beach: That's unrelated to SQL databases though. What you're referring to is an OR-mapping.
<beach>
And if the GC doesn't find it, does it still live on in the data base? And if so, what happens when you read the object back in? Is it EQ to the object you stored?
<loke[m]1>
Typically an OR mapping is implemented using a metaclass that tracks changes to an instance and then implements a synchronisation function that writes the updates to a database.
<loke[m]1>
Need to leave my desk for a meeting. back in an hour.
<beach>
Take care.
<loke[m]1>
I implemented an OR-mapping for CouchDB once though, you can take a look at my code here:
<beach>
So that sounds really complicated. And I still don't understand how it works. Does it mean that I can't just store a person. I have to have a different kind of person that with a different metaclass?
<no-defun-allowed>
I am terrified of planning how I might handle crashes leaving my server "database" (which is backed by the filesystem) in an inconsistent state. Ideally, replication would make the stored state so small, that it'd be easier just to reload everything from the network, but that is probably not going to happen.
<beach>
But suppose I just drop the reference to my person in memory, even though it is stored in the database. Does the OR mapping know to delete the object from the data base when the GC has recycled it?
<no-defun-allowed>
The OR only deletes when instructed to. Using references would make it impossible to use datasets that are larger than the address space provided to the Lisp image.
<beach>
Wow, so we turn Common Lisp into a language without automatic memory management?
<beach>
I knew there was something fishy with data bases.
<no-defun-allowed>
We both know that such datasets rarely exist, but that is a problem. And yes, it could be considered manual entry management.
<beach>
My suspicions were confirmed then. Thanks!
<fiddlerwoaroof>
I tend to think of the database as a remote application like a webservice, when I'm dealing with RDBMSes
<no-defun-allowed>
I wanted to use a SQL database (e.g. Postgres) as a backend for this server, but I have an approximation of real objects to store, and the best option is to serialize into a binary format, which apparently Postgres doesn't handle so efficiently.
<beach>
So then, why on earth would a Common Lisp programmer turn to a data base even though the data set is small enough to be kept in memory?
<fiddlerwoaroof>
The main one is consistency checks that don't depend on your application code being correct
<beach>
fiddlerwoaroof: Yes, and I also don't understand remote stuff since I don't see how identity would be preserved.
<beach>
And I don't understand serialization in general either, since it too does not preserve identity.
<fiddlerwoaroof>
The DB schema usually changes much more slowly than your application code, and the cost of corrupted persistent data can be extremely high
<beach>
Clobber is such that you work in memory, and log the transactions. You can then quit your Common Lisp system, restart it, and load the log, and a "similar" object graph will be created.
<beach>
No identity problems.
<fiddlerwoaroof>
Usually identity is represented by one or more values that uniquely identify an object
<no-defun-allowed>
I am also not going to bet that the objects stored by a server will fit in memory, because truth told, I have no clue what kind of access patterns could happen, if the network is running literally any class-based object-oriented program.
<beach>
fiddlerwoaroof: So you mean you need to manually create pointers just like you do with SQL?
<beach>
I truly can't figure out why a Common Lisp programmer would be willing to sacrifice all the good parts of Common Lisp in order to use a data base.
<fiddlerwoaroof>
In distributed systems in general, the idea of "identity" is usually not really central, in the sense of reference identity
<no-defun-allowed>
Having some varying stages of going from real objects to binary blobs, I maintain a weak hash table of already-existing instances and their hashes in the server and client. Thus we can have enough object identity for things to make sense.
<beach>
fiddlerwoaroof: Exactly, which is why I don't want distributed, and I don't understand it.
<fiddlerwoaroof>
or reference equalityy
<fiddlerwoaroof>
Usually you treat as identical things that are equal under an appropriately specified value of "equality"
<beach>
Abandoning Common Lisp-style identity means you are no longer programming Common Lisp really.
<no-defun-allowed>
And we continue to maintain the illusion by putting a read barrier on SLOT-VALUE-USING-CLASS, which rewrites slot values to replace "reference" objects with the real object supplied by the client.
<fiddlerwoaroof>
Again, I don't think of the database as part of my program
<no-defun-allowed>
There was a technique based on "naming" objects and maintaining name translation tables in replicated object systems which I read about.
<fiddlerwoaroof>
Anymore than the IRC server is part of my IRC client
<White_Flame>
nor is a database part of your address space, nor connected to the ephemeral runtime of the lisp image
quazimodo has quit [Ping timeout: 246 seconds]
<beach>
And you have to take into account the possibility of one application object being represented by several instances. Then you have to track updates so that all instances are synchronous. That sounds like C++ programming to me.
<fiddlerwoaroof>
I don't understand that problem
<White_Flame>
in database applications, the database is the canonical store of information. Clients work with queries & pieces at a time, resolving all changes back into the shared database
contrapunctus has left #lisp ["Disconnected: closed"]
<fiddlerwoaroof>
Yeah, no client should ever care about the state of the data in another client
<beach>
So, how does that work if I want to store a person (instance of the class PERSON)?
<White_Flame>
any lisp runtime can come and go, working with the external data in the database, as much as little as it wants, and can do so simultaneously with others
<White_Flame>
databases are for data, not for objects
<beach>
Oh, so you can't store objects?
<White_Flame>
no, you store rows of data in tables
<beach>
Since in Common Lisp an object is any Common Lisp datum, what is the difference?
<White_Flame>
because of references
<White_Flame>
"relational" databases mean the relations are reified
<no-defun-allowed>
I don't think SQL has references (any more than it has indexes of rows in tables).
<White_Flame>
instead of implicit unnamed references
<fiddlerwoaroof>
I think the best way to think of a table is a relation between the primary key and 0 or more other values
<no-defun-allowed>
At the rate at which I program, it might be wiser for myself to wait for CLOSOS, and use the in-memory database implementation as a persistent database.
<beach>
Now I am beginning to see the answer to my question. It appears that the data base can store only objects that are not guaranteed to be EQ, so that creating a copy is not a problem.
<White_Flame>
and because it has no implicit references, that removes the burden fo having everything manifested at once
<beach>
That is one SERIOUS LIMITATION.
<fiddlerwoaroof>
It isn't really
<beach>
It is for me.
<White_Flame>
databases are for: 1) your data is bigger than RAM, 2) you need transactional security, 3) you have multiple users hitting your data simultaneously, 4) the data needs to persist safely
<moon-child>
if it's a concern, make your own version of eq that compares primary keys for db-sourced objects
<no-defun-allowed>
It makes me have to serialize, and handle all that stuff.
random-nick has joined #lisp
Stanley00 has quit []
<beach>
Anyway, thanks for all the information. All my suspicions were confirmed.
<White_Flame>
and of course, SQL (and any query language, like prolog etc) makes traversing thorugh tons of data way simpler than imperative looping
<White_Flame>
so in my list above, clobber only addresses 2 and 4
<fiddlerwoaroof>
now the "log of data" method like Clobber is also pretty widely used
<no-defun-allowed>
Re-reading the Postgres manual, the "limitation" that a binary value has to be materialized entirely in memory is not really a problem, as I would do that on the Lisp side briefly too.
<fiddlerwoaroof>
It's great for situations where you want to distribute work across a large number of computers
contrapunctus has joined #lisp
galex-713 has quit [Ping timeout: 246 seconds]
<fiddlerwoaroof>
The last system I worked on basically treated the database as a cache, and you replayed the log through all the worker nodes to rebuild or update the cache.
aartaka_d has quit [Ping timeout: 246 seconds]
<White_Flame>
beach:your EQ conclusion is incorrect as well. Relational keys have very speciifc equality semantics, and those are the only things that are compared for identity
<fiddlerwoaroof>
But, in this context, the restrictions are even more severe because you have to design your data so that reprocessing the same log entry doesn't change the DB
<fiddlerwoaroof>
Because, roughly, you can't guarantee that a message in the log is only processed once (if you want to make sure that you don't lose any data)
<beach>
White_Flame: Sure, but they are separate from my Common Lisp references, so I have to program differently.
<White_Flame>
correct, they are data, they are not objects. there is no pointer or reference to them. they are stored by key
<beach>
Yes, again, my suspicions are confirmed.
<White_Flame>
and those keys between rows can be connected in unique ways via sql to get summaries, comparisons, joins, etc in complex ways across huge datasets
quazimodo has joined #lisp
<beach>
So here is a good story: My employer bought Oracle to store student information like exam results, etc. I proved to my students that 100 years of such data would fit in the RAM of the laptop I was using at the time.
<White_Flame>
actually, the key is only for fast lookup, there can be slow lookup for any match
<White_Flame>
right, you can make custom solutions for anything. Or you can have multiple machines all sharing ACID protected data in a standard way
<White_Flame>
instead of only implemented the protections you think are needed at implementation time
<fiddlerwoaroof>
White_Flame: the primary key is sort of essential to the relational model, though
<White_Flame>
fiddlerwoaroof: it's what makes it scalable
<fiddlerwoaroof>
Not just that, it's how you make design decisions
<White_Flame>
any non-key column can be used for selection. just the key is unique with the table and indexed well
<fiddlerwoaroof>
e.g. your schema is largely driven by the idea that a table is a relation between the columns that compose the primary key and the rest of the columns
rumbler31 has joined #lisp
<fiddlerwoaroof>
I've never read Codd's book on the relational model, but my general impression is that the primary key is not just an optimization, it's part of the theory behind the model
<White_Flame>
yes, it's part of using it well
<White_Flame>
and designing around the best strengths
<White_Flame>
I just made the point that it's not the only way to query
<fiddlerwoaroof>
sure
<fiddlerwoaroof>
RDBMSes also tend to be used by multiple applicaitons simultaneously: e.g. the applications your developers make for users, the financial department's accounting software, the data science department's modeling tools, etc.
<fiddlerwoaroof>
The other big advantage is that it's a relatively rigorously specified way to represent data that lots of existing tools can take advantage of.
rumbler31 has quit [Ping timeout: 268 seconds]
quazimodo has quit [Ping timeout: 260 seconds]
<no-defun-allowed>
Generally, I'm now convinced that getting a database to behave with the possibility of crashes is easier than getting a filesystem to behave.
amb007 has quit [Read error: Connection reset by peer]
<White_Flame>
I"m just dealing with too many problems that have to deal with tons of data
<srandon111>
hello all, is active development on common lisp and/or common lisp libraries/modules still done? or is it a lnaguage just used to mantain old software?
<beach>
srandon111: There is lots of active development of applications and system software written in Common Lisp.
<beach>
srandon111: But there is no coordinated activity to evolve the language itself.
Alfr has quit [Quit: Leaving]
<scymtym>
there is probably also some work to keep legacy common lisp software running, but my impression is that such cases often involve commercial software and the commercial implementations and are not discussed here
<beach>
Indeed (to both observations).
<beach>
srandon111: Where did you get the idea that there might not be any active development in Common Lisp?
hendursa1 has joined #lisp
OlCe has joined #lisp
<srandon111>
beach, just small talk that is an old language nobody uses anymore
<srandon111>
but don't know if it's true
<srandon111>
so i got the idea nobody develops 3rd party libraries anymore
<beach>
srandon111: You shouldn't listen to what ignorant people say.
<beach>
srandon111: I said "ignorant", but there is another category of people who will spread this kind of misinformation, namely people who have a huge amount of effort invested in some technology that might be threatened by Common Lisp.
<srandon111>
beach, yes i can imagine that of course
Lord_Nightmare has joined #lisp
<beach>
That last kind of people is a dangerous one. Carol Dweck calls this phenomenon a "closed mindset". And these people will sometimes do awful stuff to avoid having to abandon the technology they invested in, and learn something better.
karlosz has quit [Quit: karlosz]
<beach>
Often, people with a closed mindset are also very sociable and come across as leaders, which makes the problem even worse.
<scymtym>
but there is no useful answer to such questions anyway. if a single person still uses common lisp, the answer whether anybody still uses common lisp would technically be "yes", but practically "no". but at what threshold does the answer become practically "yes"?
mathrick has quit [Ping timeout: 260 seconds]
troydm has quit [Ping timeout: 260 seconds]
<beach>
True.
tiwEllien has joined #lisp
mathrick has joined #lisp
tiwEllien has quit [Ping timeout: 252 seconds]
wxie has quit [Quit: wxie]
frost-lab has joined #lisp
wxie has joined #lisp
_paul0 has quit [Quit: Leaving]
mgr_ has quit [Read error: Connection reset by peer]
mgr_ has joined #lisp
nij has joined #lisp
troydm has joined #lisp
aartaka_d has joined #lisp
nij has left #lisp [#lisp]
aartaka has quit [Ping timeout: 240 seconds]
aartaka_d has quit [Ping timeout: 260 seconds]
pve has joined #lisp
wxie has quit [Quit: wxie]
luni has quit [Quit: Connection closed]
kingcons has quit [Ping timeout: 260 seconds]
kingcons has joined #lisp
ljavorsk has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
aartaka has joined #lisp
wxie has joined #lisp
contrapunctus has joined #lisp
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
contrapunctus has left #lisp ["Disconnected: closed"]
contrapunctus has joined #lisp
cosimone has quit [Remote host closed the connection]
aeth has quit [Ping timeout: 240 seconds]
cosimone has joined #lisp
theothornhill has joined #lisp
aeth has joined #lisp
anticrisis has quit [Read error: Connection reset by peer]
johnjay has quit [Ping timeout: 246 seconds]
hiroaki has quit [Ping timeout: 246 seconds]
varjag has joined #lisp
aartaka has quit [Read error: Connection reset by peer]
<White_Flame>
srandon111: quicklisp really invigorated 3rd party usage, and compared to CL's age is quite recent
<White_Flame>
*3rd party library usage
aartaka has joined #lisp
l1x has joined #lisp
hiroaki has joined #lisp
zdravko61 has quit [Remote host closed the connection]
johnjay has joined #lisp
tiwEllien has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
contrapunctus has left #lisp ["Disconnected: closed"]
tiwEllien has quit [Ping timeout: 245 seconds]
theothornhill has quit [Ping timeout: 252 seconds]
contrapunctus has joined #lisp
theothornhill has joined #lisp
<srandon111>
scymtym, ok so the question is, is common lisp practically used ?
<srandon111>
are there modern projects written in common lisp ?
<beach>
srandon111: Why is that information important to you?
igemnace has quit [Remote host closed the connection]
theothornhill has quit [Remote host closed the connection]
<no-defun-allowed>
"Having asked about the possibility that there are real people out there who use Lisp (as opposed to AI People who are known to be non-real) and having received no answers, I can only conclude that Lisp is not being used and that it is not, therefore, a real language."
<no-defun-allowed>
(kidding, of course)
<beach>
Is that a quotation from somewhere?
<no-defun-allowed>
The ending remarks from a short-lived section of some journal called Lisp Pointers. It failed to catch on because Lisp people call them references and not pointers.
<beach>
srandon111: I am asking because if the answer had been "no", what conclusion would you draw from it? It would be a grave mistake to draw the conclusion that Common Lisp CAN NOT be used for such thing, as opposed to drawing the more correct conclusion that programmers (and especially managers) are generally not very well trained when it comes to knowing the features of what is out there.
<no-defun-allowed>
Oh, the journal was Lisp Pointers, and that was the closing remark of "The key of Lisp".
<beach>
OK.
luni has joined #lisp
luni has left #lisp [#lisp]
<no-defun-allowed>
Sorry for distracting you with my self-correction.
orivej has joined #lisp
cchristiansen has quit [Remote host closed the connection]
vegansbane6963 has joined #lisp
<srandon111>
beach, i wanted to learn a lisp language and have doubts about doing clojure or common lisp
<srandon111>
i like the fact of common lisp for not being dependant on JVM
<srandon111>
and being able to produce statically linked executables
<srandon111>
which this is much harder for clojuer
frgo has quit [Remote host closed the connection]
frgo has joined #lisp
<indathrone>
srandon111: don't overthink it; just pick one and get started. If you like working in lisps, much of what you learn with one will translate into working in others.
aeth has quit [Ping timeout: 240 seconds]
<jackdaniel>
(but don't trust people claiming that cobol is an acceptable lisp!)
<no-defun-allowed>
"much" is writing (f a b) instead of f(a, b)
aeth has joined #lisp
akoana has joined #lisp
<Odin->
srandon111: In my experience, Clojure has more concessions to modern ways of thinking, but the community assumes that Java is familiar.
<no-defun-allowed>
mOdErN wAyS oF tHiNkInG
<Odin->
Yeah, you know, like "JSON is really where data formats should be at".
<Odin->
I never said modern was better. :)
<no-defun-allowed>
Now that you mention it, sure why not.
<no-defun-allowed>
Usually that's the implication still. Sorry.
OlCe has quit [Ping timeout: 268 seconds]
* Odin-
is a historian, so sometimes forget that's the automatic reading.
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Spawns_Carpeting has joined #lisp
OlCe has joined #lisp
narimiran has quit [Ping timeout: 240 seconds]
orivej has quit [Ping timeout: 260 seconds]
VincentVega has joined #lisp
Bike has joined #lisp
<VincentVega>
Anyone who used cffi here? How do I do automatic NULL checks? I have a bunch of functions that return various pointers, so I guess I can't just do this https://pastebin.com/zbz31xRa and would have to produce these definitions on the fly or something. Unless there's an existing mechanism for this of course, and that's why I am here.
heisig has joined #lisp
tinhatcat has joined #lisp
tinhatcat has quit [Client Quit]
nikolayclfx has joined #lisp
<VincentVega>
In fact, nvm, guess I can try to define new foreign types on the fly, if cffi is ok with it...
<srandon111>
indathrone, jackdaniel thanks a lot
wxie has joined #lisp
<jackdaniel>
huh, I didn't contribute to the discussion anything except for a joke
<jackdaniel>
but sure
ljavorsk has quit [Ping timeout: 240 seconds]
Spawns_Carpeting has quit [Read error: Connection reset by peer]
<Bike>
of course, if you don't know the type, this could cause problems. for example if you guess something is a null terminated string and it turns out to be a two megabyte array with no zeroes in it
<jmercouris>
I see
<jmercouris>
well, yes
<jmercouris>
in this case I am working Gboxed objects
<jmercouris>
so the type information /should/ be what the documentation says
<jmercouris>
well then again, there are no guarantees in this life
rumbler31 has quit [Remote host closed the connection]
<jmercouris>
thanks for the ideas
wsinatra has quit [Read error: Connection reset by peer]
wsinatra has joined #lisp
<jmercouris>
Is there a way to click on a var and see its value in the REPL?
<jmercouris>
for example I see a defvar form in my source code
<jmercouris>
can I just click on it and see its current value?
<ecraven>
SLIME might be able to do this
<jmercouris>
as it stands, what I currently do is switch to the package
<jmercouris>
and then print it out
<_death>
C-c C-i RET ?
<_death>
er, C-c C-I RET
<_death>
once again.. C-c I RET :/
<jmercouris>
_death: THANK YOU
<jmercouris>
that is so damn useful
orivej has joined #lisp
rumbler31 has joined #lisp
sjl has joined #lisp
tiwEllien has joined #lisp
tiwEllien has quit [Quit: WeeChat 3.0.1]
rumbler31 has quit [Remote host closed the connection]
dilated_dinosaur has quit [Ping timeout: 252 seconds]
dilated_dinosaur has joined #lisp
aartaka_d has quit [Ping timeout: 260 seconds]
akoana has left #lisp ["Leaving"]
cage_ has joined #lisp
mindCrime_ has joined #lisp
rogersm has quit [Quit: Leaving...]
bitmapper has joined #lisp
aartaka has joined #lisp
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 246 seconds]
rumbler31 has joined #lisp
supercoven has joined #lisp
dilated_dinosaur has quit [Ping timeout: 268 seconds]
dilated_dinosaur has joined #lisp
skapata has joined #lisp
aartaka has joined #lisp
dilated_dinosaur has quit [Ping timeout: 240 seconds]
gitgood has joined #lisp
aartaka_d has quit [Ping timeout: 246 seconds]
aartaka_d has joined #lisp
dilated_dinosaur has joined #lisp
aartaka has quit [Ping timeout: 260 seconds]
orivej has quit [Ping timeout: 268 seconds]
Alfr has joined #lisp
marusich has quit [Quit: Leaving]
a0 has joined #lisp
eden has quit [Ping timeout: 240 seconds]
frfxzd has joined #lisp
johnjay has quit [Ping timeout: 240 seconds]
johnjay has joined #lisp
hendursa1 has joined #lisp
hendursa1 has quit [Remote host closed the connection]
imuo has joined #lisp
hendursa1 has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
jonatack has quit [Quit: jonatack]
hendursa1 has quit [Ping timeout: 240 seconds]
hendursa1 has joined #lisp
jonatack has joined #lisp
curtosis has joined #lisp
curtosis is now known as curtosis[away]
lotuseat` has joined #lisp
lotuseater has quit [Ping timeout: 246 seconds]
lotuseat` is now known as lotuseater
ukari has quit [Remote host closed the connection]
ukari has joined #lisp
Sauvin has quit [Read error: Connection reset by peer]
VincentVega has quit [Quit: Connection closed]
VincentVega has joined #lisp
jeosol has joined #lisp
<jcowan>
beach: I think that if you approach the relational model without assumptions and without a filter, you find that it has its own kind of consistency and in fact is quite beautiful in the mathematical sense.
<jcowan>
Granted, SQL databases have made serious compromises with the model like allowing users to depend on the order of columns and rows.
<jcowan>
Without meaning to offend, you sound to me like someone discovering Lisp and saying "My suspicions are confirmed; this is not like Java at all!"
<jcowan>
"Why would anyone give up the rigor of statically typed OOP for this big ball of mud that allows you to write just any old thing?"
<_death>
well, Lisp has some history with object databases..
Lycurgus has joined #lisp
aartaka has joined #lisp
<jmercouris>
I wish there were different arity functions
<jmercouris>
So we could have the same function redefined with different argument counts like in Java
<jmercouris>
So that we could have both (defun xyz (qwe)) and (defun xyz (qwe rst))
<jmercouris>
That would be really cool
aartaka_d has quit [Ping timeout: 246 seconds]
<Gnuxie[m]>
you could probably make them
aartaka_d has joined #lisp
<jmercouris>
I’m sure I could, I just wish they were built in
a0 has quit [Quit: Leaving]
<Gnuxie[m]>
not sure there's much need for that as none of CL (the language) needs them, so would make sense for it to be a portable library
aartaka has quit [Ping timeout: 268 seconds]
<Alfr>
Won't you have to sacrifice &optional and friends?
<Gnuxie[m]>
like, there's nothing that special that is required for their implementation and i don't know how much you'll really lose in performance to dispatch either, it doesn't seem to be that complicated at a first look
<beach>
jcowan: I know the beauty of it. I took a graduate-level course at Hopkins. And it makes a lot of sense as long as you consider only numbers and strings, but it gets more complicated when you want to preserve identity.
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
cosimone has quit [Read error: Connection reset by peer]
eden has joined #lisp
hendursaga has joined #lisp
hendursa2 has joined #lisp
hendursa1 has quit [Ping timeout: 240 seconds]
aartaka has joined #lisp
hendursaga has quit [Ping timeout: 240 seconds]
aartaka_d has quit [Ping timeout: 246 seconds]
long4mud has joined #lisp
<jmercouris>
Alfr: I believe you are correct ambiguity in that case would make some dispatch unsolvable
raeda__ has joined #lisp
imuo has quit [Quit: Connection closed]
raeda_ has quit [Remote host closed the connection]
dilated_dinosaur has quit [Ping timeout: 240 seconds]
aeth_ has joined #lisp
dilated_dinosaur has joined #lisp
karlosz has joined #lisp
aeth has quit [Ping timeout: 240 seconds]
imuo has joined #lisp
aeth_ is now known as aeth
cage_ has quit [Quit: Leaving]
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
Lycurgus has quit [Quit: Exeunt]
karlosz has quit [Quit: karlosz]
Spawns_Carpeting has joined #lisp
jeosol has quit [Quit: Connection closed]
hiroaki has quit [Ping timeout: 246 seconds]
ggoes has quit [Quit: WeeChat 2.3]
heisig has quit [Quit: Leaving]
hiroaki has joined #lisp
galex-713 has quit [Ping timeout: 246 seconds]
VincentVega has quit [Quit: Connection closed]
ggoes has joined #lisp
supercoven has quit [Ping timeout: 268 seconds]
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
galex-713 has joined #lisp
Spawns_Carpeting has joined #lisp
karlosz has joined #lisp
Lord_of_Life_ has joined #lisp
Lord_of_Life has quit [Ping timeout: 246 seconds]
Lord_of_Life_ is now known as Lord_of_Life
shka_ has quit [Ping timeout: 260 seconds]
klltkr has joined #lisp
eden has quit [Remote host closed the connection]
eden has joined #lisp
curtosis has joined #lisp
jeosol has joined #lisp
cosimone has joined #lisp
frfxzd has quit [Quit: Leaving]
eden has quit [Quit: Leaving]
klltkr has quit [Quit: My MacBook has gone to sleep. ZZZzzz…]
lotuseater has quit [Quit: ERC (IRC client for Emacs 27.1)]
warweasle has quit [Quit: rcirc on GNU Emacs 26.1]
<Bike>
you could think of those java and C++ functions as being multiple functions with different types that happen to have the same name. the compiler can unambiguously figure out which definition a particular call will use. lisp has apply so in general it can't. of course you could still make it mostly free with some pretty basic compiler macroing
aartaka_d has joined #lisp
aartaka has quit [Ping timeout: 240 seconds]
Spawns_Carpeting has quit [Quit: ZNC 1.7.2+deb3 - https://znc.in]
<White_Flame>
inline that defun and you're most of the way there
frgo has joined #lisp
rodriga has quit [Ping timeout: 240 seconds]
<White_Flame>
(foo 1 2 3) should constant fold into (funcall (aref foo-arities 3) 1 2 3)
cosimone has quit [Read error: Connection reset by peer]
<White_Flame>
and still allow #'foo to be passed arround, APPLY'd etc
wsinatra has quit [Ping timeout: 252 seconds]
chipolux has joined #lisp
ljavorsk has joined #lisp
frgo_ has joined #lisp
narimiran has quit [Ping timeout: 268 seconds]
frgo has quit [Ping timeout: 250 seconds]
VincentVega has joined #lisp
anticrisis has joined #lisp
Inline has joined #lisp
wsinatra has joined #lisp
chipolux has quit [Quit: chipolux]
random-nick has quit [Ping timeout: 240 seconds]
random-nick has joined #lisp
klltkr has joined #lisp
aindilis has joined #lisp
Lord_of_Life has quit [Ping timeout: 240 seconds]
galex-713 has quit [Ping timeout: 246 seconds]
raeda__ has quit [Quit: Leaving]
curtosis is now known as curtosis[away]
curtosis[away] has quit [Quit: My Mac Mini has gone to sleep. ZZZzzz…]
galex-713 has joined #lisp
karlosz has quit [Quit: karlosz]
karlosz has joined #lisp
albusp has quit [Quit: albusp]
albusp has joined #lisp
wsinatra has quit [Quit: WeeChat 3.1]
albusp has quit [Client Quit]
albusp has joined #lisp
<Shinmera>
And the award for Longest Symbol Name Ever Devised goes tooooo.... ASDF (of course), with ASDF/BACKWARD-INTERFACE::*DEPRECATED-FUNCTION-STYLE-WARNING-ENABLE-ASDF-BINARY-LOCATIONS-COMPATIBILITY-NOTIFIED-P*
cchristiansen has joined #lisp
Oddity has joined #lisp
<phadthai>
almost as long as long cat
karlosz has quit [Quit: karlosz]
surabax has quit [Quit: Leaving]
random-nick has quit [Ping timeout: 240 seconds]
<jcowan>
beach: That was a very old version of the model. The latest version allows arbitrary objects (in the Lisp sense) as primitives.
orivej has quit [Remote host closed the connection]
orivej has joined #lisp
<gabc>
Hi! I'm trying to understand conditions, and I keep getting an "Unbound condition slot" error. I reproduced it here, can anybody can see the issue? Thanks! https://plaster.tymoon.eu/view/2369#2369
<no-defun-allowed>
The :initarg should also be a keyword.
<Bike>
gabc: you have :initarg myvar, but probably meant :initarg :myvar
<gabc>
Arf
<no-defun-allowed>
Yep.
<Bike>
i'm a little surprised signal doesn't complain about that
<Bike>
(on sbcl)
<Bike>
(complain about an unrecognized initarg, i mean)