<m_mans>
so, both tests was on 32Gb sequental write, but first one with 1Mb block size, the second with 1Kb block size
<m_mans>
so, both tests was on 32Gb sequental write, but first one with 1Mb block size, the second with 1Kb block size
<m_mans>
so, both tests was on 32Gb sequental write, but first one with 1Mb block size, the second with 1Kb block size
<m_mans>
so, both tests was on 32Gb sequental write, but first one with 1Mb block size, the second with 1Kb block size
<m_mans>
so, both tests was on 32Gb sequental write, but first one with 1Mb block size, the second with 1Kb block size
<Regenaxer>
sequental write is fast
<Regenaxer>
sequental write is fast
<Regenaxer>
sequental write is fast
<Regenaxer>
sequental write is fast
<Regenaxer>
sequental write is fast
<Regenaxer>
You refer to the DB import issue?
<Regenaxer>
You refer to the DB import issue?
<Regenaxer>
You refer to the DB import issue?
<Regenaxer>
You refer to the DB import issue?
<Regenaxer>
You refer to the DB import issue?
<Regenaxer>
The problem is exactly that the writes are *not* sequential
<Regenaxer>
The problem is exactly that the writes are *not* sequential
<Regenaxer>
The problem is exactly that the writes are *not* sequential
<Regenaxer>
The problem is exactly that the writes are *not* sequential
<Regenaxer>
The problem is exactly that the writes are *not* sequential
<Regenaxer>
So that what 'create' is for
<Regenaxer>
So that what 'create' is for
<Regenaxer>
So that what 'create' is for
<Regenaxer>
So that what 'create' is for
<Regenaxer>
So that what 'create' is for
<m_mans>
yes, right, only for fast imports
<m_mans>
yes, right, only for fast imports
<m_mans>
yes, right, only for fast imports
<m_mans>
yes, right, only for fast imports
<m_mans>
yes, right, only for fast imports
<Regenaxer>
it sorts the indexes to make them more or less sequential
<Regenaxer>
it sorts the indexes to make them more or less sequential
<Regenaxer>
it sorts the indexes to make them more or less sequential
<Regenaxer>
it sorts the indexes to make them more or less sequential
<Regenaxer>
it sorts the indexes to make them more or less sequential
<Regenaxer>
Try to do I/O with 32 GiB accessing *random* parts of the file
<Regenaxer>
Try to do I/O with 32 GiB accessing *random* parts of the file
<Regenaxer>
Try to do I/O with 32 GiB accessing *random* parts of the file
<Regenaxer>
Try to do I/O with 32 GiB accessing *random* parts of the file
<Regenaxer>
Try to do I/O with 32 GiB accessing *random* parts of the file
<m_mans>
so, 1k blocks are 4 times slower here, than 1m blocks
<m_mans>
so, 1k blocks are 4 times slower here, than 1m blocks
<m_mans>
so, 1k blocks are 4 times slower here, than 1m blocks
<m_mans>
so, 1k blocks are 4 times slower here, than 1m blocks
<m_mans>
so, 1k blocks are 4 times slower here, than 1m blocks
<Regenaxer>
Yes, but does that matter*
<Regenaxer>
Yes, but does that matter*
<Regenaxer>
Yes, but does that matter*
<Regenaxer>
Yes, but does that matter*
<Regenaxer>
Yes, but does that matter*
<Regenaxer>
According to my tests, writing speed does not matter at all
<Regenaxer>
According to my tests, writing speed does not matter at all
<Regenaxer>
According to my tests, writing speed does not matter at all
<Regenaxer>
According to my tests, writing speed does not matter at all
<Regenaxer>
According to my tests, writing speed does not matter at all
<Regenaxer>
For the above use case
<Regenaxer>
For the above use case
<Regenaxer>
For the above use case
<Regenaxer>
For the above use case
<Regenaxer>
For the above use case
<m_mans>
yes, 32Gb random reads/writes will be slow, you a right
<m_mans>
yes, 32Gb random reads/writes will be slow, you a right
<m_mans>
yes, 32Gb random reads/writes will be slow, you a right
<m_mans>
yes, 32Gb random reads/writes will be slow, you a right
<m_mans>
yes, 32Gb random reads/writes will be slow, you a right
<m_mans>
are
<m_mans>
are
<m_mans>
are
<m_mans>
are
<m_mans>
are
<Regenaxer>
It will trash
<Regenaxer>
It will trash
<Regenaxer>
It will trash
<Regenaxer>
It will trash
<Regenaxer>
It will trash
<Regenaxer>
It is a disk cache issue
<Regenaxer>
It is a disk cache issue
<Regenaxer>
It is a disk cache issue
<Regenaxer>
It is a disk cache issue
<Regenaxer>
It is a disk cache issue
<Regenaxer>
No matter how you fill the cache with write()
<Regenaxer>
No matter how you fill the cache with write()
<Regenaxer>
No matter how you fill the cache with write()
<Regenaxer>
No matter how you fill the cache with write()
<Regenaxer>
No matter how you fill the cache with write()
<Regenaxer>
It is the kernel that takes all the time
<Regenaxer>
It is the kernel that takes all the time
<Regenaxer>
It is the kernel that takes all the time
<Regenaxer>
It is the kernel that takes all the time
<Regenaxer>
It is the kernel that takes all the time
<Regenaxer>
trying to swap disk buffers in and out
<Regenaxer>
trying to swap disk buffers in and out
<Regenaxer>
trying to swap disk buffers in and out
<Regenaxer>
trying to swap disk buffers in and out
<Regenaxer>
trying to swap disk buffers in and out
<m_mans>
but what do you think about 4 times diff on sequental write 1m/1k block size?
<m_mans>
but what do you think about 4 times diff on sequental write 1m/1k block size?
<m_mans>
but what do you think about 4 times diff on sequental write 1m/1k block size?
<m_mans>
but what do you think about 4 times diff on sequental write 1m/1k block size?
<m_mans>
but what do you think about 4 times diff on sequental write 1m/1k block size?
<Regenaxer>
Good thing, but where is the problem? What does it solve?
<Regenaxer>
Good thing, but where is the problem? What does it solve?
<Regenaxer>
Good thing, but where is the problem? What does it solve?
<Regenaxer>
Good thing, but where is the problem? What does it solve?
<Regenaxer>
Good thing, but where is the problem? What does it solve?
<m_mans>
I suppose 512b will be even slower
<m_mans>
I suppose 512b will be even slower
<m_mans>
I suppose 512b will be even slower
<m_mans>
I suppose 512b will be even slower
<m_mans>
I suppose 512b will be even slower
<Regenaxer>
Pil uses the standard BLKSIZE of the system, usually 8 KiB
<Regenaxer>
Pil uses the standard BLKSIZE of the system, usually 8 KiB
<Regenaxer>
Pil uses the standard BLKSIZE of the system, usually 8 KiB
<Regenaxer>
Pil uses the standard BLKSIZE of the system, usually 8 KiB
<Regenaxer>
Pil uses the standard BLKSIZE of the system, usually 8 KiB
<Regenaxer>
but DB uses the size of the DB blocks
<Regenaxer>
but DB uses the size of the DB blocks
<Regenaxer>
but DB uses the size of the DB blocks
<Regenaxer>
but DB uses the size of the DB blocks
<Regenaxer>
but DB uses the size of the DB blocks
<Regenaxer>
as specified with 'dbs'
<Regenaxer>
as specified with 'dbs'
<Regenaxer>
as specified with 'dbs'
<Regenaxer>
as specified with 'dbs'
<Regenaxer>
as specified with 'dbs'
<Regenaxer>
usually 4 KiB for indexes
<Regenaxer>
usually 4 KiB for indexes
<Regenaxer>
usually 4 KiB for indexes
<Regenaxer>
usually 4 KiB for indexes
<Regenaxer>
usually 4 KiB for indexes
<Regenaxer>
So I do not understand in fact what you mean ;)
<Regenaxer>
So I do not understand in fact what you mean ;)
<Regenaxer>
So I do not understand in fact what you mean ;)
<Regenaxer>
So I do not understand in fact what you mean ;)
<Regenaxer>
So I do not understand in fact what you mean ;)
<Regenaxer>
what you suggest
<Regenaxer>
what you suggest
<Regenaxer>
what you suggest
<Regenaxer>
what you suggest
<Regenaxer>
what you suggest
<m_mans>
Regenaxer: sorry, I'm fixing urgent bugs on our site :) bbl
<m_mans>
Regenaxer: sorry, I'm fixing urgent bugs on our site :) bbl
<m_mans>
Regenaxer: sorry, I'm fixing urgent bugs on our site :) bbl
<m_mans>
Regenaxer: sorry, I'm fixing urgent bugs on our site :) bbl
<m_mans>
Regenaxer: sorry, I'm fixing urgent bugs on our site :) bbl
<Regenaxer>
ok :)
<Regenaxer>
ok :)
<Regenaxer>
ok :)
<Regenaxer>
ok :)
<Regenaxer>
ok :)
<m_mans>
back
<m_mans>
back
<m_mans>
back
<m_mans>
back
<m_mans>
back
<m_mans>
writes are random mainly because of indexes, right? I refer only to massive import case
<m_mans>
writes are random mainly because of indexes, right? I refer only to massive import case
<m_mans>
writes are random mainly because of indexes, right? I refer only to massive import case
<m_mans>
writes are random mainly because of indexes, right? I refer only to massive import case
<m_mans>
writes are random mainly because of indexes, right? I refer only to massive import case
m_mans1 has joined #picolisp
m_mans1 has joined #picolisp
m_mans1 has joined #picolisp
m_mans1 has joined #picolisp
m_mans1 has joined #picolisp
<Regenaxer>
Mainly indexes, but not only
<Regenaxer>
Mainly indexes, but not only
<Regenaxer>
Mainly indexes, but not only
<Regenaxer>
Mainly indexes, but not only
<Regenaxer>
Mainly indexes, but not only
<Regenaxer>
For example the OpenStreetMap model has nodes and ways
<Regenaxer>
For example the OpenStreetMap model has nodes and ways
<Regenaxer>
For example the OpenStreetMap model has nodes and ways
<Regenaxer>
For example the OpenStreetMap model has nodes and ways
<Regenaxer>
For example the OpenStreetMap model has nodes and ways
<Regenaxer>
Each way has a list of nodes
<Regenaxer>
Each way has a list of nodes
<Regenaxer>
Each way has a list of nodes
<Regenaxer>
Each way has a list of nodes
<Regenaxer>
Each way has a list of nodes
<Regenaxer>
and each nodes has a list of ways and a list of neighbours
<Regenaxer>
and each nodes has a list of ways and a list of neighbours
<Regenaxer>
and each nodes has a list of ways and a list of neighbours
<Regenaxer>
and each nodes has a list of ways and a list of neighbours
<Regenaxer>
and each nodes has a list of ways and a list of neighbours
<Regenaxer>
So these are pointing wildly around ;)
<Regenaxer>
So these are pointing wildly around ;)
<Regenaxer>
So these are pointing wildly around ;)
<Regenaxer>
So these are pointing wildly around ;)
<Regenaxer>
So these are pointing wildly around ;)
<Regenaxer>
These joints take about 80 of the import time, the objects and indexes the rest
<Regenaxer>
These joints take about 80 of the import time, the objects and indexes the rest
<Regenaxer>
These joints take about 80 of the import time, the objects and indexes the rest
<Regenaxer>
These joints take about 80 of the import time, the objects and indexes the rest
<Regenaxer>
These joints take about 80 of the import time, the objects and indexes the rest
<Regenaxer>
But *after* importing, it is extremely fast to display eg a set of ways
<Regenaxer>
But *after* importing, it is extremely fast to display eg a set of ways
<Regenaxer>
But *after* importing, it is extremely fast to display eg a set of ways
<Regenaxer>
But *after* importing, it is extremely fast to display eg a set of ways
<Regenaxer>
But *after* importing, it is extremely fast to display eg a set of ways
<Regenaxer>
all nodes and their connections are directly accessible
<Regenaxer>
all nodes and their connections are directly accessible
<Regenaxer>
all nodes and their connections are directly accessible
<Regenaxer>
all nodes and their connections are directly accessible
<Regenaxer>
all nodes and their connections are directly accessible
<m_mans>
ah, ok, the problem is wider then I thought
<m_mans>
ah, ok, the problem is wider then I thought
<m_mans>
ah, ok, the problem is wider then I thought
<m_mans>
ah, ok, the problem is wider then I thought
<m_mans>
ah, ok, the problem is wider then I thought
<Regenaxer>
yes, it is a general one. But still on most imports only indexes are relevant, and these are fast now with 'create'
<Regenaxer>
yes, it is a general one. But still on most imports only indexes are relevant, and these are fast now with 'create'
<Regenaxer>
yes, it is a general one. But still on most imports only indexes are relevant, and these are fast now with 'create'
<Regenaxer>
yes, it is a general one. But still on most imports only indexes are relevant, and these are fast now with 'create'
<Regenaxer>
yes, it is a general one. But still on most imports only indexes are relevant, and these are fast now with 'create'
<Regenaxer>
We could perhaps do something similar with +Joint's too
<Regenaxer>
We could perhaps do something similar with +Joint's too
<Regenaxer>
We could perhaps do something similar with +Joint's too
<Regenaxer>
We could perhaps do something similar with +Joint's too
<Regenaxer>
We could perhaps do something similar with +Joint's too
<Regenaxer>
ie at first pass put only one side of the joint, then pass over the sorted nodes etc.
<Regenaxer>
ie at first pass put only one side of the joint, then pass over the sorted nodes etc.
<Regenaxer>
ie at first pass put only one side of the joint, then pass over the sorted nodes etc.
<Regenaxer>
ie at first pass put only one side of the joint, then pass over the sorted nodes etc.
<Regenaxer>
ie at first pass put only one side of the joint, then pass over the sorted nodes etc.
<Regenaxer>
I think it is not worth the effort
<Regenaxer>
I think it is not worth the effort
<Regenaxer>
I think it is not worth the effort
<Regenaxer>
I think it is not worth the effort
<Regenaxer>
I think it is not worth the effort
<Regenaxer>
In "normal" applications you import "flat" data
<Regenaxer>
In "normal" applications you import "flat" data
<Regenaxer>
In "normal" applications you import "flat" data
<Regenaxer>
In "normal" applications you import "flat" data
<Regenaxer>
In "normal" applications you import "flat" data
<Regenaxer>
not graphs
<Regenaxer>
not graphs
<Regenaxer>
not graphs
<Regenaxer>
not graphs
<Regenaxer>
not graphs
<m_mans>
but, again, when I try a little example with 'create' (creating 1000000 small objects in loop) - it is relatavely slow
<m_mans>
but, again, when I try a little example with 'create' (creating 1000000 small objects in loop) - it is relatavely slow
<m_mans>
but, again, when I try a little example with 'create' (creating 1000000 small objects in loop) - it is relatavely slow
<m_mans>
but, again, when I try a little example with 'create' (creating 1000000 small objects in loop) - it is relatavely slow
<m_mans>
but, again, when I try a little example with 'create' (creating 1000000 small objects in loop) - it is relatavely slow
<Regenaxer>
One million?
<Regenaxer>
One million?
<Regenaxer>
One million?
<Regenaxer>
One million?
<Regenaxer>
One million?
<Regenaxer>
I think it takes 50 sec here
<Regenaxer>
I think it takes 50 sec here
<Regenaxer>
I think it takes 50 sec here
<Regenaxer>
I think it takes 50 sec here
<Regenaxer>
I think it takes 50 sec here
<m_mans>
file size is not so big, only 30mb if I remember correctly
<m_mans>
file size is not so big, only 30mb if I remember correctly
<m_mans>
file size is not so big, only 30mb if I remember correctly
<m_mans>
file size is not so big, only 30mb if I remember correctly
<m_mans>
file size is not so big, only 30mb if I remember correctly
<Regenaxer>
Let me try
<Regenaxer>
Let me try
<Regenaxer>
Let me try
<Regenaxer>
Let me try
<Regenaxer>
Let me try
<m_mans>
yes, here it took even less. But if we compare this with capabilities of hdd, it looks slow
<m_mans>
yes, here it took even less. But if we compare this with capabilities of hdd, it looks slow
<m_mans>
yes, here it took even less. But if we compare this with capabilities of hdd, it looks slow
<m_mans>
yes, here it took even less. But if we compare this with capabilities of hdd, it looks slow
<m_mans>
yes, here it took even less. But if we compare this with capabilities of hdd, it looks slow
<Regenaxer>
Ah, not 50. It is only 29 sec
<Regenaxer>
Ah, not 50. It is only 29 sec
<Regenaxer>
Ah, not 50. It is only 29 sec
<Regenaxer>
Ah, not 50. It is only 29 sec
<Regenaxer>
Ah, not 50. It is only 29 sec
<m_mans>
~ the same time here I suppose. Even with RAM disk
<m_mans>
~ the same time here I suppose. Even with RAM disk
<m_mans>
~ the same time here I suppose. Even with RAM disk
<m_mans>
~ the same time here I suppose. Even with RAM disk
<m_mans>
~ the same time here I suppose. Even with RAM disk
<Regenaxer>
As I'm trying to tell you all the time, the hard disk is *not* the problem
<Regenaxer>
As I'm trying to tell you all the time, the hard disk is *not* the problem
<Regenaxer>
As I'm trying to tell you all the time, the hard disk is *not* the problem
<Regenaxer>
As I'm trying to tell you all the time, the hard disk is *not* the problem
<Regenaxer>
As I'm trying to tell you all the time, the hard disk is *not* the problem
<Regenaxer>
If you use a SSD it takes the same time
<Regenaxer>
If you use a SSD it takes the same time
<Regenaxer>
If you use a SSD it takes the same time
<Regenaxer>
If you use a SSD it takes the same time
<Regenaxer>
If you use a SSD it takes the same time
<Regenaxer>
it is building the data structures
<Regenaxer>
it is building the data structures
<Regenaxer>
it is building the data structures
<Regenaxer>
it is building the data structures
<Regenaxer>
it is building the data structures
<Regenaxer>
objects and b-trees
<Regenaxer>
objects and b-trees
<Regenaxer>
objects and b-trees
<Regenaxer>
objects and b-trees
<Regenaxer>
objects and b-trees
<Regenaxer>
I/O is a minor part of that
<Regenaxer>
I/O is a minor part of that
<Regenaxer>
I/O is a minor part of that
<Regenaxer>
I/O is a minor part of that
<Regenaxer>
I/O is a minor part of that
<m_mans>
do you mean application part?
<m_mans>
do you mean application part?
<m_mans>
do you mean application part?
<m_mans>
do you mean application part?
<m_mans>
do you mean application part?
<Regenaxer>
yep
<Regenaxer>
yep
<Regenaxer>
yep
<Regenaxer>
yep
<Regenaxer>
yep
<m_mans>
not OS
<m_mans>
not OS
<m_mans>
not OS
<m_mans>
not OS
<m_mans>
not OS
<Regenaxer>
lib/db.l and lib/btree.l
<Regenaxer>
lib/db.l and lib/btree.l
<Regenaxer>
lib/db.l and lib/btree.l
<Regenaxer>
lib/db.l and lib/btree.l
<Regenaxer>
lib/db.l and lib/btree.l
<m_mans>
ah, ok, ok. Sorry if I told stupid things :))
<m_mans>
ah, ok, ok. Sorry if I told stupid things :))
<m_mans>
ah, ok, ok. Sorry if I told stupid things :))
<m_mans>
ah, ok, ok. Sorry if I told stupid things :))
<m_mans>
ah, ok, ok. Sorry if I told stupid things :))
<Regenaxer>
29 sec means 34483 objects per second
<Regenaxer>
29 sec means 34483 objects per second
<Regenaxer>
29 sec means 34483 objects per second
<Regenaxer>
29 sec means 34483 objects per second
<Regenaxer>
29 sec means 34483 objects per second
<Regenaxer>
plus three indexes
<Regenaxer>
plus three indexes
<Regenaxer>
plus three indexes
<Regenaxer>
plus three indexes
<Regenaxer>
plus three indexes
<Regenaxer>
34 objects per millisecond
<Regenaxer>
34 objects per millisecond
<Regenaxer>
34 objects per millisecond
<Regenaxer>
34 objects per millisecond
<Regenaxer>
34 objects per millisecond
<Regenaxer>
each with three properties and their indexes
<Regenaxer>
each with three properties and their indexes
<Regenaxer>
each with three properties and their indexes
<Regenaxer>
each with three properties and their indexes
<Regenaxer>
each with three properties and their indexes
<Regenaxer>
I think this is pretty fast
<Regenaxer>
I think this is pretty fast
<Regenaxer>
I think this is pretty fast
<Regenaxer>
I think this is pretty fast
<Regenaxer>
I think this is pretty fast
<m_mans>
yes, I agree
<m_mans>
yes, I agree
<m_mans>
yes, I agree
<m_mans>
yes, I agree
<m_mans>
yes, I agree
<Regenaxer>
As Pil is not optimized for speed here
<Regenaxer>
As Pil is not optimized for speed here
<Regenaxer>
As Pil is not optimized for speed here
<Regenaxer>
As Pil is not optimized for speed here
<Regenaxer>
As Pil is not optimized for speed here
<m_mans>
Interesting, what is most bottleneck places?
<m_mans>
Interesting, what is most bottleneck places?
<m_mans>
Interesting, what is most bottleneck places?
<m_mans>
Interesting, what is most bottleneck places?
<m_mans>
Interesting, what is most bottleneck places?
<m_mans>
b-trees or other parts?
<m_mans>
b-trees or other parts?
<m_mans>
b-trees or other parts?
<m_mans>
b-trees or other parts?
<m_mans>
b-trees or other parts?
<Regenaxer>
I think building the index nodes (here it is not the disk trashing yet)
<Regenaxer>
I think building the index nodes (here it is not the disk trashing yet)
<Regenaxer>
I think building the index nodes (here it is not the disk trashing yet)
<Regenaxer>
I think building the index nodes (here it is not the disk trashing yet)
<Regenaxer>
I think building the index nodes (here it is not the disk trashing yet)
<Regenaxer>
If you look with ps, you see the CPU is busy at 99 percent
<Regenaxer>
If you look with ps, you see the CPU is busy at 99 percent
<Regenaxer>
If you look with ps, you see the CPU is busy at 99 percent
<Regenaxer>
If you look with ps, you see the CPU is busy at 99 percent
<Regenaxer>
If you look with ps, you see the CPU is busy at 99 percent
<Regenaxer>
For large DBs, when the disk cache effect starts, it is only 20 or so percent
<Regenaxer>
For large DBs, when the disk cache effect starts, it is only 20 or so percent
<Regenaxer>
For large DBs, when the disk cache effect starts, it is only 20 or so percent
<Regenaxer>
For large DBs, when the disk cache effect starts, it is only 20 or so percent
<Regenaxer>
For large DBs, when the disk cache effect starts, it is only 20 or so percent
<Regenaxer>
the rest is spent in the kernel
<Regenaxer>
the rest is spent in the kernel
<Regenaxer>
the rest is spent in the kernel
<Regenaxer>
the rest is spent in the kernel
<Regenaxer>
the rest is spent in the kernel
<Regenaxer>
So for *small* DBs it could perhaps be made faster by writing the B-Tree stuff in assembly
<Regenaxer>
So for *small* DBs it could perhaps be made faster by writing the B-Tree stuff in assembly
<Regenaxer>
So for *small* DBs it could perhaps be made faster by writing the B-Tree stuff in assembly
<Regenaxer>
So for *small* DBs it could perhaps be made faster by writing the B-Tree stuff in assembly
<Regenaxer>
So for *small* DBs it could perhaps be made faster by writing the B-Tree stuff in assembly
<Regenaxer>
But small DBs are fast enough ;)
<Regenaxer>
But small DBs are fast enough ;)
<Regenaxer>
But small DBs are fast enough ;)
<Regenaxer>
But small DBs are fast enough ;)
<Regenaxer>
But small DBs are fast enough ;)
<Regenaxer>
And big DBs wont benefit
<Regenaxer>
And big DBs wont benefit
<Regenaxer>
And big DBs wont benefit
<Regenaxer>
And big DBs wont benefit
<Regenaxer>
And big DBs wont benefit
<m_mans>
thank you for the explanation!
<m_mans>
thank you for the explanation!
<m_mans>
thank you for the explanation!
<m_mans>
thank you for the explanation!
<m_mans>
thank you for the explanation!
<Regenaxer>
Welcome :)
<Regenaxer>
Welcome :)
<Regenaxer>
Welcome :)
<Regenaxer>
Welcome :)
<Regenaxer>
Welcome :)
<Regenaxer>
It is an interesting issue
<Regenaxer>
It is an interesting issue
<Regenaxer>
It is an interesting issue
<Regenaxer>
It is an interesting issue
<Regenaxer>
It is an interesting issue
<Regenaxer>
Perhaps one day we will extend 'create' to handle joints too
<Regenaxer>
Perhaps one day we will extend 'create' to handle joints too
<Regenaxer>
Perhaps one day we will extend 'create' to handle joints too
<Regenaxer>
Perhaps one day we will extend 'create' to handle joints too
<Regenaxer>
Perhaps one day we will extend 'create' to handle joints too
m_mans1 has quit [Quit: Leaving.]
m_mans1 has quit [Quit: Leaving.]
m_mans1 has quit [Quit: Leaving.]
m_mans1 has quit [Quit: Leaving.]
m_mans1 has quit [Quit: Leaving.]
m_mans has quit [Quit: Leaving]
m_mans has quit [Quit: Leaving]
m_mans has quit [Quit: Leaving]
m_mans has quit [Quit: Leaving]
m_mans has quit [Quit: Leaving]
jibanes has quit [Ping timeout: 272 seconds]
jibanes has quit [Ping timeout: 272 seconds]
jibanes has quit [Ping timeout: 272 seconds]
jibanes has quit [Ping timeout: 272 seconds]
jibanes has quit [Ping timeout: 272 seconds]
jibanes has joined #picolisp
jibanes has joined #picolisp
jibanes has joined #picolisp
jibanes has joined #picolisp
jibanes has joined #picolisp
orivej has joined #picolisp
orivej has joined #picolisp
orivej has joined #picolisp
orivej has joined #picolisp
orivej has joined #picolisp
orivej has quit [Ping timeout: 245 seconds]
orivej has quit [Ping timeout: 245 seconds]
orivej has quit [Ping timeout: 245 seconds]
orivej has quit [Ping timeout: 245 seconds]
orivej has quit [Ping timeout: 245 seconds]
beneroth has joined #picolisp
beneroth has joined #picolisp
beneroth has joined #picolisp
beneroth has joined #picolisp
beneroth has joined #picolisp
<beneroth>
hi all
<beneroth>
hi all
<beneroth>
hi all
<beneroth>
hi all
<beneroth>
hi all
<Regenaxer>
Hi beneroth! Happy New Year
<Regenaxer>
Hi beneroth! Happy New Year
<Regenaxer>
Hi beneroth! Happy New Year
<Regenaxer>
Hi beneroth! Happy New Year
<Regenaxer>
Hi beneroth! Happy New Year
<beneroth>
Happy New Year Regenaxer !
<beneroth>
Happy New Year Regenaxer !
<beneroth>
Happy New Year Regenaxer !
<beneroth>
Happy New Year Regenaxer !
<beneroth>
Happy New Year Regenaxer !
<Regenaxer>
:)
<Regenaxer>
:)
<Regenaxer>
:)
<Regenaxer>
:)
<Regenaxer>
:)
<Nistur>
Happy New Year lispers :)
<Nistur>
Happy New Year lispers :)
<Nistur>
Happy New Year lispers :)
<Nistur>
Happy New Year lispers :)
<Nistur>
Happy New Year lispers :)
<Regenaxer>
Hi Nistur! Same!
<Regenaxer>
Hi Nistur! Same!
<Regenaxer>
Hi Nistur! Same!
<Regenaxer>
Hi Nistur! Same!
<Regenaxer>
Hi Nistur! Same!
<beneroth>
Same Nistur, may you reach your goals.. or something.. in 2019 :)
<beneroth>
Same Nistur, may you reach your goals.. or something.. in 2019 :)
<beneroth>
Same Nistur, may you reach your goals.. or something.. in 2019 :)
<beneroth>
Same Nistur, may you reach your goals.. or something.. in 2019 :)
<beneroth>
Same Nistur, may you reach your goals.. or something.. in 2019 :)
<Nistur>
beneroth: my goals for 2019 have been severely descoped...
<Nistur>
beneroth: my goals for 2019 have been severely descoped...
<Nistur>
beneroth: my goals for 2019 have been severely descoped...
<Nistur>
beneroth: my goals for 2019 have been severely descoped...
<Nistur>
beneroth: my goals for 2019 have been severely descoped...
<Nistur>
We are... going to get a new tenant in July. Which means that, outside of work, my goals until July are: Prepare for tenant. And after July they will be: Look after tenant
<Nistur>
We are... going to get a new tenant in July. Which means that, outside of work, my goals until July are: Prepare for tenant. And after July they will be: Look after tenant
<Nistur>
We are... going to get a new tenant in July. Which means that, outside of work, my goals until July are: Prepare for tenant. And after July they will be: Look after tenant
<Nistur>
We are... going to get a new tenant in July. Which means that, outside of work, my goals until July are: Prepare for tenant. And after July they will be: Look after tenant
<Nistur>
We are... going to get a new tenant in July. Which means that, outside of work, my goals until July are: Prepare for tenant. And after July they will be: Look after tenant
<beneroth>
tenant ?
<beneroth>
tenant ?
<beneroth>
tenant ?
<beneroth>
tenant ?
<beneroth>
tenant ?
<beneroth>
kid ?
<beneroth>
kid ?
<beneroth>
kid ?
<beneroth>
kid ?
<beneroth>
kid ?
<Regenaxer>
Or lending a house or appartment to someone?
<Regenaxer>
Or lending a house or appartment to someone?
<Regenaxer>
Or lending a house or appartment to someone?
<Regenaxer>
Or lending a house or appartment to someone?
<Regenaxer>
Or lending a house or appartment to someone?
<Nistur>
beneroth: the latter
<Nistur>
beneroth: the latter
<Nistur>
beneroth: the latter
<Nistur>
beneroth: the latter
<Nistur>
beneroth: the latter
<Regenaxer>
New family member? Congrats!! :)
<Regenaxer>
New family member? Congrats!! :)
<Regenaxer>
New family member? Congrats!! :)
<Regenaxer>
New family member? Congrats!! :)
<Regenaxer>
New family member? Congrats!! :)
<Nistur>
Thanks :P I wonder if I can get a picolisp onsie for it ;)
<Nistur>
Thanks :P I wonder if I can get a picolisp onsie for it ;)
<Nistur>
Thanks :P I wonder if I can get a picolisp onsie for it ;)
<Nistur>
Thanks :P I wonder if I can get a picolisp onsie for it ;)
<Nistur>
Thanks :P I wonder if I can get a picolisp onsie for it ;)