What is the best way to process this list
Cecil Westerhof
recipes.
To get the ingredient list for my brownies recipe, I use:
(getf (get-recipe "Brownies") :ingredients)
and get:
((:QUANTITY "5" :TYPE "stuk" :INGREDIENT "eieren")
(:QUANTITY "350" :TYPE "gram" :INGREDIENT "suiker")
(:QUANTITY "175" :TYPE "gram" :INGREDIENT "boter (gesmolten)")
(:QUANTITY "1" :TYPE "eetlepel" :INGREDIENT "vanille essence")
(:QUANTITY "175" :TYPE "gram" :INGREDIENT "bloem")
(:QUANTITY "100" :TYPE "gram" :INGREDIENT "cacao")
(:QUANTITY "100" :TYPE "gram" :INGREDIENT "(walnoten)")
(:QUANTITY "100" :TYPE "gram" :INGREDIENT "(kokos)")
(:QUANTITY "2" :TYPE "stuk" :INGREDIENT "(bananen)")
(:QUANTITY "100" :TYPE "gram" :INGREDIENT "(hazelnoten)"))
This I want to display and this can be done with:
(dolist (this-ingredient (getf (get-recipe "Brownies") :ingredients))
(format t "~3@a ~8a ~a~%"
(getf this-ingredient :quantity)
(getf this-ingredient :type)
(getf this-ingredient :ingredient)))
and this gives:
5 stuk eieren
350 gram suiker
175 gram boter (gesmolten)
1 eetlepel vanille essence
175 gram bloem
100 gram cacao
100 gram (walnoten)
100 gram (kokos)
2 stuk (bananen)
100 gram (hazelnoten)
At the moment this is hard coded, but of course this is not what I want.
I want only to use the space that is needed. The way I am thinking about
it, is to do two dolist and in the first I could find the longest
lengths for :quantity and :type and use those in the format. I was just
wondering if there is not a more efficient way to do this.
--
Cecil Westerhof
Senior Software Engineer
LinkedIn: http://www.linkedin.com/in/cecilwesterhof
Cecil Westerhof
I already made a function for it:
(defun display-ingredients (recipe)
(let ((quantity-length 0)
(temp)
(type-length 0))
(dolist (this-ingredient (getf recipe :ingredients))
(setq temp (length (getf this-ingredient :quantity)))
(when (> temp quantity-length)
(setq quantity-length temp))
(setq temp (length (getf this-ingredient :type)))
(when (> temp type-length)
(setq type-length temp)))
(dolist (this-ingredient (getf recipe :ingredients))
(format t "~v@a ~va ~a~%"
quantity-length (getf this-ingredient :quantity)
type-length (getf this-ingredient :type)
(getf this-ingredient :ingredient)))))
With 'Brownies' I get:
(display-ingredients (get-recipe "Brownies"))
5 stuk eieren
350 gram suiker
175 gram boter (gesmolten)
1 eetlepel vanille essence
175 gram bloem
100 gram cacao
100 gram (walnoten)
100 gram (kokos)
2 stuk (bananen)
100 gram (hazelnoten)
With 'Salate de vinete' I get:
(display-ingredients (get-recipe "Salate de vinete"))
10 stuk grote aubergines
30 stuk gedroogde en gemalen pepers
3 stuk ui
1 eetlepel knoflook
2 eetlepels zout
olie
So it does what I want, but I was just wondering if there was a better
way? In this particular case it is not very important, because the lists
will not be very big, but I like to make things for the general case, so
that when the data set changes there are no nasty surprises.
Mirko
Instead of looping over the lists, maybe `reduce' will work:
(reduce #'> :key #'fifth ingredients) ;; untested
(see http://www.lispworks.com/documentation/HyperSpec/Body/f_reduce.htm)
Mirko
Tim X
<snip>
>
> So it does what I want, but I was just wondering if there was a better
> way? In this particular case it is not very important, because the lists
> will not be very big, but I like to make things for the general case, so
> that when the data set changes there are no nasty surprises.
I can see a couple of places where things could be improved, both with
respect to code style and algorithm. However, keep in mind that I'm
still learning this CL stuff as well!
I do think there are better data abstractions/structures to represent
your data, but as this is a learning exercise and it is only a simple
app, I'll leave that for now. However, once you have the basic blocks in
place, I would consider trying different data representations, such as
an association list, nested lists/trees or structs to start with.
Keeping that in mind, it may also help structure your code and decide
when to creat a function - think about what would need to be changed if
you moved from a property list to an association list or a tree or array
of structs etc and abstract that away with a function.
The two main things that jump out for me straight away are that you ar
traversing the same list twice and you are performing the same getf
operations twice. I'd be thinking about ways this could be avoided or
reduced. for example, maybe in the first loop, you could be creating a
new structure/list that is easier to process with format. While you
would still be looping over a list, you may be able to eliminate one set
of getf operations. (remember to consider what getf needs to do to
return the value!).
I remember you were asking before if lists were too inefficient and best
avoided. the response I gave was that lists in lisp are probably the most
efficient list implementation around and that for many tasks, they are
quite suitable. However, it is also important to use the lists well. for
example, the practice of pushing elements onto the front of a list an
then reversing it rather than appending new elements to reduce list
traversals is a common example. Lists can be quite efficient, but you do
still need to consider what they are and what various list operations
involve. Any operation that involves retrieving data from a list which
is not from the head/car of the list will involve list traversal and
therefore, could be expensive. Minimising how often you need to traverse
the list will improve efficiency.
On a style note, consider the difference between
> (let ((quantity-length 0)
> (temp)
> (type-length 0))
> (dolist (this-ingredient (getf recipe :ingredients))
> (setq temp (length (getf this-ingredient :quantity)))
> (when (> temp quantity-length)
> (setq quantity-length temp))
> (setq temp (length (getf this-ingredient :type)))
> (when (> temp type-length)
> (setq type-length temp)))
> (dolist (this-ingredient (getf recipe :ingredients))
and
> (let ((quantity-length 0)
> (type-length 0))
> (dolist (this-ingredient (getf recipe :ingredients))
(setf quantity-length (max (getf this-ingredient :quantity)
quantity-length))
(setf type-length (max (getf this-ingredient :type)
type-length))
> (dolist (this-ingredient (getf recipe :ingredients))
which removes the need for the tmp variable and the two 'when' blocks.
It also reveals a clearer pattern, which wold normally indicate a
possible further refinement. for example, maybe a function which accepts
a plist and a property name and returns the length of the longest
property for that property name. However, in this case, assuming we
stick with the plist, I'd be tempted to use a loop that builds up the
list of quantities and types with initial elements representing the
length of the longest quantity and type and then passing that list to format
for processing.
The loop macro is hated by some and loved by others. In this particular
case, I think it wold be worth investigating as it provides constructs
that would both collect the elements into a list and which could
calculate the maximum length for both quantity and type. Not necessarily
more efficient, but would likely be clearer code. In addition to
reducing the probability of subtle bugs and being easier to maintain,
clearer code also tends to reveal patterns better and helps to identify
where refactoring will further reduce the code and clarify its intention etc.
HTH
Tim
--
tcross (at) rapttech dot com dot au
Kenneth Tilton
Not worth worrying about, or even close to worth worrying about. It's
not even close to close to worth worrying about.
>> I already made a function for it:
>> (defun display-ingredients (recipe)
>> (let ((quantity-length 0)
>> (temp)
>> (type-length 0))
>> (dolist (this-ingredient (getf recipe :ingredients))
>> (setq temp (length (getf this-ingredient :quantity)))
>> (when (> temp quantity-length)
>> (setq quantity-length temp))
>> (setq temp (length (getf this-ingredient :type)))
>> (when (> temp type-length)
>> (setq type-length temp)))
>> (dolist (this-ingredient (getf recipe :ingredients))
>> (format t "~v@a ~va ~a~%"
>> quantity-length (getf this-ingredient :quantity)
>> type-length (getf this-ingredient :type)
>> (getf this-ingredient :ingredient)))))
>>
> <snip>
>> So it does what I want, but I was just wondering if there was a better
>> way? In this particular case it is not very important, because the lists
>> will not be very big, but I like to make things for the general case, so
>> that when the data set changes there are no nasty surprises.
I suggest you write the code you are writing now and not the code you
might write someday. Someday you can have a recipes container with slots
for max length of each column, and maintain it as you add new elements.
Using a plist is not the lay to go. Use defstruct. Simpler than a plist,
really, and massively more efficient.
uh, ya lost the length operator...
> quantity-length))
> (setf type-length (max (getf this-ingredient :type)
> type-length))
>> (dolist (this-ingredient (getf recipe :ingredients))
>
> which removes the need for the tmp variable and the two 'when' blocks.
> It also reveals a clearer pattern, which wold normally indicate a
> possible further refinement. for example, maybe a function which accepts
> a plist and a property name and returns the length of the longest
> property for that property name. However, in this case, assuming we
> stick with the plist, I'd be tempted to use a loop that builds up the
> list of quantities and types with initial elements representing the
> length of the longest quantity and type and then passing that list to format
> for processing.
>
> The loop macro is hated by some and loved by others. In this particular
> case,...
(loop for i in (getf recipe :ingredients)
maximizing (length (getf i :quantity))
into quantity-length
maximixing (length (getf i :type))
into type-length....
Yeah, hateful.
kt
--
http://thelaughingstockatpngs.com/
http://www.facebook.com/pages/The-Laughingstock/115923141782?ref=nf
Giorgos Keramidas
> I already made a function for it:
> (defun display-ingredients (recipe)
> (let ((quantity-length 0)
> (temp)
> (type-length 0))
> (dolist (this-ingredient (getf recipe :ingredients))
> (setq temp (length (getf this-ingredient :quantity)))
> (when (> temp quantity-length)
> (setq quantity-length temp))
> (setq temp (length (getf this-ingredient :type)))
> (when (> temp type-length)
> (setq type-length temp)))
> (dolist (this-ingredient (getf recipe :ingredients))
> (format t "~v@a ~va ~a~%"
> quantity-length (getf this-ingredient :quantity)
> type-length (getf this-ingredient :type)
> (getf this-ingredient :ingredient)))))
getf may only have to be called once per property (think of what getf
does to do its job):
CL-USER> (defun get-ordered-properties (plist indicator-list)
(mapcar (lambda (item)
(mapcar (lambda (prop)
(getf item prop))
indicator-list))
plist))
GET-ORDERED-PROPERTIES
CL-USER> (get-ordered-properties *ingredients* (list :quantity :type))
(("5" "stuk") ("350" "gram") ("175" "gram") ("1" "eetlepel")
("175" "gram") ("100" "gram") ("100" "gram") ("100" "gram")
("2" "stuk") ("100" "gram"))
Since your plist values are all strings, you can loop over the result
and just keep a running maximum for each string item:
CL-USER> (loop :for (quantity type) :in *foo*
:maximizing (length quantity) :into quantity-width
:maximizing (length type) :into type-width
:finally (return (list quantity-width type-width)))
(3 8)
Now you have your column widths.
Nicolas Neuss
> This I want to display and this can be done with:
> (dolist (this-ingredient (getf (get-recipe "Brownies") :ingredients))
> (format t "~3@a ~8a ~a~%"
> (getf this-ingredient :quantity)
> (getf this-ingredient :type)
> (getf this-ingredient :ingredient)))
Something as
(loop for (&key quantity type ingredient &allow-other-keys) in
(getf (get-recipe "Brownies") :ingredients) do
(format t "~3@a ~8a ~a~%" quantity type ingredient))
looks nicer to me.
Nicolas
Pascal J. Bourguignon
> Not worth worrying about, or even close to worth worrying about. It's
> not even close to close to worth worrying about.
Correct.
> I suggest you write the code you are writing now and not the code you
> might write someday. Someday you can have a recipes container with
> slots for max length of each column, and maintain it as you add new
> elements.
Yes.
> Using a plist is not the lay to go. Use defstruct. Simpler than a
> plist, really, and massively more efficient.
False. Structures are not always faster than plist. Notaby,
implementations may typecheck the structure object, which slows
structure accessors so much that plist up to 5 or even more slots is
faster. Of course, if you need that kind of speed, you can always add
(:type list) to your defstruct instead. But the point is that short
lists are faster than most other data structures.
--
__Pascal Bourguignon__ http://www.informatimago.com/
Tim X
I also think, at this stage of learning, its often good to first try
things using something like a plist and then refactor using something
else, such as defstruct. In reality, given what th eOP is doing, the
difference in performance between defstruct and plist is likely to be
negligible. However, the difference in code clarity and ease of
expression using the defstruct is going to make coding the app a lot
easier (I suspect this was KTs main point). For some people, it is often
only through doing it the wrong way you begin to really appreciate the
right way (all too often, I find I'm one of these). The choice of the
right abstraction is something that comes with experience - when
learning, I find it is sometimes valueable to use all the different
abstractions the language offers for the same problem because you then
get first hand experience regarding the strengths/weaknesses of each
within that language. This is why I suggested to the OP that he
continues to use the plist based abstraction, but do so in such a way
that you can then change the abstraction later to see what impact it
has. While most abstractions will have obvious strengths/weaknesses,
sometimes its only hands-on experience which really gives you a feel for
them in that language. For example, using a linked list in C has
significant overhead and complexity compared to CL, but the basic
pros/cons of a linked list are the same in both languages.
This also needs to be balanced with the very valid point regarding
writing the code you mean to write and avoiding making things to
contrived just for the sake of it. When you find things are becoming too
contorted or difficult because of your initial choice of abstraction,
then its usually time to refactor and select a new abstraction better
able to satisfy your evolving requirements. While the recipie app may be
a little contrived, its still important to have a 'real' something at
the end of the day.
Kenneth Tilton
>> Using a plist is not the lay to go. Use defstruct. Simpler than a
>> plist, really, and massively more efficient.
>
> False. Structures are not always faster than plist. Notaby,
> implementations may typecheck the structure object, which slows
> structure accessors so much that plist up to 5 or even more slots is
> faster.
Rubbish! What crappy implementation are you imagining for these
incredibly slow defstructs (by which I mean which Lisp and how do they
implement defstructs by default? Lemme see some timings!
mdj
> > False. Structures are not always faster than plist. Notaby,
> > implementations may typecheck the structure object, which slows
> > structure accessors so much that plist up to 5 or even more slots is
> > faster.
>
> Rubbish! What crappy implementation are you imagining for these
> incredibly slow defstructs (by which I mean which Lisp and how do they
> implement defstructs by default? Lemme see some timings!
Unless the structures were implemented with conses this seems almost
impossible, since a slot access can be compiled out to nothing more
than indexed addressing! And the type check is what, a single
compare ?
Kenneth Tilton
Yep.
> And the type check is what, a single
> compare ?
>
Type-checking is for Java/C++ wusses! I always get a kick out of struct
accessors working on the wrong struct when I screw up. Same thing with
coding the wrong copier: copies fine!
mdj
> Type-checking is for Java/C++ wusses! I always get a kick out of struct
> accessors working on the wrong struct when I screw up. Same thing with
> coding the wrong copier: copies fine!
Well, 'correct' programs don't need it :-) I like the "lisp way" of
providing runtime checking until I decide I need the speed more than
the belt ...
Pillsy
[...]
> I suggest you write the code you are writing now and not the code you
> might write someday.
I nominate this for the Kenny fortune file.
Cheers,
Pillsy
Pascal J. Bourguignon
> Pascal J. Bourguignon wrote:
>
>>> Using a plist is not the lay to go. Use defstruct. Simpler than a
>>> plist, really, and massively more efficient.
>>
>> False. Structures are not always faster than plist. Notaby,
>> implementations may typecheck the structure object, which slows
>> structure accessors so much that plist up to 5 or even more slots is
>> faster.
>
> Rubbish! What crappy implementation are you imagining for these
> incredibly slow defstructs (by which I mean which Lisp and how do they
> implement defstructs by default? Lemme see some timings!
>
> kt
Existance proof:
C/USER[11]> (defstruct ss a b c d e)
SS
C/USER[12]> (let ((s (make-ss :a 42))) (time (loop :repeat 100000 :do (ss-a s))))
Real time: 0.494208 sec.
Run time: 0.464029 sec.
Space: 804400 Bytes
NIL
C/USER[13]> (defstruct (sl (:type list)) a b c d e)
SL
C/USER[14]> (let ((s (make-sl :a 42))) (time (loop :repeat 100000 :do (sl-a s))))
Real time: 0.489189 sec.
Run time: 0.424026 sec.
Space: 804400 Bytes
GC: 1, GC time: 0.012001 sec.
NIL
C/USER[15]> (values (lisp-implementation-type) (lisp-implementation-version))
"CLISP" ;
"2.41 (2006-10-13) (built on thalassa.lan.informatimago.com [192.168.1.198])"
C/USER[17]> (disassemble 'ss-a)
Disassembly of function SS-A
(CONST 0) = SS
(CONST 1) = 1
1 required argument
0 optional arguments
No rest parameter
No keyword parameters
5 byte-code instructions:
0 (CONST&PUSH 0) ; SS
1 (LOAD&PUSH 2)
2 (CONST&PUSH 1) ; 1
3 (CALLS2 47) ; SYSTEM::%STRUCTURE-REF
5 (SKIP&RET 2)
NIL
C/USER[18]> (disassemble 'sl-a)
Disassembly of function SL-A
1 required argument
0 optional arguments
No rest parameter
No keyword parameters
3 byte-code instructions:
0 (LOAD 1)
1 (CAR)
2 (SKIP&RET 2)
NIL
C/USER[19]>
Kenneth Tilton
PWUAHAHAHAHA!!! What made you choose slot A? PWUAHAHAHHAHAAH!!!!
kenny
Pascal J. Bourguignon
> PWUAHAHAHAHA!!! What made you choose slot A? PWUAHAHAHHAHAAH!!!!
aref, or a structure slot access could involve a multiplication, which
is often slower tha a few memory accesses (as long as the cache is hit).
In any case, my advice is to use defstruct, and once your application
is debugged, if you need to optimize speed and you didn't use generic
function on these structures, try out (:type vector) or (:type list).
Thomas A. Russ
> So it does what I want, but I was just wondering if there was a better
> way? In this particular case it is not very important, because the lists
> will not be very big, but I like to make things for the general case, so
> that when the data set changes there are no nasty surprises.
Well, I would think that a "better" way might be one that is more
flexible. Also, you could improve robustness by handling the case where
there is no corresponding value. Consider the following code for doing
the formatting. It does still need to go through the list twice, but I
don't think there is a way to avoid that.
(defun display-formatted-properties (keylist list-of-plists stream)
(let ((field-lengths (make-array (length keylist) :initial-element 0)))
(loop for plist in list-of-plists
do (loop for key in keylist
as i upfrom 0
do (setf (aref field-lengths i)
(max (aref field-lengths i)
(length (getf plist key ""))))))
(loop for plist in list-of-plists
do (loop for key in keylist
as i upfrom 0
do (format stream " ~vA"
(aref field-lengths i)
(getf plist key "")))
(format stream "~%"))))
I used LOOP mainly to get parallel stepping in the inner loop. One could
use DOLIST with explicit assignments instead. Note that this doesn't do
different left/right justification, although one could add that as an
extension.
(display-formatted-properties '(:quantity :type :ingredient)
(getf (get-recipe "Brownies") :ingredients)
*standard-output*)
5 stuk eieren
350 gram suiker
175 gram boter (gesmolten)
1 eetlepel vanille essence
175 gram bloem
100 gram cacao
100 gram (walnoten)
100 gram (kokos)
2 stuk (bananen)
100 gram (hazelnoten)
If you want to have this work with more than just strings, you can achieve
that by using format on the value returned by GETF when computing the
length. But if you do that, it may be just better to collect all of the
string values along with the field lengths so that you (a) only call
FORMAT once per data item and (b) are sure that the length and the output
formats remain the same. This will also do justification for :LEFT :RIGHT
or :CENTER if specified, and will also optionally produce column headers
based on the keywords.
(defun display-formatted-properties (keylist list-of-plists stream
&key alignment include-header-p)
(if alignment
(assert (= (length keylist) (length alignment)))
(setq alignment (make-list (length keylist) :initial-element :left)))
(let ((field-lengths (make-array (length keylist) :initial-element 0))
(formatted-strings nil))
(setq formatted-strings
(loop for plist in list-of-plists
collect (loop for key in keylist
as i upfrom 0
as formatted-value = (format nil "~A"
(getf plist key ""))
do (setf (aref field-lengths i)
(max (aref field-lengths i)
(length formatted-value)))
collect formatted-value)))
(when include-header-p
(push (loop for key in keylist
as keystring = (format nil "~A" key)
as i upfrom 0
do (setf (aref field-lengths i)
(max (aref field-lengths i)
(length keystring)))
collect keystring)
formatted-strings))
(loop for strings in formatted-strings
do (loop for item in strings
as align in alignment
as i upfrom 0
as width = (aref field-lengths i)
do (when (> width 0) ; Only do non-empty fields
(when (> i 0)
(format stream " "))
(ecase align
(:left (format stream "~vA" width item))
(:right (format stream "~v@A" width item))
(:center (format stream "~v:@<~A~>" width item)))))
(format stream "~%"))))
(display-formatted-properties '(:quantity :type :ingredient)
(getf (get-recipe "Brownies") :ingredients)
t)
5 stuk eieren
350 gram suiker
175 gram boter (gesmolten)
1 eetlepel vanille essence
175 gram bloem
100 gram cacao
100 gram (walnoten)
100 gram (kokos)
2 stuk (bananen)
100 gram (hazelnoten)
(display-formatted-properties '(:quantity :type :ingredient)
(getf (get-recipe "Brownies") :ingredients)
t
:include-header-p t
:alignment '(:right :left :left))
QUANTITY TYPE INGREDIENT
5 stuk eieren
350 gram suiker
175 gram boter (gesmolten)
1 eetlepel vanille essence
175 gram bloem
100 gram cacao
100 gram (walnoten)
100 gram (kokos)
2 stuk (bananen)
100 gram (hazelnoten)
(display-formatted-properties '(:ingredient :quantity :type)
(getf (get-recipe "Brownies") :ingredients)
t
:include-header-p t
:alignment '(:center :right :left))
INGREDIENT QUANTITY TYPE
eieren 5 stuk
suiker 350 gram
boter (gesmolten) 175 gram
vanille essence 1 eetlepel
bloem 175 gram
cacao 100 gram
(walnoten) 100 gram
(kokos) 100 gram
(bananen) 2 stuk
(hazelnoten) 100 gram
======================================
And then there is the entire set of solutions that use the MAPing
functions instead of loops.
Kenneth Tilton
> Kenneth Tilton <kent...@gmail.com> writes:
>> PWUAHAHAHAHA!!! What made you choose slot A? PWUAHAHAHHAHAAH!!!!
>
> aref, or a structure slot access could involve a multiplication, which
> is often slower tha a few memory accesses (as long as the cache is hit).
Keep wiggling, and while you are at it let's review the record:
Pascal J. Bourguignon wrote:
> Kenneth Tilton <kent...@gmail.com> writes:
>> Using a plist is not the lay to go. Use defstruct. Simpler than a
>> plist, really, and massively more efficient.
>
> False. Structures are not always faster than plist.
False? I said "plist" and you said "plist" and you offer timings and
disassembly of a list defstruct? Tsk, tsk.
Let's see those fancy timings and disassemblies of (getf x :ingredient)
-- yes, it is my turn to stack the deck, we'll take the third attribute.
kt
mdj
wrote:
> Kenneth Tilton <kentil...@gmail.com> writes:
> > PWUAHAHAHAHA!!! What made you choose slot A? PWUAHAHAHHAHAAH!!!!
>
> aref, or a structure slot access could involve a multiplication, which
> is often slower tha a few memory accesses (as long as the cache is hit).
For aref, that's true (unless the index is a power of two into a one
dimensional array) but not for structures. There's no point at all in
having generated code recompute a value that is derivable at structure
definition time.
Matt
Pascal J. Bourguignon
Yes. But still, some implementation just do that. See the
disassembly I posted.
mdj
wrote:
> > For aref, that's true (unless the index is a power of two into a one
> > dimensional array) but not for structures. There's no point at all in
> > having generated code recompute a value that is derivable at structure
> > definition time.
>
> Yes. But still, some implementation just do that. See the
> disassembly I posted.
And some don't:
SBCL 1.0.30 (Linux x86_64) :
(let ((s (make-ss :a 42))) (time (loop :repeat 100000 :do (ss-a s))))
Evaluation took:
0.000 seconds of real time
0.000000 seconds of total run time (0.000000 user, 0.000000 system)
100.00% CPU
100,746 processor cycles
0 bytes consed
(let ((s (make-sl :a 42))) (time (loop :repeat 100000 :do (sl-a s))))
Evaluation took:
0.000 seconds of real time
0.001000 seconds of total run time (0.001000 user, 0.000000 system)
100.00% CPU
699,300 processor cycles
0 bytes consed
Your example only shows that CLISP has a crummy implementation of
structures, not that plists can outperform structures below a certain
number of members.
An optimal implementation will contain less memory references for
structures regardless of machine architecture, and will be faster.
period.
Matt
Kenneth Tilton
Where has anybody timed a plist? I see no timings of the plist
implementation. Does everyone know what is a plist? Am I the only one
that understands that PB quickly abandoned "plists are just as fast" as
soon as he realized his gaffe and pretended the issue was defstructs of
type list? Is the Tiger Woods implosion bigger than OJ's?
kenneth
---
http://www.stuckonalgebra.com
mdj
> Where has anybody timed a plist? I see no timings of the plist
> implementation. Does everyone know what is a plist? Am I the only one
> that understands that PB quickly abandoned "plists are just as fast" as
> soon as he realized his gaffe and pretended the issue was defstructs of
> type list?
I just assume list based structs are plists and not alists and that
the performance is representative. I feel no compulsion to prove what
should be obvious ...
> Is the Tiger Woods implosion bigger than OJ's?
I think they inserted entirely different objects into the respective
women, so it's difficult to do an objective comparison
Ron Garret
<d50e5346-8eef-457c...@j5g2000yqm.googlegroups.com>,
mdj <mdj...@gmail.com> wrote:
> On Jan 5, 12:14 pm, Kenneth Tilton <kentil...@gmail.com> wrote:
>
> > Where has anybody timed a plist? I see no timings of the plist
> > implementation. Does everyone know what is a plist? Am I the only one
> > that understands that PB quickly abandoned "plists are just as fast" as
> > soon as he realized his gaffe and pretended the issue was defstructs of
> > type list?
>
> I just assume list based structs are plists and not alists
Why do you think they have to be one or the other?
rg
Ron Garret
Ron Garret <rNOS...@flownet.com> wrote:
BTW, here's a clue:
? (defstruct foo a b)
FOO
? (setf foo1 (make-foo :a 'a :b 'b))
#S(FOO :A A :B B)
? (defstruct foo b a)
FOO
? foo1
#S(FOO :B A :A B)
rg
Madhu
Wrote on Mon, 04 Jan 2010 21:22:26 -0800:
|> In article
|> <d50e5346-8eef-457c...@j5g2000yqm.googlegroups.com>,
|> mdj <mdj...@gmail.com> wrote:
|
|> > I just assume list based structs are plists and not alists
|>
|> Why do you think they have to be one or the other?
|
| BTW, here's a clue:
|
| ? (defstruct foo a b)
| FOO
| ? (setf foo1 (make-foo :a 'a :b 'b))
| #S(FOO :A A :B B)
| ? (defstruct foo b a)
| FOO
| ? foo1
| #S(FOO :B A :A B)
First This is not conformant code. The standard clearly states:
`The consequences of redefining a defstruct structure are undefined.'
<http://www.lispworks.com/documentation/HyperSpec/Body/m_defstr.htm>
What you are actually illustrating is how your particular lisp
implementation changes the layout of existing instances after a
structure definition has changed. Other implementation choices could
choose to keep the old instances in their old layouts.
In any case this has no relevance to using either alists or plists or
simple position based lists (accessed by NTH) and is bound to be
misleading.
--
Madhu
Ron Garret
Madhu <eno...@meer.net> wrote:
> * Ron Garret <rNOSPAMon-A6D73...@news.albasani.net> :
> Wrote on Mon, 04 Jan 2010 21:22:26 -0800:
> |> In article
> |> <d50e5346-8eef-457c...@j5g2000yqm.googlegroups.com>,
> |> mdj <mdj...@gmail.com> wrote:
> |
> |> > I just assume list based structs are plists and not alists
> |>
> |> Why do you think they have to be one or the other?
> |
> | BTW, here's a clue:
> |
> | ? (defstruct foo a b)
> | FOO
> | ? (setf foo1 (make-foo :a 'a :b 'b))
> | #S(FOO :A A :B B)
> | ? (defstruct foo b a)
> | FOO
> | ? foo1
> | #S(FOO :B A :A B)
>
> First This is not conformant code.
I didn't say it was.
> In any case this has no relevance to using either alists or plists or
> simple position based lists (accessed by NTH) and is bound to be
> misleading.
That's true, but that's not the topic I was addressing. The topic I was
addressing was whether the assumption that "list based structs are
plists and not alists" is reasonable.
rg
Madhu
* Ron Garret <rNOSPAMon-79BB4...@news.albasani.net> :
Wrote on Mon, 04 Jan 2010 23:22:04 -0800:
|>
|> First This is not conformant code.
|
| I didn't say it was.
|
|> In any case this has no relevance to using either alists or plists or
|> simple position based lists (accessed by NTH) and is bound to be
|> misleading.
|
| That's true, but that's not the topic I was addressing. The topic I
| was addressing was whether the assumption that "list based structs are
| plists and not alists" is reasonable.
Right, My point was that not only was the code you posted
non-conformant, but it is also not relevant to addressing the assumption
you wish to address. To repeat what I said, the code you posted
illustrates what one your particular lisp implementation changes the
layout of existing instances after a structure definition has
changed. There are other alternatives in other implementations.
Besides What you shewed was the printed representation of the structure
which has no direct relevance to how it is implemented --- in whatsoever
way --- be it ANY type of lists or arrays. One could layout a defstruct
instance using a persistent database backend, and it would still print
as #S(:A 10 :B 20).
--
Madhu
mdj
> In article <m3my0tf3if....@moon.robolove.meer.net>,
>
>
>
> Madhu <enom...@meer.net> wrote:
> > * Ron Garret <rNOSPAMon-A6D739.21222604012...@news.albasani.net> :
> > Wrote on Mon, 04 Jan 2010 21:22:26 -0800:
> > |> In article
> > |> mdj <mdj....@gmail.com> wrote:
> > |
> > |> > I just assume list based structs are plists and not alists
> > |>
> > |> Why do you think they have to be one or the other?
> > |
> > | BTW, here's a clue:
> > |
> > | ? (defstruct foo a b)
> > | FOO
> > | ? (setf foo1 (make-foo :a 'a :b 'b))
> > | #S(FOO :A A :B B)
> > | ? (defstruct foo b a)
> > | FOO
> > | ? foo1
> > | #S(FOO :B A :A B)
>
> > First This is not conformant code.
>
> I didn't say it was.
>
> > In any case this has no relevance to using either alists or plists or
> > simple position based lists (accessed by NTH) and is bound to be
> > misleading.
>
> That's true, but that's not the topic I was addressing. The topic I was
> addressing was whether the assumption that "list based structs are
> plists and not alists" is reasonable.
It's not. My bad. List structures are required by the standard to be
position based, and the car will be the structure name if it's :name'd
in the defstruct. Accessors (at least in SBCL) use ELT to access the
element, since you're free to specify vector as the type instead of
list.
In any case, the example you gave was of an untyped defstruct, which
will be a class, not a list, and the implementation is free to
implement slots on classes however it sees fit.
Matt
Kenneth Tilton
> On Jan 5, 12:14 pm, Kenneth Tilton <kentil...@gmail.com> wrote:
>
>> Where has anybody timed a plist? I see no timings of the plist
>> implementation. Does everyone know what is a plist? Am I the only one
>> that understands that PB quickly abandoned "plists are just as fast" as
>> soon as he realized his gaffe and pretended the issue was defstructs of
>> type list?
>
> I just assume list based structs are plists and not alists and that
> the performance is representative.
I see. You are barking mad. Welcome to the group!
> I feel no compulsion to prove what
> should be obvious ...
Good for you!
kt
w_a_x_man
> Cecil Westerhof <Ce...@decebal.nl> writes:
> > I am still experimenting with CL. At the moment I am working with
> > recipes.
> (display-ingredients (get-recipe "Brownies"))
> 5 stuk eieren
> 350 gram suiker
> 175 gram boter (gesmolten)
> 1 eetlepel vanille essence
> 175 gram bloem
> 100 gram cacao
> 100 gram (walnoten)
> 100 gram (kokos)
> 2 stuk (bananen)
> 100 gram (hazelnoten)
>
> (display-ingredients (get-recipe "Salate de vinete"))
> 10 stuk grote aubergines
> 30 stuk gedroogde en gemalen pepers
> 3 stuk ui
> 1 eetlepel knoflook
> 2 eetlepels zout
> olie
>
> So it does what I want, but I was just wondering if there was a better
> way? In this particular case it is not very important, because the lists
> will not be very big, but I like to make things for the general case, so
> that when the data set changes there are no nasty surprises.
In Bigloo Scheme:
(module recipe
(main main)
(extern (macro eprintf::int (string string string string)
"printf")))
(define (getf flat-list key)
(cadr (member key flat-list)))
(define brownies
'((:QUANTITY "5" :TYPE "stuk" :INGREDIENT "eieren")
(:QUANTITY "350" :TYPE "gram" :INGREDIENT "suiker")
(:QUANTITY "175" :TYPE "gram" :INGREDIENT "boter (gesmolten)")
(:QUANTITY "1" :TYPE "eetlepel" :INGREDIENT "vanille essence")
(:QUANTITY "175" :TYPE "gram" :INGREDIENT "bloem")
(:QUANTITY "100" :TYPE "gram" :INGREDIENT "cacao")
(:QUANTITY "100" :TYPE "gram" :INGREDIENT "(walnoten)")
(:QUANTITY "100" :TYPE "gram" :INGREDIENT "(kokos)")
(:QUANTITY "2" :TYPE "stuk" :INGREDIENT "(bananen)")
(:QUANTITY "100" :TYPE "gram" :INGREDIENT "(hazelnoten)")))
(define (max-width recipe field)
(apply max (map (lambda (x) (string-length (getf x field)))
recipe)))
(define (main args)
(let [(keys '(:QUANTITY :TYPE :INGREDIENT))]
(multiple-value-bind (qw tw iw)
(apply values
(map (lambda(k)(number->string (max-width brownies k)))
keys))
(let [(fstring (string-append " %" qw "s %-" tw "s %s\n"))]
(for-each
(lambda (x) (apply eprintf fstring
(map (lambda(k)(getf x k)) keys)))
brownies)))))
Ron Garret
<68313485-b59e-4f8c...@e27g2000yqd.googlegroups.com>,
mdj <mdj...@gmail.com> wrote:
Right. The point is that PLIST and ALIST are NOT an exhaustive
enumeration of the possible representations of a struct whose type is
list.
rg
Ron Garret
Madhu <eno...@meer.net> wrote:
> * Ron Garret <rNOSPAMon-79BB4...@news.albasani.net> :
> Wrote on Mon, 04 Jan 2010 23:22:04 -0800:
>
> |>
> |> First This is not conformant code.
> |
> | I didn't say it was.
> |
> |> In any case this has no relevance to using either alists or plists or
> |> simple position based lists (accessed by NTH) and is bound to be
> |> misleading.
> |
> | That's true, but that's not the topic I was addressing. The topic I
> | was addressing was whether the assumption that "list based structs are
> | plists and not alists" is reasonable.
>
> Right, My point was that not only was the code you posted
> non-conformant, but it is also not relevant to addressing the assumption
> you wish to address.
Happily, the person to whom the remark was addressed was able to see
that it was.
> To repeat what I said, the code you posted
> illustrates what one your particular lisp implementation changes the
> layout of existing instances after a structure definition has
> changed.
Actually it shows exactly the opposite, that my Lisp does NOT change the
layout of existing instances. I am pleased to see that the First Law of
Madhu (to wit: Madhu is always Wrong about Everything) will not have to
be revised.
> There are other alternatives in other implementations.
>
> Besides What you shewed was the printed representation of the structure
> which has no direct relevance to how it is implemented --- in whatsoever
> way --- be it ANY type of lists or arrays. One could layout a defstruct
> instance using a persistent database backend, and it would still print
> as #S(:A 10 :B 20).
You need to pay closer attention. The result I exhibited was
inconsistent with the underlying implementation being either an ALIST or
a PLIST.
There is actually one valid criticism of my example, and that is that I
left out the :TYPE LIST option. So here's the correct example:
? (defstruct (foo (:type list)) a b)
FOO
? (make-foo :a 'aa :b 'bb)
(AA BB)
? (type-of *)
CONS
Heh, look at that. Conforming code!
rg
Madhu
* Ron Garret <rNOSPAMon-D4C12...@news.albasani.net> :
Wrote on Tue, 05 Jan 2010 10:38:16 -0800:
| In article <m3iqbhf...@moon.robolove.meer.net>,
| Madhu <eno...@meer.net> wrote:
|
|> * Ron Garret <rNOSPAMon-79BB4...@news.albasani.net> :
|> Wrote on Mon, 04 Jan 2010 23:22:04 -0800:
|>
|> |>
|> |> First This is not conformant code.
|> |
|> | I didn't say it was.
|> |
|> |> In any case this has no relevance to using either alists or plists or
|> |> simple position based lists (accessed by NTH) and is bound to be
|> |> misleading.
|> |
|> | That's true, but that's not the topic I was addressing. The topic I
|> | was addressing was whether the assumption that "list based structs are
|> | plists and not alists" is reasonable.
|>
|> Right, My point was that not only was the code you posted
|> non-conformant, but it is also not relevant to addressing the assumption
|> you wish to address.
|
| Happily, the person to whom the remark was addressed was able to see
| that it was.
I hope he was able to see exactly how wrong an example your code was in
the context.
|> To repeat what I said, the code you posted illustrates what one your
|> particular lisp implementation changes the layout of existing
|> instances after a structure definition has changed.
|
| Actually it shows exactly the opposite, that my Lisp does NOT change
| the layout of existing instances.
No. It does not show that.
| I am pleased to see that the First Law of Madhu (to wit: Madhu is
| always Wrong about Everything) will not have to be revised.
The law you seem to prove is that you are clueless AND wrong EVERYTIME
you post anything related to DEFSTRUCT (as with other parts of Common
Lisp)
|> There are other alternatives in other implementations.
|>
|> Besides What you shewed was the printed representation of the structure
|> which has no direct relevance to how it is implemented --- in whatsoever
|> way --- be it ANY type of lists or arrays. One could layout a defstruct
|> instance using a persistent database backend, and it would still print
|> as #S(:A 10 :B 20).
|
| You need to pay closer attention. The result I exhibited was
| inconsistent with the underlying implementation being either an ALIST or
| a PLIST.
No. You did not exhibit that. You exhhibited "undefined behaviour" in a
Lisp implementation where a LIST based representation was NOT requested.
| There is actually one valid criticism of my example, and that is that
| I left out the :TYPE LIST option. So here's the correct example
The valid criticism I made of your example was that it was irrelevant
nonsense on multiple counts. Comparing your example with the following
will only prove that.
mdj
> | Happily, the person to whom the remark was addressed was able to see
> | that it was.
>
> I hope he was able to see exactly how wrong an example your code was in
> the context.
No you don't. You're only interested in foolish bickering.
The example (whilst ostensibly incorrect) at least prompted me to read
the spec and confirm how list based structures are implemented.
> |> To repeat what I said, the code you posted illustrates what one your
> |> particular lisp implementation changes the layout of existing
> |> instances after a structure definition has changed.
> |
> | Actually it shows exactly the opposite, that my Lisp does NOT change
> | the layout of existing instances.
>
> No. It does not show that.
Are you stupid? That's exactly what it shows.
> | I am pleased to see that the First Law of Madhu (to wit: Madhu is
> | always Wrong about Everything) will not have to be revised.
>
> The law you seem to prove is that you are clueless AND wrong EVERYTIME
> you post anything related to DEFSTRUCT (as with other parts of Common
> Lisp)
Proof? The only thing I can see proof of is that you lose your ability
to think rationally when someone challenges you.
And yes everyone, I realise I'm assuming a preexisting ability to
think that can be lost.
> | You need to pay closer attention. The result I exhibited was
> | inconsistent with the underlying implementation being either an ALIST or
> | a PLIST.
>
> No. You did not exhibit that. You exhhibited "undefined behaviour" in a
> Lisp implementation where a LIST based representation was NOT requested.
Fairly obviously, if you change a structure definition, the results
this has IS undefined. In Ron's example the result is fairly
innocuous, as effectively all that happens is the labels of two
pointer offsets is changed. Of course, certain other structure
redefinitions could result in fixnums being interpreted as pointers,
or other spectacularly broken behaviour.
> | There is actually one valid criticism of my example, and that is that
> | I left out the :TYPE LIST option. So here's the correct example
>
> The valid criticism I made of your example was that it was irrelevant
> nonsense on multiple counts. Comparing your example with the following
> will only prove that.
Since the original point was the comparative speed of plists vs.
structures at sizes below n, the validity of your criticism seems the
only thing that's irrelevant here.
Madhu
* mdj <9264dedd-3728-4753...@m26g2000yqb.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 00:00:58 -0800 (PST):
|> | Happily, the person to whom the remark was addressed was able to see
|> | that it was.
|>
|> I hope he was able to see exactly how wrong an example your code was
|> in the context.
|
| No you don't. You're only interested in foolish bickering.
I sincerely hoped you were able to see how the example was wrong, but I
see not only have you missed how the example was wrong but you are
interested in bickering and making a demonstration o how your
intellectual honesty is only slightly lesser than Ron.
| The example (whilst ostensibly incorrect) at least prompted me to read
| the spec and confirm how list based structures are implemented.
And after reading the spec you still believe the wrong example relates
in any way to your misunderstanding or understanding of how defstruct
works?
|> |> To repeat what I said, the code you posted illustrates what one
|> |> your particular lisp implementation changes the layout of existing
|> |> instances after a structure definition has changed.
|> |
|> | Actually it shows exactly the opposite, that my Lisp does NOT
|> | change the layout of existing instances.
|>
|> No. It does not show that.
|
| Are you stupid? That's exactly what it shows.
No. You are stupid if you believe that it demonstrates that. Call this
point A. Again you draw a different conclusion below which contradicts
this.
|> | I am pleased to see that the First Law of Madhu (to wit: Madhu is
|> | always Wrong about Everything) will not have to be revised.
|>
|> The law you seem to prove is that you are clueless AND wrong
|>EVERYTIME you post anything related to DEFSTRUCT (as with other parts
|>of Common Lisp)
|
| Proof? The only thing I can see proof of is that you lose your ability
| to think rationally when someone challenges you.
Again you seem to have losty ability to think rationally here. Listen
Matt, Ron made a mistake by posting a misleading incorrect example in
order to clarify a dumb assumption on your part.
|> No. You did not exhibit that. You exhhibited "undefined behaviour" in a
|> Lisp implementation where a LIST based representation was NOT requested.
|
| Fairly obviously, if you change a structure definition, the results
| this has IS undefined.
The result is undefined according to the Spec. Ron changed the
definition of a defstruct and demonstrated the printed representation of
an existing instance in a particular implementation.
| In Ron's example the result is fairly innocuous, as effectively all
| that happens is the labels of two pointer offsets is changed.
This "probably means" means that the layout has changed of the original
instance after the structure got redefined. If the layout has not
changed why would the printed representation change? Compare Point A
above where Ron claimed (falsely) that I was wrong and his example
showed that his implementation did not in fact change the layout, and
you called me stupid for pointing this out?
| Of course, certain other structure redefinitions could result in
| fixnums being interpreted as pointers, or other spectacularly broken
| behaviour.
|
|> | There is actually one valid criticism of my example, and that is that
|> | I left out the :TYPE LIST option. So here's the correct example
|>
|> The valid criticism I made of your example was that it was irrelevant
|> nonsense on multiple counts. Comparing your example with the
|> following will only prove that.
Have you applied your rational logic skills AFTER reading of the spec to
compare the examples and see what they demonstrate?
| Since the original point was the comparative speed of plists vs.
| structures at sizes below n, the validity of your criticism seems the
| only thing that's irrelevant here.
My criticism is against Ron posting irrelevant minformation in response
to your dumb assumption. You follow that up by posting more
misinformation and exhibiting more dumbness. I have just pointed it out
Again discussion with either of you is pointless as both of you are
dishonest assholes who just use a semblance of logic and reasoning to
mislead for the purpose of senseless bickering and debate.
Since your intent seems to mislead people with your nonsense, it is not
irrelevant to point out your mistake
--
Madhu
mdj
> | In Ron's example the result is fairly innocuous, as effectively all
> | that happens is the labels of two pointer offsets is changed.
>
> This "probably means" means that the layout has changed of the original
> instance after the structure got redefined.
No. The values in the instance are in the same places (relative to
each other), so the instance hasn't changed.
> If the layout has not changed why would the printed representation change?
Only the "layout" of the TYPE has changed. This means that the
accessor functions have been redefined, as has it's constructor
function. The print function may or may not be generated at definition
time but in either case it is referring to the structures TYPE to
determine the layout of instances.
> Compare Point A above where Ron claimed (falsely) that I was wrong and his example
> showed that his implementation did not in fact change the layout,
Did change it, or didn't? Can't decide?
> and you called me stupid for pointing this out?
Yes
Madhu
* mdj <c2b32d97-a67b-4e76...@c34g2000yqn.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 01:26:53 -0800 (PST):
[misinformed nonsense snipped]
Take your lying dishonest bickering elsewhere.
--
Thanks
Madhu
mdj
> * mdj <c2b32d97-a67b-4e76-9224-f9400c84f...@c34g2000yqn.googlegroups.com> :
> Wrote on Wed, 6 Jan 2010 01:26:53 -0800 (PST):
>
> [misinformed nonsense snipped]
>
> Take your lying dishonest bickering elsewhere.
So whether or not my interpretation is correct, you can't fault it, so
you call me a liar.
How very enlightened of you.
Madhu
Matt, You are posting bullshit in a technical group. I assume most
members have some capacity for rational critical reasoning and
honesty, even if you lack it.
You have demonstrated here (and earlier) that you are not honest and
only interested in bickering so debate with you is a waste of time.. I
am not interested in answering every of your fallacious posts or playing
your "How many ways can I get this wrong so you can correct me" game.
The only item I have pending is Who is Hanne Gudiken and why did you use
her name when posting on Comp.lang.lisp in an earlier thread?
--
Madhu
* mdj <aa5cceab-a5ef-4a5f...@m26g2000yqb.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 01:49:30 -0800 (PST):
mdj
> Matt, You are posting bullshit in a technical group. I assume most
> members have some capacity for rational critical reasoning and
> honesty, even if you lack it.
Step 1: Appeal to everyone's ego by implying you think they're smart.
Predictable, and unfortunately for you gives away the fact that you
really don't respect other people's intellect. If you did, you'd
refrain from using a cheap salesman's trickery.
> You have demonstrated here (and earlier) that you are not honest and
> only interested in bickering so debate with you is a waste of time.. I
> am not interested in answering every of your fallacious posts or playing
> your "How many ways can I get this wrong so you can correct me" game.
There's a group of people in this world who insist that Darwin's
theory of evolution must be false due to "unexplained gaps in the
fossil record". They bring no new evidence or conjecture to the table
themselves; they just point to an area with little/no evidence and
conspiratorially call an entire field of scientific enquiry into
question.
Whatever colourful name you'd prefer to give these people, you can't
help but recognise that their argument pattern is in fact the same as
your own: insist other people are mistaken, but refuse to offer any
actual conjecture to the contrary. The fallback position is one of
pure Authoritarianism in both their case, and in yours.
Another example of how this form of thinking affects you is your
failure to recognise when Ron is employing the Socratic method when
discussing something. You completely miss the point, intent on
pointing out the 'misleading' when the intent is to be 'leading' and
encourage the other party to think.
> The only item I have pending is Who is Hanne Gudiken and why did you use
> her name when posting on Comp.lang.lisp in an earlier thread?
In the interest of diplomacy I'll assume you're intelligent enough to
figure that out for yourself.
Matt
Madhu
* mdj <65bc0c63-914c-4e3c...@u41g2000yqe.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 05:26:52 -0800 (PST):
| On Jan 6, 7:55 pm, Madhu <enom...@meer.net> wrote:
|> Matt, You are posting bullshit in a technical group. I assume most
|> members have some capacity for rational critical reasoning and
|> honesty, even if you lack it.
[bullshit, nonsense snipped]
| Another example of how this form of thinking affects you is your
| failure to recognise when Ron is employing the Socratic method when
| discussing something. You completely miss the point, intent on
| pointing out the 'misleading' when the intent is to be 'leading' and
| encourage the other party to think.
You have been misled. And you are now bent on misleading others,
Ron made a mistake again upthread that I pointed out. He was plainly
unambiguously wrong. He cannot admit it because of a pathological
condition, and instead to cover his own mistakes he starts accusing me
of being Wrong on Everything. This is a recurring behaviour pattern
which poisons the usenet newsgroup. This is a disease you have too.
You are doing the same thing --- you made a mistake you cannot admit it
and cover it up with verbiage non-sequitors and fallacious reasoning,
baseless false and irrelevant accusations baseless accusations.
You have been doing this since you started posting to CLL, and your
non-sequitors and fallacies are an insult to an intelligence and it is
an insult to the newsgroup to even start to respond to them ---
especially after you have admitted your intent to troll and bicker.
|> The only item I have pending is Who is Hanne Gudiken and why did you
|> use her name when posting on Comp.lang.lisp in an earlier thread?
|
| In the interest of diplomacy I'll assume you're intelligent enough to
| figure that out for yourself.
This isnt about diplomacy, its about your representing and implicating
others fraudlently, and about risks to that party in associating with
characters like you.
--
Madhu
mdj
> You have been misled. And you are now bent on misleading others,
I am the grand conspirator! Hell bent on spreading misinformation
about CL wherever the opportunity arises!
> Ron made a mistake again upthread that I pointed out. He was plainly
> unambiguously wrong. He cannot admit it because of a pathological
> condition, and instead to cover his own mistakes he starts accusing me
> of being Wrong on Everything.
You mean like here, where Ron clearly uses trickery to escape
responsibility for his gratuitous error?
| On Jan 6, 4:38 am, Ron Garret <rNOSPA...@flownet.com> wrote:
|
| > There is actually one valid criticism of my example, and that is
that I
| > left out the :TYPE LIST option. So here's the correct example:
That sneaky bugger :-)
> This is a recurring behaviour pattern which poisons the usenet newsgroup. This is a disease you have too.
> You are doing the same thing --- you made a mistake you cannot admit it and cover it up with verbiage non-sequitors and fallacious reasoning, baseless false and irrelevant accusations baseless accusations.
And yet you provide no examples or conjecture to the contrary.
What mistake did I make that I didn't admit to ?
> You have been doing this since you started posting to CLL, and your
> non-sequitors and fallacies are an insult to an intelligence and it is
> an insult to the newsgroup to even start to respond to them ---
> especially after you have admitted your intent to troll and bicker.
I only recall admitting to mockery, Madhu. Would you like some more ?
> |> The only item I have pending is Who is Hanne Gudiken and why did you
> |> use her name when posting on Comp.lang.lisp in an earlier thread?
> |
> | In the interest of diplomacy I'll assume you're intelligent enough to
> | figure that out for yourself.
>
> This isnt about diplomacy, its about your representing and implicating
> others fraudlently, and about risks to that party in associating with
> characters like you.
I'll be sure to warn her when I kiss her goodnight.
Matt
Madhu
Matt, stop pretending that you are in engaging in an honest exchange,
* mdj
<3696b9e8-49b6-4b20...@j24g2000yqa.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 06:07:38 -0800 (PST):
|> |> The only item I have pending is Who is Hanne Gudiken and why did
|> |> you use her name when posting on Comp.lang.lisp in an earlier
|> |> thread?
|> |
|> | In the interest of diplomacy I'll assume you're intelligent enough to
|> | figure that out for yourself.
|>
|> This isnt about diplomacy, its about your representing and implicating
|> others fraudlently, and about risks to that party in associating with
|> characters like you.
|
| I'll be sure to warn her when I kiss her goodnight.
You are a dishonest fraudulent bastard, with no scruples and just enough
skills to mislead, lie, cheat, and try to cover aup your lies.
Anything else?
--
Madhu
mdj
> You are a dishonest fraudulent bastard.
I think we can leave my mother out of this.
> with no scruples and just enough
> skills to mislead, lie, cheat, and try to cover aup your lies.
>
> Anything else?
Yes.
a) What Lies ?
b) What Cheats ?
c) What cover up ?
Madhu
* mdj <80d31090-cc7b-4bb4...@c3g2000yqd.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 06:29:45 -0800 (PST):
d) What Non sequitors ?
e) What False and baseless accusations ?
f) What irrelevant nonsense ?
g) What logical fallacies?
The statmenets you have made upthread that I have expressly avoided
responding to so as to not be sucked in to satisfy your pathological
bickering needs.
Quit pretending you are engaging in an honest exchange.
--
Madhu
If you cant make technically relevant ontopic posts in the future,
please refrain from polluting the newsgroup.
mdj
> * mdj <80d31090-cc7b-4bb4-8b8d-f40854313...@c3g2000yqd.googlegroups.com> :
> Wrote on Wed, 6 Jan 2010 06:29:45 -0800 (PST):
>
> | On Jan 7, 12:15 am, Madhu <enom...@meer.net> wrote:
> |
> |> You are a dishonest fraudulent bastard.
> |
> | I think we can leave my mother out of this.
> |
> |> with no scruples and just enough
> |> skills to mislead, lie, cheat, and try to cover aup your lies.
> |>
> |> Anything else?
> |
> | Yes.
> |
> | a) What Lies ?
> | b) What Cheats ?
> | c) What cover up ?
>
> d) What Non sequitors ?
> e) What False and baseless accusations ?
> f) What irrelevant nonsense ?
> g) What logical fallacies?
>
> The statmenets you have made upthread that I have expressly avoided
> responding to so as to not be sucked in to satisfy your pathological
> bickering needs.
So we have to take it "on faith" that you've spotted these heinous
infractions on my part, and be grateful of the community service
you're providing us by letting us know?
You're like the witch doctor in a medieval village pointing at a
stranger and yelling "It was HIM that poisoned the well!"
> If you cant make technically relevant ontopic posts in the future,
> please refrain from polluting the newsgroup.
Oh grow up. You made a mistake. Happens to all of us.
Madhu
You continue to pollute. Do you have a last name?
* mdj <9c06db50-a8d6-4213...@34g2000yqp.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 06:46:48 -0800 (PST):
| On Jan 7, 12:35 am, Madhu <enom...@meer.net> wrote:
|> * mdj <80d31090-cc7b-4bb4-8b8d-f40854313...@c3g2000yqd.googlegroups.com> :
|> Wrote on Wed, 6 Jan 2010 06:29:45 -0800 (PST):
|>
|> | On Jan 7, 12:15 am, Madhu <enom...@meer.net> wrote:
|> |
|> |> You are a dishonest fraudulent bastard.
|> |
|> | I think we can leave my mother out of this.
|> |
|> |> with no scruples and just enough
|> |> skills to mislead, lie, cheat, and try to cover aup your lies.
|> |>
|> |> Anything else?
|> |
|> | Yes.
|> |
|> | a) What Lies ?
|> | b) What Cheats ?
|> | c) What cover up ?
|>
|> d) What Non sequitors ?
|> e) What False and baseless accusations ?
|> f) What irrelevant nonsense ?
|> g) What logical fallacies?
|>
|> The statmenets you have made upthread that I have expressly avoided
|> responding to so as to not be sucked in to satisfy your pathological
|> bickering needs.
|
| So we have to take it "on faith" that you've spotted these heinous
| infractions on my part, and be grateful of the community service
| you're providing us by letting us know?
Stop pretending you are engaging in an honest exchange.
It is clear to those who have enough technical knowledge, capacity for
critical thinking and logical reasoning, the members of a technical
group.
| You're like the witch doctor in a medieval village pointing at a
| stranger and yelling "It was HIM that poisoned the well!"
There you start off again
|> If you cant make technically relevant ontopic posts in the future,
|> please refrain from polluting the newsgroup.
|
| Oh grow up. You made a mistake. Happens to all of us.
No. Ron made a mistake, I pointed it out. He responded refusing to
admit it and by instead accusing me of making a mistake in an attempt to
confuse and mislead. You are doing the same thing.
If you cant make focussed technically relevant ontopic posts in the
mdj
> You continue to pollute. Do you have a last name?
Yes but since you don't disclose yours it's rude of you to ask.
> | So we have to take it "on faith" that you've spotted these heinous
> | infractions on my part, and be grateful of the community service
> | you're providing us by letting us know?
>
> Stop pretending you are engaging in an honest exchange.
>
> It is clear to those who have enough technical knowledge, capacity for
> critical thinking and logical reasoning, the members of a technical
> group.
>
> | You're like the witch doctor in a medieval village pointing at a
> | stranger and yelling "It was HIM that poisoned the well!"
>
> There you start off again
It's an appropriate analogy for someone who rubbishes other people
without evidence. That's you.
> |> If you cant make technically relevant ontopic posts in the future,
> |> please refrain from polluting the newsgroup.
> |
> | Oh grow up. You made a mistake. Happens to all of us.
>
> No. Ron made a mistake, I pointed it out. He responded refusing to
> admit it and by instead accusing me of making a mistake in an attempt to
> confuse and mislead. You are doing the same thing.
I reposted Ron's admission a couple of posts ago. Why are you still
insisting he didn't admit it?
> If you cant make focussed technically relevant ontopic posts in the
> future, please refrain from polluting the newsgroup.
Your bluff is called sunshine. It's pretty obvious from your inability
to construct a retort any more sophisticated than "Hey everyone!
Matt's a Liar!" that you're holding a dud hand.
You contribute nothing, Madhu. You proclaim people are wrong at any
opportunity and if they disagree with you, you resort to name calling.
You don't back your statements up with reasoned arguments because when
you do your reason is usually found wanting.
I can only summise that you enjoy being the brunt of other peoples
jokes.
Madhu
* mdj <c1f926f0-e580-4c03...@s3g2000yqs.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 07:23:08 -0800 (PST):
| On Jan 7, 12:53 am, Madhu <enom...@meer.net> wrote:
|> You continue to pollute. Do you have a last name?
|
| Yes but since you don't disclose yours it's rude of you to ask.
You are using my last name.
|>
|> Stop pretending you are engaging in an honest exchange.
|
|> | Oh grow up. You made a mistake. Happens to all of us.
|>
|> No. Ron made a mistake, I pointed it out. He responded refusing to
|> admit it and by instead accusing me of making a mistake in an attempt
|> to confuse and mislead. You are doing the same thing.
|
| I reposted Ron's admission a couple of posts ago. Why are you still
| insisting he didn't admit it?
You did not post the parts where he refused to admit it. There are more
than a few posts filled with those. And even that post where he accuses
me of making a mistake is a mistake. You are too dumb/insane to see it.
|> If you cant make focussed technically relevant ontopic posts in the
|> future, please refrain from polluting the newsgroup.
|
| Your bluff is called sunshine. It's pretty obvious from your inability
| to construct a retort any more sophisticated than "Hey everyone!
| Matt's a Liar!" that you're holding a dud hand.
How do you engage in honest arguments with a liar?
| You contribute nothing, Madhu.
You contribute even less. Your contribution is specifically
trolling. You have trolled me before in an attempt to poison the group.
| You proclaim people are wrong at any opportunity and if they disagree
| with you,
Unsubstantiated Lie. I pointed out a mistake when there was a
mistake. Ron made a mistake which I pointed out.
|you resort to name calling.
No. I refused to call you any names in the last thread you wasted my
time. My intent was never to insult you gratutitiously. But there is
nothing else you offer by way of exchange when you engage me in
conversation other than those names and they are the only depiction of
you. There is nothing more to you than those names.
| You don't back your statements up with reasoned arguments because when
| you do your reason is usually found wanting.
Stop pretending that you are engaging in an honest exchange, asshole.
mdj
On Jan 7, 1:34 am, Madhu <enom...@meer.net> wrote:
> |> | Oh grow up. You made a mistake. Happens to all of us.
> |>
> |> No. Ron made a mistake, I pointed it out. He responded refusing to
> |> admit it and by instead accusing me of making a mistake in an attempt
> |> to confuse and mislead. You are doing the same thing.
> |
> | I reposted Ron's admission a couple of posts ago. Why are you still
> | insisting he didn't admit it?
>
> You did not post the parts where he refused to admit it. There are more
> than a few posts filled with those. And even that post where he accuses
> me of making a mistake is a mistake. You are too dumb/insane to see it.
Because he said no such thing. Repost it if I'm mistaken.
> |> If you cant make focussed technically relevant ontopic posts in the
> |> future, please refrain from polluting the newsgroup.
> |
> | Your bluff is called sunshine. It's pretty obvious from your inability
> | to construct a retort any more sophisticated than "Hey everyone!
> | Matt's a Liar!" that you're holding a dud hand.
>
> How do you engage in honest arguments with a liar?
The usual approach is to use reason to expose a contradiction in the
liars statements, then expose it. It's recommended to supply the
correct information for comparison, sans the inconsistency.
> | You contribute nothing, Madhu.
>
> You contribute even less. Your contribution is specifically
> trolling. You have trolled me before in an attempt to poison the group.
>
> | You proclaim people are wrong at any opportunity and if they disagree
> | with you,
>
> Unsubstantiated Lie.
Nonsense. You substantiate it yourself in your responses. Like the end
of this one.
> I pointed out a mistake when there was a mistake. Ron made a mistake which I pointed out.
There was no mistake. Ron was *intentionally* trying to get me to
think about the issue myself. It worked. Your lack of knowledge about
the dialectic process doesn't make someone elses use of it invalid. It
makes you look ignorant when you insist that persons usage of that
particular argument technique is being misleading.
> |you resort to name calling.
>
> No. I refused to call you any names in the last thread you wasted my
> time. My intent was never to insult you gratutitiously. But there is
> nothing else you offer by way of exchange when you engage me in
> conversation other than those names and they are the only depiction of
> you. There is nothing more to you than those names.
I offered a justification of my position and a contradiction of yours.
Your insistence that I did no such thing doesn't change the fact that
I did. Calling my responses bullshit doesn't make them bullshit. There
is no hierarchy of authority here.
> | You don't back your statements up with reasoned arguments because when
> | you do your reason is usually found wanting.
>
> Stop pretending that you are engaging in an honest exchange, asshole.
What pretense? You're just calling me a liar again without
justification. I made my position quite clear. If you don't understand
it, ask for clarification. If you disagree with it, state why. If you
don't understand why you disagree but feel the need to call people
liars, at least consider how ridiculous this makes you look before you
do it.
Why is it that you think the fact that someone maye have made a small
mistake is reason to carry on like a pork chop ?
Madhu
* mdj <8f17f368-d96c-42c1...@k17g2000yqh.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 17:17:57 -0800 (PST):
| On Jan 7, 1:34 am, Madhu <enom...@meer.net> wrote:
|
|> |> | Oh grow up. You made a mistake. Happens to all of us.
|> |>
|> |> No. Ron made a mistake, I pointed it out. He responded refusing to
|> |> admit it and by instead accusing me of making a mistake in an attempt
|> |> to confuse and mislead. You are doing the same thing.
|> |
|> | I reposted Ron's admission a couple of posts ago. Why are you still
|> | insisting he didn't admit it?
|>
|> You did not post the parts where he refused to admit it. There are more
|> than a few posts filled with those. And even that post where he accuses
|> me of making a mistake is a mistake. You are too dumb/insane to see it.
|
| Because he said no such thing. Repost it if I'm mistaken.
You can read the responses yourself.
|> |> If you cant make focussed technically relevant ontopic posts in the
|> |> future, please refrain from polluting the newsgroup.
|> |
|> | Your bluff is called sunshine. It's pretty obvious from your inability
|> | to construct a retort any more sophisticated than "Hey everyone!
|> | Matt's a Liar!" that you're holding a dud hand.
|>
|> How do you engage in honest arguments with a liar?
|
| The usual approach is to use reason to expose a contradiction in the
| liars statements, then expose it. It's recommended to supply the
| correct information for comparison, sans the inconsistency.
I have done this time and again, in this and earlier threads. Quit
pretending you are engaging in an honest exchange.
|> | You contribute nothing, Madhu.
|>
|> You contribute even less. Your contribution is specifically
|> trolling. You have trolled me before in an attempt to poison the group.
|>
|> | You proclaim people are wrong at any opportunity and if they disagree
|> | with you,
|>
|> Unsubstantiated Lie.
|
| Nonsense. You substantiate it yourself in your responses. Like the end
| of this one.
You just keep adding lies. Quit pretending you are engaging in an
honest exchange.
|
|> I pointed out a mistake when there was a mistake. Ron made a mistake
|> which I pointed out.
|
| There was no mistake.
Wrong. You are truely clueless.
| Ron was *intentionally* trying to get me to think about the issue
| myself. It worked. Your lack of knowledge about the dialectic process
| doesn't make someone elses use of it invalid. It makes you look
| ignorant when you insist that persons usage of that particular
| argument technique is being misleading.
Wrong. Ron was clueless too. You two are made for each other.
|> |you resort to name calling.
|>
|> No. I refused to call you any names in the last thread you wasted my
|> time. My intent was never to insult you gratutitiously. But there is
|> nothing else you offer by way of exchange when you engage me in
|> conversation other than those names and they are the only depiction
|> of you. There is nothing more to you than those names.
|
| I offered a justification of my position and a contradiction of yours.
| Your insistence that I did no such thing doesn't change the fact that
| I did. Calling my responses bullshit doesn't make them bullshit. There
| is no hierarchy of authority here.
Quit pretending to engage in an honest exchange.
|> | You don't back your statements up with reasoned arguments because when
|> | you do your reason is usually found wanting.
|>
|> Stop pretending that you are engaging in an honest exchange, asshole.
|
| What pretense? You're just calling me a liar again without
| justification. I made my position quite clear. If you don't understand
| it, ask for clarification. If you disagree with it, state why. If you
| don't understand why you disagree but feel the need to call people
| liars, at least consider how ridiculous this makes you look before you
| do it.
You have justified it in every response to any thread. If you don't
understand why I am calling you a dishonest bastard, and cant see how
your responses are incorrect maybe you should ask someone else for
clarification to explain it to you.
But you are not engaging in honest exchange.
Establishing you as a liar when you are indeed lying is the only useful
outcome of this exchange.
| Why is it that you think the fact that someone maye have made a small
| mistake is reason to carry on like a pork chop ?
I just pointed out a piece of irrelevant nonsense. End of story. Since
then I am only responding to your attempts to add more irrelevant
non-topic nonsense, and your pathological psychological defect to bicker
about it. Note I am NOT answering your non-sequiturs
You have nothing relevant to say ontopic. Quit pretending you are
engaging in honest debate.
mdj
> Establishing you as a liar when you are indeed lying is the only useful
> outcome of this exchange.
I have merely stated what I think. What I think may be wrong, but it
doesn't make me a liar to state it.
> | Why is it that you think the fact that someone maye have made a small
> | mistake is reason to carry on like a pork chop ?
>
> I just pointed out a piece of irrelevant nonsense. End of story. Since
> then I am only responding to your attempts to add more irrelevant
> non-topic nonsense, and your pathological psychological defect to bicker
> about it.
Irrelevant to you perhaps, but not directed at you. There's no basis
for you to claim that it's irrelevant to me.
> Note I am NOT answering your non-sequiturs
I note you have not responded to any argument I've made. Whether or
not they're non-sequiturs remains to be seen. I'll happily concede
that they are if you can demonstrate it, I have no problem being shown
incorrect. Why would I bother engaging in a discussion if I thought I
had nothing more to learn?
> You have nothing relevant to say ontopic. Quit pretending you are
> engaging in honest debate.
Quit calling me a liar without any justification.
Madhu
Matt, you dishonest asshole, quit pretending to engage in an honest
exchange. You have nothing useful to say --- we have nothing to
communicate. Everything I had to say, I have said in my initial post.
What is your purpose in engaging me in responding to every thread of
where you add more prepostorous nonsense to respond to?
Don't ask me to convince you, because that request isnt honest. You are
just trolling, and all you have done in CLL is troll me.
* mdj <9cb9e39d-fbfc-4a82...@j14g2000yqm.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 18:09:59 -0800 (PST):
| On Jan 7, 11:29 am, Madhu <enom...@meer.net> wrote:
|
|> Establishing you as a liar when you are indeed lying is the only
|> useful outcome of this exchange.
|
| I have merely stated what I think. What I think may be wrong, but it
| doesn't make me a liar to state it.
No. You have engaged in more dishonesty than that. It is self evident
to anyone with a faculty of critical reasoning, with any familiarity
with the issues.
If anyone else gives a flying fuck they would have pointed it out.
|> | Why is it that you think the fact that someone maye have made a small
|> | mistake is reason to carry on like a pork chop ?
|>
|> I just pointed out a piece of irrelevant nonsense. End of story. Since
|> then I am only responding to your attempts to add more irrelevant
|> non-topic nonsense, and your pathological psychological defect to bicker
|> about it.
|
| Irrelevant to you perhaps, but not directed at you. There's no basis
| for you to claim that it's irrelevant to me.
Matt, you dishonest bastard, you can claim anything you want. It has
nothing to do with anything which was being discussed.
|
|> Note I am NOT answering your non-sequiturs
|
| I note you have not responded to any argument I've made. Whether or
| not they're non-sequiturs remains to be seen.
Matt, you dishonest bastard, It has been seen, and it has been avoided.
| I'll happily concede that they are if you can demonstrate it,
You lie. Don't ask me to convince you, because that request isnt
honest. You are just trolling, and all you have done in CLL is troll me.
It has been done and you have demonstrated you are psychologically
defective and you will only make more irrelevant non-sequiturs to cover
up any demonstration of your bullshit.
Quit pretending you are engaging in honest conversation.
| I have no problem being shown incorrect. Why would I bother engaging
| in a discussion if I thought I had nothing more to learn?
You will learn nothing from me. You have already stated you can learn
nothing from me, yet you propose this? Another inconsistency that is
only pointed out in vain to a dishonest bastard.
If you ask my assesment, you are not competent and lack cognitive
abilities to learn CL. You are just wasting time and polluting the
newsgroup.
|> You have nothing relevant to say ontopic. Quit pretending you are
|> engaging in honest debate.
|
| Quit calling me a liar without any justification.
I am not calling you a liar without justification. I am calling you a
liar with justification. Justifying it to a liar is pointless. If you
want me to stop calling you a liar, quit trying to engage me here with
dishonest intent.
mdj
> You lie. Don't ask me to convince you, because that request isnt
> honest. You are just trolling, and all you have done in CLL is troll me.
> It has been done and you have demonstrated you are psychologically
> defective and you will only make more irrelevant non-sequiturs to cover
> up any demonstration of your bullshit.
My contributions to this thread are as follows:
1. To agree with Ken that Pascal's assertion that plists are faster
than structures for small values is false, and to state *why*
2. I incorrectly assumed that if a list based representation of a
structure was being used then it would be a plist or an alist. Ron
helped me see that, and I appreciate his effort.
Point 1, IMO, stands.
To be honest, I had no desire to 'engage' with you at all. I only did
so when you (IMO incorrectly) stated that a structure #S(:a a :b b)
which has it's definition altered to (b a) has *not* been re-organised
when it later displays as #S(:b a :a b). If it was re-organised it
would display as #S(:b b :a a), which it did not. There is, you'll
agree, only two possible organisations for that structure. I'm sorry
you seem to think this makes me a dishonest person, but it seems clear
to me that no reasonable implementation would attempt to reorganise
the (potentially terabytes) of existing instances when a defstruct is
redefined. One has to check what their own implementation does, but I
think you'll find that the one you're advocating is the *least*
likely, considering it's only even possible at all if the structures
remain the same size, and in that case it isn't even necessary to do
it at all. I would contend that the only reason implementations allow
redefinition at all is to facilitate prototyping and bottom-up design,
since the results of doing so will in practice be unpredictable at
best, contrived examples notwithstanding.
You're free of course to disagree with my interpretation, either by
correcting it, shutting up, or even calling me a liar. Doing the
latter however as you can see has no justification whatsoever.
The fact that I might be incorrect does not make me dishonest. Your
belief that I am dishonest probably stems from your insistence that I
take you at your word that I am. Your response to my above explanation
was to call it bullshit, and my refusal to accept that as a
contradictory statement does not make me dishonest. It is simply a way
of thinking. It's perfectly reasonable to hold a position until
contrary evidence is discovered Madhu, regardless of your particular
views on the matter.
Matt
Madhu
Matt you dishonest bastard, quit pretending to engage in honest debate.
* mdj <de9873df-ee37-464a...@35g2000yqa.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 19:14:48 -0800 (PST):
| On Jan 7, 12:26 pm, Madhu <enom...@meer.net> wrote:
|
|> You lie. Don't ask me to convince you, because that request isnt
|> honest. You are just trolling, and all you have done in CLL is troll me.
|> It has been done and you have demonstrated you are psychologically
|> defective and you will only make more irrelevant non-sequiturs to cover
|> up any demonstration of your bullshit.
|
| My contributions to this thread are as follows:
Your contributions to this thread also 10+ messages addressed to me.
| 1. To agree with Ken that Pascal's assertion that plists are faster
| than structures for small values is false, and to state *why*
|
| 2. I incorrectly assumed that if a list based representation of a
| structure was being used then it would be a plist or an alist. Ron
| helped me see that, and I appreciate his effort.
Ron said "here is a clue" and then posted an irrelevant and wrong
example that I pointed out was wrong and does not address anything being
discussed, but introduced non-relevant implementation defined behaviour
which will mislead. End of story.
The implementation dependant undefined behaviour has no relevance to the
LIST representation of Point 1.
You have picked that up, and focussed your interactions with me on that
non-sequitur.
| Point 1, IMO, stands.
|
| To be honest, I had no desire to 'engage' with you at all.
You would prove that by not engaging me, instead of exhibiting another
inconsistency.
Ron's mistake stands out regardless of WHATEVER implementation specific
behaviour he exhibited.
| I only did so when you (IMO incorrectly) stated that a structure
[clueless uninformed speculative bullshit about irrelevant
implementation-dependent undefined behaviour snipped]
| You're free of course to disagree with my interpretation, either by
| correcting it, shutting up, or even calling me a liar. Doing the
| latter however as you can see has no justification whatsoeve
I cannot disagree with nonsese. This shitshow about layout is undefined
behaviour and no relevant conclusion can be drawn from what is exhibited
from some definition of undefined consequnce.
This is a technical newsgroup. You are posting nonsense to satisfy your
pathological need to bicker, not to learn.
| The fact that I might be incorrect does not make me dishonest.
Quit pretending to engage in honest debate. The fact that you are
incorrect is unrelated to your dishonesty. Your in acknowledging
logical conclusions and twisting statements, I suspect from satisfying
your pathological need to bicker.
| Your belief that I am dishonest probably stems from your insistence
| that I take you at your word that I am. Your response to my above
| explanation was to call it bullshit, and my refusal to accept that as
| a contradictory statement does not make me dishonest.
No, your dishonesty comes from inconsistencies you have exhibited. This
is a technical newsgroup. The fact that you can make wrong assumptions
that I am not required to clear up does not make you "honest". Your
logic is apalling.
| It is simply a way of thinking. It's perfectly reasonable to hold a
| position until contrary evidence is discovered Madhu, regardless of
| your particular views on the matter.
No. Another logical fallacy I wont challenge. This is a technical
newsgroup this has nothing to do with my views on anything and
everything to do with your pathological need to bicker.
Quit trying to pretend you are engaging in honest interaction when you
try to troll yet another response from me on this NG
--
Madhu
mdj
> Matt you dishonest bastard, quit pretending to engage in honest debate.
Oh grow up.
> Your contributions to this thread also 10+ messages addressed to me.
>
> | 1. To agree with Ken that Pascal's assertion that plists are faster
> | than structures for small values is false, and to state *why*
> |
> | 2. I incorrectly assumed that if a list based representation of a
> | structure was being used then it would be a plist or an alist. Ron
> | helped me see that, and I appreciate his effort.
>
> Ron said "here is a clue" and then posted an irrelevant and wrong
> example that I pointed out was wrong and does not address anything being
> discussed, but introduced non-relevant implementation defined behaviour
> which will mislead. End of story.
Why is it misleading simply because it is implementation defined?
> The implementation dependant undefined behaviour has no relevance to the
> LIST representation of Point 1.
In case you hadn't noticed, implementation issues are what is being
discussed.
> You have picked that up, and focussed your interactions with me on that
> non-sequitur.
The only non-sequitur I can see here is your insistence that
implementation defined details about structure implementations are
irrelevent to a discussion about the implementation of structures.
> | Point 1, IMO, stands.
> |
> | To be honest, I had no desire to 'engage' with you at all.
>
> You would prove that by not engaging me, instead of exhibiting another
> inconsistency.
Nonsense. I can't prove what I desired two days ago by altering my
current behaviour.
> Ron's mistake stands out regardless of WHATEVER implementation specific
> behaviour he exhibited.
You're making a false assumption about his intent.
> | I only did so when you (IMO incorrectly) stated that a structure
>
> [clueless uninformed speculative bullshit about irrelevant
> implementation-dependent undefined behaviour snipped]
You made a statement about what you thought it was doing which was
incorrect. I corrected it. Blathering on about its irrelevancy now is
beside the point.
> | You're free of course to disagree with my interpretation, either by
> | correcting it, shutting up, or even calling me a liar. Doing the
> | latter however as you can see has no justification whatsoeve
>
> I cannot disagree with nonsese. This shitshow about layout is undefined
> behaviour and no relevant conclusion can be drawn from what is exhibited
> from some definition of undefined consequnce.
You claimed the layout changed. Now that you've been shown wrong you
cry about it's irrelevancy. And apparently I'm the dishonest one :-)
The fact that the spec declares the consequences of redefinition to be
undefined is inconsequential to the issue under discussion. If you had
any understanding of how machines actually work and how that affects
how structures are implemented you'd be able to see that.
> This is a technical newsgroup. You are posting nonsense to satisfy your
> pathological need to bicker, not to learn.
>
> | The fact that I might be incorrect does not make me dishonest.
>
> Quit pretending to engage in honest debate. The fact that you are
> incorrect is unrelated to your dishonesty. Your in acknowledging
> logical conclusions and twisting statements, I suspect from satisfying
> your pathological need to bicker.
I'm arguing. If you think it's bickering, stop.
> | Your belief that I am dishonest probably stems from your insistence
> | that I take you at your word that I am. Your response to my above
> | explanation was to call it bullshit, and my refusal to accept that as
> | a contradictory statement does not make me dishonest.
>
> No, your dishonesty comes from inconsistencies you have exhibited. This
> is a technical newsgroup. The fact that you can make wrong assumptions
> that I am not required to clear up does not make you "honest". Your
> logic is apalling.
I did not say that. I said it does not make me *dishonest*, which is a
correct statement.
This is hilarious. You accuse me of dishonesty, then you invert the
premise of something I said less than 20 lines after you quoted it
directly and use it as an example of my faulty logic?
You're a joke.
> | It is simply a way of thinking. It's perfectly reasonable to hold a
> | position until contrary evidence is discovered Madhu, regardless of
> | your particular views on the matter.
>
> No. Another logical fallacy I wont challenge. This is a technical
> newsgroup this has nothing to do with my views on anything and
> everything to do with your pathological need to bicker.
That fact that you think this is a clear indication that your own
faculty of reason is extremely limited.
Madhu
Matt you dishonest bastard, quit pretending to engage in honest debate.
inconsitencies you exhibit that exposes you as a pathological liar with
a serious psychiartic problem.
* mdj <16eb4def-5084-43b5...@d20g2000yqh.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 20:55:08 -0800 (PST):
| On Jan 7, 1:33 pm, Madhu <enom...@meer.net> wrote:
|> Matt you dishonest bastard, quit pretending to engage in honest debate.
|
| Oh grow up.
|
|> Your contributions to this thread also 10+ messages addressed to me.
|>
|> | 1. To agree with Ken that Pascal's assertion that plists are faster
|> | than structures for small values is false, and to state *why*
|> |
|> | 2. I incorrectly assumed that if a list based representation of a
|> | structure was being used then it would be a plist or an alist. Ron
|> | helped me see that, and I appreciate his effort.
|>
|> Ron said "here is a clue" and then posted an irrelevant and wrong
|> example that I pointed out was wrong and does not address anything being
|> discussed, but introduced non-relevant implementation defined behaviour
|> which will mislead. End of story.
|
| Why is it misleading simply because it is implementation defined?
|
|> The implementation dependant undefined behaviour has no relevance to the
|> LIST representation of Point 1.
|
| In case you hadn't noticed, implementation issues are what is being
| discussed.
You sneaky dishonest bastard why are you hiding the fact that Point 1
was being discussed. Point 1 does not involve undefined consequences.
It involves a list representation, and a dumb assumption on your part
that structs are represented as plists. The example posted has no
relevance to any list representation. It does not use LISTS to represent
the instance. The example posted showed how a particular implementation
behaved when invoking IRRELEVANT undefined behaviour, on an instance
that is NOT A LIST REPREESENTATION. It is bullshit in context of your
original bullshit.
|> You have picked that up, and focussed your interactions with me on
|> that non-sequitur.
|
| The only non-sequitur I can see here is your insistence that
| implementation defined details about structure implementations are
| irrelevent to a discussion about the implementation of structures.
No, You sneaky dishonest bastard. Dont try to change the facts. The
non-sequitur is a starting discussion of implementation specific
behaviour in response undefined consequences in the context of Point 1.
|
|> | Point 1, IMO, stands.
|> |
|> | To be honest, I had no desire to 'engage' with you at all.
|>
|> You would prove that by not engaging me, instead of exhibiting another
|> inconsistency.
|
| Nonsense. I can't prove what I desired two days ago by altering my
| current behaviour.
How conveniently indistinguishable from a lie. The fact that you are a
pathological liar would fit the facts.
|> Ron's mistake stands out regardless of WHATEVER implementation specific
|> behaviour he exhibited.
|
| You're making a false assumption about his intent.
No you dishonest bastard, I am not assuming anything about his intent.
He has stated his intent clearly and failed to meet up to it. You lack
comprehension abilities, it is a useless.
|> | I only did so when you (IMO incorrectly) stated that a structure
|>
|> [clueless uninformed speculative bullshit about irrelevant
|> implementation-dependent undefined behaviour snipped]
|
| You made a statement about what you thought it was doing which was
| incorrect. I corrected it. Blathering on about its irrelevancy now is
| beside the point.
No, you lying asshole. I made a statement that what was going on was
irrelevant to what was purportedly being exhibited. It did not matter
what was going on, as it is irrelevant. You cannot infer what is going
on from the printed representations that Gat exhibited.
|> | You're free of course to disagree with my interpretation, either by
|> | correcting it, shutting up, or even calling me a liar. Doing the
|> | latter however as you can see has no justification whatsoeve
|>
|> I cannot disagree with nonsese. This shitshow about layout is undefined
|> behaviour and no relevant conclusion can be drawn from what is exhibited
|> from some definition of undefined consequnce.
|
| You claimed the layout changed. Now that you've been shown wrong you
| cry about it's irrelevancy. And apparently I'm the dishonest one :-)
Yes you are. My point was only that the example was irrelevant
bullshit, and the fact that the layout changed or did not change is a
non-sequitur when you want to establish Point 1 from the example. The
fact that the layout changed or does not change has no impact on the
dumbness of your assumption or the inappropriateness of Ron's example.
Again you fell for the Ron's trick. Last time it was on the meaning of
"interesting". Now it is on the meaning of "Layout".
| The fact that the spec declares the consequences of redefinition to be
| undefined is inconsequential to the issue under discussion.
You dishonest asshole --- my objection to Ron's example was that the
undefined behaviour which was exhibited was inconsequential to the issue
under discussion which is Point 1.
This makes everything you say below irrelevant to Point 1.
| If you had any understanding of how machines actually work and how
| that affects how structures are implemented you'd be able to see that.
You dishonest asshole, It does not need an understanding of machines
etc. to see it is inconsequential. My point was that it is
inconsequential to Point 1. Introducing it here is misleading if your
goal was to clear up Point Besides I have an understanding of how
defstruct is implemented in CMUCL, and the design choices available and
the tradeoffs
|> This is a technical newsgroup. You are posting nonsense to satisfy your
|> pathological need to bicker, not to learn.
|>
|> | The fact that I might be incorrect does not make me dishonest.
|>
|> Quit pretending to engage in honest debate. The fact that you are
|> incorrect is unrelated to your dishonesty. Your dishonest is
part of your psychological make up. It is exhibited by inconsistencies
you display in your posts. You do NOT acknowledge
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|> logical conclusions . You twist statements, Your dishonesty is
|> related, I suspect to satisfying your pathological need to bicker.
|
| I'm arguing. If you think it's bickering, stop.
No, asshole, you are bickering and hiding your bickering by pretending
to engage in an honest argument. How can I stop you from bickering? By
not bickering. I am responding to your posts without bickering in the
hope you will stop your dishonest trolling.
|> | Your belief that I am dishonest probably stems from your insistence
|> | that I take you at your word that I am. Your response to my above
|> | explanation was to call it bullshit, and my refusal to accept that
|> | as a contradictory statement does not make me dishonest.
|>
|> No, your dishonesty comes from inconsistencies you have exhibited. This
|> is a technical newsgroup. The fact that you can make wrong assumptions
|> that I am not required to clear up does not make you "honest". Your
|> logic is apalling.
|
| I did not say that. I said it does not make me *dishonest*, which is a
| correct statement.
Again you dishonest asshole you made the implying the contrary.
| This is hilarious. You accuse me of dishonesty, then you invert the
| premise of something I said less than 20 lines after you quoted it
| directly and use it as an example of my faulty logic?
|
| You're a joke.
You are a pathological liar
|> | It is simply a way of thinking. It's perfectly reasonable to hold a
|> | position until contrary evidence is discovered Madhu, regardless of
|> | your particular views on the matter.
|>
|> No. Another logical fallacy I wont challenge. This is a technical
|> newsgroup this has nothing to do with my views on anything and
|> everything to do with your pathological need to bicker.
|
| That fact that you think this is a clear indication that your own
| faculty of reason is extremely limited.
Then why dont you just quit trying to pretend you are engaging in honest
mdj
> Matt you dishonest bastard, quit pretending to engage in honest debate.
> inconsitencies you exhibit that exposes you as a pathological liar with
> a serious psychiartic problem.
We often suspect in others our own undesirable behaviours. Psychology
101
> |
> | In case you hadn't noticed, implementation issues are what is being
> | discussed.
>
> You sneaky dishonest bastard why are you hiding the fact that Point 1
> was being discussed. Point 1 does not involve undefined consequences.
> It involves a list representation, and a dumb assumption on your part
> that structs are represented as plists. The example posted has no
> relevance to any list representation. It does not use LISTS to represent
> the instance. The example posted showed how a particular implementation
> behaved when invoking IRRELEVANT undefined behaviour, on an instance
> that is NOT A LIST REPREESENTATION. It is bullshit in context of your
> original bullshit.
No. Point 1 involves the speed comparison of plists to structs. Pascal
provided a comparison of CLISP's list based struct (which is NOT a
plist) to it's default struct. This is a false comparison.
The essence of Point 1, being whether plists are faster than structs
when they're small is still up for debate.
And I'm still waiting for Pascal to post numbers supporting his
assertion.
> |> You have picked that up, and focussed your interactions with me on
> |> that non-sequitur.
> |
> | The only non-sequitur I can see here is your insistence that
> | implementation defined details about structure implementations are
> | irrelevent to a discussion about the implementation of structures.
>
> No, You sneaky dishonest bastard. Dont try to change the facts. The
> non-sequitur is a starting discussion of implementation specific
> behaviour in response undefined consequences in the context of Point 1.
The redefinition of structs has nothing to do with Point 1. Ron only
showed that to 'prompt' me into rethinking my (admittedly silly)
assertion that only plists or alists would be used to implement
structures.
> |> | Point 1, IMO, stands.
> |> |
> |> | To be honest, I had no desire to 'engage' with you at all.
> |>
> |> You would prove that by not engaging me, instead of exhibiting another
> |> inconsistency.
> |
> | Nonsense. I can't prove what I desired two days ago by altering my
> | current behaviour.
>
> How conveniently indistinguishable from a lie. The fact that you are a
> pathological liar would fit the facts.
Fit what facts ?
> |> Ron's mistake stands out regardless of WHATEVER implementation specific
> |> behaviour he exhibited.
> |
> | You're making a false assumption about his intent.
>
> No you dishonest bastard, I am not assuming anything about his intent.
> He has stated his intent clearly and failed to meet up to it. You lack
> comprehension abilities, it is a useless.
Where did he do this ?
> |> | I only did so when you (IMO incorrectly) stated that a structure
> |>
> |> [clueless uninformed speculative bullshit about irrelevant
> |> implementation-dependent undefined behaviour snipped]
> |
> | You made a statement about what you thought it was doing which was
> | incorrect. I corrected it. Blathering on about its irrelevancy now is
> | beside the point.
>
> No, you lying asshole. I made a statement that what was going on was
> irrelevant to what was purportedly being exhibited. It did not matter
> what was going on, as it is irrelevant. You cannot infer what is going
> on from the printed representations that Gat exhibited.
How do you know that I did? How do you know I didn't try it out on 3
different implementations and infer from the disassembly of their
accessor functions what was going on?
You don't know that. You made a false assumption.
> |> | You're free of course to disagree with my interpretation, either by
> |> | correcting it, shutting up, or even calling me a liar. Doing the
> |> | latter however as you can see has no justification whatsoeve
> |>
> |> I cannot disagree with nonsese. This shitshow about layout is undefined
> |> behaviour and no relevant conclusion can be drawn from what is exhibited
> |> from some definition of undefined consequnce.
> |
> | You claimed the layout changed. Now that you've been shown wrong you
> | cry about it's irrelevancy. And apparently I'm the dishonest one :-)
>
> Yes you are. My point was only that the example was irrelevant
> bullshit, and the fact that the layout changed or did not change is a
> non-sequitur when you want to establish Point 1 from the example. The
> fact that the layout changed or does not change has no impact on the
> dumbness of your assumption or the inappropriateness of Ron's example.
Again, the example was not made with respect to Point 1, it was made
with respect to my false assumption.
> Again you fell for the Ron's trick. Last time it was on the meaning of
> "interesting". Now it is on the meaning of "Layout".
>
> | The fact that the spec declares the consequences of redefinition to be
> | undefined is inconsequential to the issue under discussion.
>
> You dishonest asshole --- my objection to Ron's example was that the
> undefined behaviour which was exhibited was inconsequential to the issue
> under discussion which is Point 1.
>
> This makes everything you say below irrelevant to Point 1.
> | If you had any understanding of how machines actually work and how
> | that affects how structures are implemented you'd be able to see that.
>
> You dishonest asshole, It does not need an understanding of machines
> etc. to see it is inconsequential. My point was that it is
> inconsequential to Point 1. Introducing it here is misleading if your
> goal was to clear up Point Besides I have an understanding of how
> defstruct is implemented in CMUCL, and the design choices available and
> the tradeoffs
It wasn't to clear up the point, Madhu, it was to clear up my false
assumption.
Point 1 has alas been lost in all this noise.
> |> This is a technical newsgroup. You are posting nonsense to satisfy your
> |> pathological need to bicker, not to learn.
> |>
> |> | The fact that I might be incorrect does not make me dishonest.
> |>
> |> Quit pretending to engage in honest debate. The fact that you are
> |> incorrect is unrelated to your dishonesty. Your dishonest is
> part of your psychological make up. It is exhibited by inconsistencies
> you display in your posts. You do NOT acknowledge
> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> |> logical conclusions . You twist statements, Your dishonesty is
> |> related, I suspect to satisfying your pathological need to bicker.
> |
> | I'm arguing. If you think it's bickering, stop.
>
> No, asshole, you are bickering and hiding your bickering by pretending
> to engage in an honest argument. How can I stop you from bickering? By
> not bickering. I am responding to your posts without bickering in the
> hope you will stop your dishonest trolling.
How many times can you call me a dishonest arsehole and claim you're
not bickering before you realise that you might've got that wrong ?
> |> | Your belief that I am dishonest probably stems from your insistence
> |> | that I take you at your word that I am. Your response to my above
> |> | explanation was to call it bullshit, and my refusal to accept that
> |> | as a contradictory statement does not make me dishonest.
> |>
> |> No, your dishonesty comes from inconsistencies you have exhibited. This
> |> is a technical newsgroup. The fact that you can make wrong assumptions
> |> that I am not required to clear up does not make you "honest". Your
> |> logic is apalling.
> |
> | I did not say that. I said it does not make me *dishonest*, which is a
> | correct statement.
>
> Again you dishonest asshole you made the implying the contrary.
Where ? (assuming I've interpreted this nonsensical statement
correctly)
Madhu
Matt, quit pretending you are engaging in an honest exchange.
* mdj <aea098d6-8484-4532...@d20g2000yqh.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 22:28:47 -0800 (PST):
| On Jan 7, 3:32 pm, Madhu <enom...@meer.net> wrote:
|> Matt you dishonest bastard, quit pretending to engage in honest debate.
|> I believe each of your response is just to cover up every exhibition of
|> inconsitencies you exhibit that exposes you as a pathological liar with
|> a serious psychiartic problem.
|
| We often suspect in others our own undesirable behaviours. Psychology
| 101
True. In the earlier thread you exhibited all the symptoms you accused
me of. This belief of your pathological mental condition however is
based on that experience and the current thread where you exhibit
continued behaviour you continue go out of your way to engage me in
pointless debate while you shift shape.
|> | In case you hadn't noticed, implementation issues are what is being
|> | discussed.
|>
|> You sneaky dishonest bastard why are you hiding the fact that Point 1
|> was being discussed. Point 1 does not involve undefined consequences.
|> It involves a list representation, and a dumb assumption on your part
|> that structs are represented as plists. The example posted has no
|> relevance to any list representation. It does not use LISTS to represent
|> the instance. The example posted showed how a particular implementation
|> behaved when invoking IRRELEVANT undefined behaviour, on an instance
|> that is NOT A LIST REPREESENTATION. It is bullshit in context of your
|> original bullshit.
|
Your original bullshit was Point 1 AND Point 2. The non-sequitur is a
non-sequitur to both points.
| No. Point 1 involves the speed comparison of plists to structs. [...]
Yes. You misleading bastard. Clarifying Point 1 does not change
anything. It is is irrelevant to Point 1 AND Point 2.
|> |> You have picked that up, and focussed your interactions with me on
|> |> that non-sequitur.
|> |
|> | The only non-sequitur I can see here is your insistence that
|> | implementation defined details about structure implementations are
|> | irrelevent to a discussion about the implementation of structures.
|>
|> No, You sneaky dishonest bastard. Dont try to change the facts. The
|> non-sequitur is a starting discussion of implementation specific
|> behaviour in response undefined consequences in the context of Point 1.
|
| The redefinition of structs has nothing to do with Point 1. Ron only
| showed that to 'prompt' me into rethinking my (admittedly silly)
| assertion that only plists or alists would be used to implement
| structures.
The redefinition of structs has nothing to do with Point 2 Either. In
fact It has nothing to do with ANYTHING under discussion. It does not
appear in Ron's CORRECTED version does not include a redefinition. It
is a non-sequitur in the context of points 1 and 2.
USING REDEFINITION OF A DEFSTRUCT TYPE TO SHOW HOW DUMB YOUR ASSUMPTION
THAT DEFSTRUCTS ARE IMPLEMENTED AS ALISTS OR PLISTS IS A NON-SEQUITUR.
YOU ARE BATSHIT CRAZY IF YOU ASSUME RON WAS TRYING TO ENLIGHTEN YOU WITH
THAT EXAMPLE. I'll be charitable and assume you are just a dishonest
bastard that is satisfying a pathological need to bicker anonymously on
the internet by quoting irrelevancy on irrelevancy.
|> |> | Point 1, IMO, stands.
|> |> |
|> |> | To be honest, I had no desire to 'engage' with you at all.
|> |>
|> |> You would prove that by not engaging me, instead of exhibiting another
|> |> inconsistency.
|> |
|> | Nonsense. I can't prove what I desired two days ago by altering my
|> | current behaviour.
|>
|> How conveniently indistinguishable from a lie. The fact that you are a
|> pathological liar would fit
your behaviour on this newsgroup.
|> |> Ron's mistake stands out regardless of WHATEVER implementation specific
|> |> behaviour he exhibited.
|> |
|> | You're making a false assumption about his intent.
|>
|> No you dishonest bastard, I am not assuming anything about his
|> intent. He has stated his intent clearly and failed to meet up to
|> it. You lack comprehension abilities, it is useless.
To argue with you as you will reply with more non-sequiturs
|
| Where did he do this ?
On Comp.lang.lisp, in this thread, before admitting he posted a wrong
example.
|> |> [clueless uninformed speculative bullshit about irrelevant
|> |> implementation-dependent undefined behaviour snipped]
|> |
|> | You made a statement about what you thought it was doing which was
|> | incorrect. I corrected it. Blathering on about its irrelevancy now is
|> | beside the point.
|>
|> No, you lying asshole. I made a statement that what was going on was
|> irrelevant to what was purportedly being exhibited. It did not matter
|> what was going on, as it is irrelevant. You cannot infer what is going
|> on from the printed representations that Gat exhibited.
|How do you know that I did?
Idiot. "You" refers to ANYONE.
|How do you know I didn't try it out on 3 different implementations and
|infer from the disassembly of their accessor functions what was going
|on?
You build up a nice Strawman. The fact is what you did is irrelevant to
addressing Either Point 1 or Point 2 --- the points yuo stated were
under discussion. It is a non-sequitur. Why are you hiding this fact
dishonestly and engaging in pathologically dishonest debate?
| You don't know that. You made a false assumption.
You lying asshole. I made no assumption. I made a statement about what
could and could not be inferred from an incorrect example which Ron
posted, and HOW inappropriate the example was and WHY it was irrelevant
to any issue which had been discussed. Undefined behaviour is a
non-sequitur.
|> |> | You're free of course to disagree with my interpretation, either by
|> |> | correcting it, shutting up, or even calling me a liar. Doing the
|> |> | latter however as you can see has no justification whatsoeve
|> |>
|> |> I cannot disagree with nonsese. This shitshow about layout is undefined
|> |> behaviour and no relevant conclusion can be drawn from what is exhibited
|> |> from some definition of undefined consequnce.
|> |
|> | You claimed the layout changed. Now that you've been shown wrong you
|> | cry about it's irrelevancy. And apparently I'm the dishonest one :-)
|>
|> Yes you are. My point was only that the example was irrelevant
|> bullshit, and the fact that the layout changed or did not change is a
|> non-sequitur when you want to establish Point 1 from the example. The
|> fact that the layout changed or does not change has no impact on the
|> dumbness of your assumption or the inappropriateness of Ron's example.
|
| Again, the example was not made with respect to Point 1, it was made
| with respect to my false assumption.
Yes. I did noted that the example is equally irrelevant bullshit with
respect to Point 2 which is your dumb assumption.
|> Again you fell for the Ron's trick. Last time it was on the meaning of
|> "interesting". Now it is on the meaning of "Layout".
|>
|> | The fact that the spec declares the consequences of redefinition to be
|> | undefined is inconsequential to the issue under discussion.
|>
|> You dishonest asshole --- my objection to Ron's example was that the
|> undefined behaviour which was exhibited was inconsequential to the
|> issue under discussion which is Point 1.
|>
|> This makes everything you say below irrelevant to Point 1.
|
|> | If you had any understanding of how machines actually work and how
|> | that affects how structures are implemented you'd be able to see that.
|>
|> You dishonest asshole, It does not need an understanding of machines
|> etc. to see it is inconsequential. My point was that it is
|> inconsequential to Point 1. Introducing it here is misleading if your
|> goal was to clear up Point Besides I have an understanding of how
|> defstruct is implemented in CMUCL, and the design choices available and
|> the tradeoffs
|
| It wasn't to clear up the point, Madhu, it was to clear up my false
| assumption.
It is equally inconsequential to Point 1 AND POINT 2. The fact that you
cannot see it either makes you a liar just trolling me and polluting the
group, or calls in question your cognitive abilities and grasp of basic
first order logic making you unfit to program. Both then beg the
question WTF are you posting in a technical newsgroup?
| Point 1 has alas been lost in all this noise.
|
|> |> This is a technical newsgroup. You are posting nonsense to satisfy your
|> |> pathological need to bicker, not to learn.
|> |>
|> |> | The fact that I might be incorrect does not make me dishonest.
|> |>
|> |> Quit pretending to engage in honest debate. The fact that you are
|> |> incorrect is unrelated to your dishonesty. Your dishonest is
|> part of your psychological make up. It is exhibited by inconsistencies
|> you display in your posts. You do NOT acknowledge
|> ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|> |> logical conclusions . You twist statements, Your dishonesty is
|> |> related, I suspect to satisfying your pathological need to bicker.
|> |
|> | I'm arguing. If you think it's bickering, stop.
|>
|> No, asshole, you are bickering and hiding your bickering by pretending
|> to engage in an honest argument. How can I stop you from bickering? By
|> not bickering. I am responding to your posts without bickering in the
|> hope you will stop your dishonest trolling.
|
| How many times can you call me a dishonest arsehole and claim you're
| not bickering before you realise that you might've got that wrong ?
Would I be trolled into answering a rhetorical question? There really
is no point in "arguing" with a dishonest stateless party with a strong
pathological lying tendency. You are not going to stop, I just request
you quit trying to pretend you are engaging in honest interaction when
mdj
On Jan 7, 5:01 pm, Madhu <enom...@meer.net> wrote:
> True. In the earlier thread you exhibited all the symptoms you accused
> me of. This belief of your pathological mental condition however is
> based on that experience and the current thread where you exhibit
> continued behaviour you continue go out of your way to engage me in
> pointless debate while you shift shape.
Sorry, I don't understand what this means.
> |> | In case you hadn't noticed, implementation issues are what is being
> |> | discussed.
> |>
> |> You sneaky dishonest bastard why are you hiding the fact that Point 1
> |> was being discussed. Point 1 does not involve undefined consequences.
> |> It involves a list representation, and a dumb assumption on your part
> |> that structs are represented as plists. The example posted has no
> |> relevance to any list representation. It does not use LISTS to represent
> |> the instance. The example posted showed how a particular implementation
> |> behaved when invoking IRRELEVANT undefined behaviour, on an instance
> |> that is NOT A LIST REPREESENTATION. It is bullshit in context of your
> |> original bullshit.
> |
>
> Your original bullshit was Point 1 AND Point 2. The non-sequitur is a
> non-sequitur to both points.
Actually the phenomena you're describing is ignoratio elenchi, and in
this particular case the specific type is known colloquially as a "red
herring"
I'd advise avoiding the use of terms you've only just recently
learned.
> | No. Point 1 involves the speed comparison of plists to structs. [...]
>
> Yes. You misleading bastard. Clarifying Point 1 does not change
> anything. It is is irrelevant to Point 1 AND Point 2.
entia non sunt multiplicanda praeter necessitatem
> |> |> You have picked that up, and focussed your interactions with me on
> |> |> that non-sequitur.
> |> |
> |> | The only non-sequitur I can see here is your insistence that
> |> | implementation defined details about structure implementations are
> |> | irrelevent to a discussion about the implementation of structures.
> |>
> |> No, You sneaky dishonest bastard. Dont try to change the facts. The
> |> non-sequitur is a starting discussion of implementation specific
> |> behaviour in response undefined consequences in the context of Point 1.
> |
> | The redefinition of structs has nothing to do with Point 1. Ron only
> | showed that to 'prompt' me into rethinking my (admittedly silly)
> | assertion that only plists or alists would be used to implement
> | structures.
>
> The redefinition of structs has nothing to do with Point 2 Either. In
> fact It has nothing to do with ANYTHING under discussion. It does not
> appear in Ron's CORRECTED version does not include a redefinition. It
> is a non-sequitur in the context of points 1 and 2.
Okay since your response to it included a mistake you're unprepared to
acknowledge we'll drop the matter.
> USING REDEFINITION OF A DEFSTRUCT TYPE TO SHOW HOW DUMB YOUR ASSUMPTION
> THAT DEFSTRUCTS ARE IMPLEMENTED AS ALISTS OR PLISTS IS A NON-SEQUITUR.
> YOU ARE BATSHIT CRAZY IF YOU ASSUME RON WAS TRYING TO ENLIGHTEN YOU WITH
> THAT EXAMPLE. I'll be charitable and assume you are just a dishonest
> bastard that is satisfying a pathological need to bicker anonymously on
> the internet by quoting irrelevancy on irrelevancy.
No, it's not a non-sequitur. It was not a conclusion, but a question.
I suggest you stop dabbling in the amateurish application of formal
logic until you've done some more research.
Ron likes to interact like a teacher. Teaching, and the socratic
method seems to be another knowledge domain that you're weak in.
Now THAT is a non-sequitur.
> |How do you know I didn't try it out on 3 different implementations and
> |infer from the disassembly of their accessor functions what was going
> |on?
>
> You build up a nice Strawman. The fact is what you did is irrelevant to
> addressing Either Point 1 or Point 2 --- the points yuo stated were
> under discussion. It is a non-sequitur. Why are you hiding this fact
> dishonestly and engaging in pathologically dishonest debate?
I'm hiding nothing. Why are you trying to make it look like I am ?
> | You don't know that. You made a false assumption.
>
> You lying asshole. I made no assumption. I made a statement about what
> could and could not be inferred from an incorrect example which Ron
> posted, and HOW inappropriate the example was and WHY it was irrelevant
> to any issue which had been discussed. Undefined behaviour is a
> non-sequitur.
See now you're just dropping that word wherever you think it's
appropriate and looking like an asshat.
You ASSUMED that I only looked at the textual output of the example.
That assumption was wrong. Get over it.
<Madhu repeating himself snipped>
Matt
Madhu
Matt, before I proceed further, you should disclose your last name and
any medical conditions you are being treated for, You seem to suffer
from a learning disability. Are you autistic?
* mdj <df6b9976-9854-446e...@j14g2000yqm.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 23:55:53 -0800 (PST):
| On Jan 7, 5:01 pm, Madhu <enom...@meer.net> wrote:
|
|> True. In the earlier thread you exhibited all the symptoms you accused
|> me of. This belief of your pathological mental condition however is
|> based on that experience and the current thread where you exhibit
|> continued behaviour you continue go out of your way to engage me in
|> pointless debate while you shift shape.
|
| Sorry, I don't understand what this means.
It means you are a pathological liar, and are substantiating it in every
post.
|> |> | In case you hadn't noticed, implementation issues are what is being
|> |> | discussed.
|> |>
|> |> You sneaky dishonest bastard why are you hiding the fact that Point 1
|> |> was being discussed. Point 1 does not involve undefined consequences.
|> |> It involves a list representation, and a dumb assumption on your part
|> |> that structs are represented as plists. The example posted has no
|> |> relevance to any list representation. It does not use LISTS to represent
|> |> the instance. The example posted showed how a particular implementation
|> |> behaved when invoking IRRELEVANT undefined behaviour, on an instance
|> |> that is NOT A LIST REPREESENTATION. It is bullshit in context of your
|> |> original bullshit.
|> |
|>
|> Your original bullshit was Point 1 AND Point 2. The non-sequitur is a
|> non-sequitur to both points.
|
| Actually the phenomena you're describing is ignoratio elenchi, and in
| this particular case the specific type is known colloquially as a "red
| herring"
|
| I'd advise avoiding the use of terms you've only just recently
| learned.
As I've noted in every post, arguing with dishonest bastards like you is
a waste of time because there is no end to your dishonesty. At this
point when logic fails I can only advice you to fuck off and die.
--
Madhu
Madhu
* Ron Garret <rNOSPAMon-D4C12...@news.albasani.net> :
Wrote on Tue, 05 Jan 2010 10:38:16 -0800:
|> Right, My point was that not only was the code you posted
|> non-conformant, but it is also not relevant to addressing the
|> assumption you wish to address.
|
| Happily, the person to whom the remark was addressed was able to see
| that it was.
The remarkable bonding between you (the master of the socratic method)
and MATT-THE-SURNAME-LESS (the pupil) is due to the fact that both of
you suffer from acute cases of Dunning–Kruger effect.
Heres a hot tip for your success: You need to find more victims of the
Dunning Kruger effect as students, to walk down every misleading path
you show, and thank you for it.
--
Madhu
Thomas F. Burdick
> you (IMO incorrectly) stated that a structure #S(:a a :b b)
> which has it's definition altered to (b a) has *not* been re-organised
> when it later displays as #S(:b a :a b). If it was re-organised it
> would display as #S(:b b :a a), which it did not. There is, you'll
> agree, only two possible organisations for that structure. I'm sorry
> you seem to think this makes me a dishonest person, but it seems clear
> to me that no reasonable implementation would attempt to reorganise
> the (potentially terabytes) of existing instances when a defstruct is
> redefined. One has to check what their own implementation does, but I
> think you'll find that the one you're advocating is the *least*
> likely, considering it's only even possible at all if the structures
> remain the same size, and in that case it isn't even necessary to do
> it at all. I would contend that the only reason implementations allow
> redefinition at all is to facilitate prototyping and bottom-up design,
> since the results of doing so will in practice be unpredictable at
> best, contrived examples notwithstanding.
There are other alternatives to either (1) blindly assuming the new
layout applies to the old instances, or (2) eagerly changing the
layout of existing instances. You could hypothetically update them
lazily using (something like) update-instance-for-redefined-class. I
don't know of any implementation that does that, however. SBCL/CMUCL
offer the option to mark the old instances as invalid, so, while you
won't get A when trying to access the A slot in the above example, at
least you'll get an error instead of B. I think it's too bad more
implementations don't do this, it's really useful behavior.
mdj
> Matt, before I proceed further, you should disclose your last name and
> any medical conditions you are being treated for, You seem to suffer
> from a learning disability. Are you autistic?
Why do you want my last name ?
> * mdj <df6b9976-9854-446e-820e-1041ac715...@j14g2000yqm.googlegroups.com> :
> Wrote on Wed, 6 Jan 2010 23:55:53 -0800 (PST):
>
> | On Jan 7, 5:01 pm, Madhu <enom...@meer.net> wrote:
> |
> |> True. In the earlier thread you exhibited all the symptoms you accused
> |> me of. This belief of your pathological mental condition however is
> |> based on that experience and the current thread where you exhibit
> |> continued behaviour you continue go out of your way to engage me in
> |> pointless debate while you shift shape.
> |
> | Sorry, I don't understand what this means.
>
> It means you are a pathological liar, and are substantiating it in every
> post.
Sorry, as far as I'm aware I've told no lies.
> |> Your original bullshit was Point 1 AND Point 2. The non-sequitur is a
> |> non-sequitur to both points.
> |
> | Actually the phenomena you're describing is ignoratio elenchi, and in
> | this particular case the specific type is known colloquially as a "red
> | herring"
> |
> | I'd advise avoiding the use of terms you've only just recently
> | learned.
>
> As I've noted in every post, arguing with dishonest bastards like you is
> a waste of time because there is no end to your dishonesty. At this
> point when logic fails I can only advice you to fuck off and die.
You can state it all you like that my argument is false because I'm a
liar, but the truth is that not only is such a statement argument ad
hominem it's also a non-sequitur, and frankly such pathetic attempts
at a retort are the last refuge of puerile minds.
I suggest you grow up.
Thomas F. Burdick
> Matt, quit pretending you are engaging in an honest exchange.
I hope you have something to help you automate this nonsense, a
keyboard macro at least.
> you exhibit
> continued behaviour you continue go out of your way to engage me in
> pointless debate while you shift shape.
OMG! Ron has enlisted sci-fi creatures in his nefarious lexiconical
consipiracy?!?! THAT must have been his motivation for sending MCL
into space! The plot thickens!!1!
Madhu
* "Thomas F. Burdick"
Wrote on Thu, 7 Jan 2010 01:02:57 -0800 (PST):
| On Jan 7, 8:01 am, Madhu <enom...@meer.net> wrote:
|> Matt, quit pretending you are engaging in an honest exchange.
|
| I hope you have something to help you automate this nonsense, a
| keyboard macro at least.
OK, burdick, quit pretending you are engaging in an honest exchange with
me.
|
|> you exhibit continued behaviour you continue go out of your way to
|> engage me in pointless debate while you shift shape.
|
| OMG! Ron has enlisted sci-fi creatures in his nefarious lexiconical
| consipiracy?!?! THAT must have been his motivation for sending MCL
| into space! The plot thickens!!1!
No, it just means that Ron has engaged more similar intellectually
dishonest types (as familiar to you as yourself), that change their
argument everytime it is shown that it is untenable
--
Madhu
mdj
I wasn't aware of that for SBCL (which I use primarily) but I've been
dabbling a bit with Clozure so I'll check out what it offers next time
I transfer some code to it (I was tempted by the MacOS X integration
possibilities)
I must admit though, other than during development, I can't come up
with a good use-case for the more elaborate functionality you elude
to ...
Matt
Madhu
* mdj <fb69aa53-178f-45cc...@34g2000yqp.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 01:02:12 -0800 (PST):
| On Jan 7, 5:42 pm, Madhu <enom...@meer.net> wrote:
|> Matt, before I proceed further, you should disclose your last name and
|> any medical conditions you are being treated for, You seem to suffer
|> from a learning disability. Are you autistic?
|
| Why do you want my last name ?
Note: I also want the answers to the other questions --- are you being
treated for any mental disorder. So far you are a dishonest
irresponsible anonymous internet troll who has been baiting me in
defence of another of Ron's mistake.
|> * mdj <df6b9976-9854-446e-820e-1041ac715...@j14g2000yqm.googlegroups.com> :
|> Wrote on Wed, 6 Jan 2010 23:55:53 -0800 (PST):
|>
|> | On Jan 7, 5:01 pm, Madhu <enom...@meer.net> wrote:
|> |
|> |> True. In the earlier thread you exhibited all the symptoms you accused
|> |> me of. This belief of your pathological mental condition however is
|> |> based on that experience and the current thread where you exhibit
|> |> continued behaviour you continue go out of your way to engage me in
|> |> pointless debate while you shift shape.
|> |
|> | Sorry, I don't understand what this means.
|>
|> It means you are a pathological liar, and are substantiating it in every
|> post.
|
| Sorry, as far as I'm aware I've told no lies.
Of course. Thats the expected response.
|> |> Your original bullshit was Point 1 AND Point 2. The non-sequitur is a
|> |> non-sequitur to both points.
|> |
|> | Actually the phenomena you're describing is ignoratio elenchi, and in
|> | this particular case the specific type is known colloquially as a "red
|> | herring"
|> |
|> | I'd advise avoiding the use of terms you've only just recently
|> | learned.
|>
|> As I've noted in every post, arguing with dishonest bastards like you is
|> a waste of time because there is no end to your dishonesty. At this
|> point when logic fails I can only advice you to fuck off and die.
|
| You can state it all you like that my argument is false because I'm a
| liar, but the truth is that not only is such a statement argument ad
| hominem it's also a non-sequitur, and frankly such pathetic attempts
| at a retort are the last refuge of puerile minds.
Not at all. It is the only reasonable retort to the pathetic retorts you
employed above (and below) in the parts of the post I snipped.
Responding to each preposterous inappropriate retort of yours serves no
purpose, being the dishonest asshole you are you will just continue to
make more preposterous retorts while ignoring all evidence, and logic.
As a pathological liar you just make stuff up or respond as a stateless
server.
Like the last time you engaged me, I have already made my points in my
first post in the thread. You have not benefitted from that, and you
just make me repeat those. You are not engaging in honest discussion.
| I suggest you grow up.
Again the only appropriate response to that is that I suggest you fuck
Ron Garret
<6d821556-254b-4df1...@a15g2000yqm.googlegroups.com>,
Marking all the old instances as invalid can still be expensive if there
are a lot of them. A better approach would be to have all the instances
have a back-pointer to a (shared) wrapper, and have the wrapper marked
as invalid when the struct is redefined.
Whether this is a good idea or not depends on whether you think that
DEFSTRUCT ought to be a high-level facility or a low-level one.
rg
Tamas K Papp
Good one, thanks for the laugh! Occasional gems like this make this
thread still worth reading.
Tamas
Ron Garret
<a0d04b66-b16e-4630...@q4g2000yqm.googlegroups.com>,
"Thomas F. Burdick" <tbur...@gmail.com> wrote:
Doh! Busted!
Damn you, Thomas, now I'll have to come up with a new nefarious plan.
There goes my weekend. :-(
rg
Madhu
* Tamas K Papp <7qlnhl...@mid.individual.net> :
Wrote on 7 Jan 2010 09:24:05 GMT:
|> OMG! Ron has enlisted sci-fi creatures in his nefarious lexiconical
|> consipiracy?!?! THAT must have been his motivation for sending MCL
|> into space! The plot thickens!!1!
|
| Good one, thanks for the laugh! Occasional gems like this make this
| thread still worth reading.
Easily amused aren't we? Still I thought it was better than the usual
flames we get from you ridiculing c.l.l posts from your point of view in
the blub.
--
Madhu
Ron Garret
Madhu <eno...@meer.net> wrote:
> The redefinition of structs has nothing to do with Point 2 Either.
I don't know what point 2 is, but the original example included a
redefinition because "real" structs are opaque. The redefinition was
needed to reveal a particular aspect of the behavior of the underlying
implementation.
> It does not
> appear in Ron's CORRECTED version does not include a redefinition.
That's right. Because list-based structs are not opaque. So the
redefinition turned out not to be necessary to make the point.
> YOU ARE BATSHIT CRAZY IF YOU ASSUME RON WAS TRYING TO ENLIGHTEN YOU WITH
> THAT EXAMPLE.
Whether or not I was *trying* to enlighten him (I was, but that is
neither here nor there) he was, in point of fact, enlightened. Matt
understood exactly the point I was trying to make. Whether that's
because I actually made the point well or because I just got lucky is
open to debate, but the fact that Matt got it (and you didn't and still
don't) is manifestly true.
rg
Madhu
* Ron Garret <rNOSPAMon-6777F...@news.albasani.net> :
Wrote on Thu, 07 Jan 2010 01:44:28 -0800:
| In article <m3pr5mb...@moon.robolove.meer.net>,
| Madhu <eno...@meer.net> wrote:
|
|> The redefinition of structs has nothing to do with Point 2 Either.
|
| I don't know what point 2 is, but the original example included a
| redefinition because "real" structs are opaque. The redefinition was
| needed to reveal a particular aspect of the behavior of the underlying
| implementation.
Let's look at this ex Post - facto justification from the master of
unchallenged master of dishonest debate of comp.lang.lisp. The
So now you are claiming that redefinition of defstruct (which has
undefined consequences) shows that a "real" structure instance is
opaque? And you can infer this from some speicific implementation's
behaviour? Sorry, you are talking through your ass again even though
your current misled audience can't see it. State explicitly how you
infer this.
But now you have introduced a "real" struct, while pretending you dont
know what `Point 2' which is what you were addressing was --- again a
deception you employ for the sake of debate. Point 2 is upthread and you
do know what it is: You addressed it: in your words
(<rNOSPAMon-79BB44.23220404012010 @ news.albasani.net>) ``whether the
assumption that "list based structs are plists and not alists" is
reasonable.''
Your redefinition example was a (defstruct) --- what you now call a
"Real struct". Had you intented to address list based structs, you
would have used (defstruct (:type :list)) --- which your corrected
example uses.
|> It does not appear in Ron's CORRECTED version does not include a
|> redefinition.
|
| That's right. Because list-based structs are not opaque. So the
| redefinition turned out not to be necessary to make the point.
Redefinition of defstruct has unspecified consequences. It is not
relevant to ANY point you are making except justifying your mistake in
an unreasonable way.
|> YOU ARE BATSHIT CRAZY IF YOU ASSUME RON WAS TRYING TO ENLIGHTEN YOU WITH
|> THAT EXAMPLE.
|
| Whether or not I was *trying* to enlighten him (I was, but that is
| neither here nor there) he was, in point of fact, enlightened. Matt
| understood exactly the point I was trying to make. Whether that's
| because I actually made the point well or because I just got lucky is
| open to debate, but the fact that Matt got it (and you didn't and
| still don't) is manifestly true.
Matt got "something". He probably understands defstruct more than you
now
--
Madhu
Ron Garret
Madhu <eno...@meer.net> wrote:
> * Ron Garret <rNOSPAMon-6777F...@news.albasani.net> :
> Wrote on Thu, 07 Jan 2010 01:44:28 -0800:
>
> | In article <m3pr5mb...@moon.robolove.meer.net>,
> | Madhu <eno...@meer.net> wrote:
> |
> |> The redefinition of structs has nothing to do with Point 2 Either.
> |
> | I don't know what point 2 is, but the original example included a
> | redefinition because "real" structs are opaque. The redefinition was
> | needed to reveal a particular aspect of the behavior of the underlying
> | implementation.
>
> Let's look at this ex Post - facto justification from the master of
> unchallenged master of dishonest debate of comp.lang.lisp. The
>
> So now you are claiming that redefinition of defstruct (which has
> undefined consequences) shows that a "real" structure instance is
> opaque?
No.
> Matt got "something". He probably understands defstruct more than you
> now
Could well be.
rg
Madhu
* mdj <df6b9976-9854-446e...@j14g2000yqm.googlegroups.com> :
Wrote on Wed, 6 Jan 2010 23:55:53 -0800 (PST):
| Ron likes to interact like a teacher. Teaching, and the socratic
| method seems to be another knowledge domain that you're weak in.
Ron likes to interact like Gavino --- posting random CL code (random
because it is unrelated to the issues being discussed) with
undefined/implementation specific consequences which he barely
understands after testing it on his one implementation of openmcl ---
and waiting for someone like kaz or pjb to correct him and give the
explanations he can learn from. By the time the "students" are
grappling with the concepts of undefined consequences --- completely
forgetting the original issues they were discussing, Ron has now learnt
enough to "instruct them" in simpler words.
This pattern has been going on for a while
--
Madhu
Madhu
* Ron Garret <rNOSPAMon-80EA8...@news.albasani.net> :
Wrote on Thu, 07 Jan 2010 02:11:20 -0800:
| No.
OK. I thought not. Your "real structs" would probably be opaque even
sans redefining the defstruct definition.
So the "particular aspect of behaviour of the underlying implementation"
that you wanted to reveal is implementation specific and comes under
"Undefined consequences" AND it acts on a "real struct".
How does this relate with your stated stated goal upthread, which was to
address, in your words, (<rNOSPAMon-79BB44.23220404012010 @
news.albasani.net>):
``whether the assumption that "list based structs are plists and not
alists" is reasonable.''.
(Hint: There is no relation.)
So what purpose did introducing defstruct redefintion (with undefined
consequences) serve? effectively all you now saying is ``I introduced
redefinition" to show "aspects of how a particular common lisp
implementation interprets "undefined consequences''.
So what general conclusion have you drawn on the ordinary list
representation of "list based structs" or the "opaque" representation of
your "real" structs, from observing the behaviour of redefintion
(invoking undefined consequences) in a particular common lisp
implementation?
--
Madhu
Ron Garret
Madhu <eno...@meer.net> wrote:
> * Ron Garret <rNOSPAMon-80EA8...@news.albasani.net> :
> Wrote on Thu, 07 Jan 2010 02:11:20 -0800:
>
> | In article <m3skai9...@moon.robolove.meer.net>,
> | Madhu <eno...@meer.net> wrote:
> |
> |> * Ron Garret <rNOSPAMon-6777F...@news.albasani.net> :
> |> Wrote on Thu, 07 Jan 2010 01:44:28 -0800:
> |>
> |> | In article <m3pr5mb...@moon.robolove.meer.net>,
> |> | Madhu <eno...@meer.net> wrote:
> |> |
> |> |> The redefinition of structs has nothing to do with Point 2 Either.
> |> |
> |> | I don't know what point 2 is, but the original example included a
> |> | redefinition because "real" structs are opaque. The redefinition
> |> | was needed to reveal a particular aspect of the behavior of the
> |> | underlying implementation.
> |>
> |> Let's look at this ex Post - facto justification from the master of
> |> unchallenged master of dishonest debate of comp.lang.lisp. The
> |>
> |> So now you are claiming that redefinition of defstruct (which has
> |> undefined consequences) shows that a "real" structure instance is
> |> opaque?
>
> | No.
>
> OK. I thought not. Your "real structs" would probably be opaque even
> sans redefining the defstruct definition.
There is no "probably." DEFSTRUCT can be used to define three different
kinds of things. Two of those things are transparent with respect to
their underlying implementations (lists and vectors), and one (what I'm
calling "real" structs) is opaque.
> So the "particular aspect of behaviour of the underlying implementation"
> that you wanted to reveal is implementation specific and comes under
> "Undefined consequences" AND it acts on a "real struct".
>
> How does this relate with your stated stated goal upthread, which was to
> address, in your words, (<rNOSPAMon-79BB44.23220404012010 @
> news.albasani.net>):
> ``whether the assumption that "list based structs are plists and not
> alists" is reasonable.''.
>
> (Hint: There is no relation.)
Of course there is. The fact that redefining the struct in the way that
I did causes existing instances to behave in the way that they do is
strongly indicative that the underlying implementation is neither a
PList nor an AList (nor any other kind of self-contained associative
map).
BTW, the example works (insofar as the results indicate what I intended
for them indicate) in CLisp and SBCL as well. So while the behavior may
be "undefined" in terms of the standard, my example turns out to be
quite robust with respect to existing practice.
rg
mdj
> * mdj <fb69aa53-178f-45cc-a2e7-fdf9d4748...@34g2000yqp.googlegroups.com> :
> Wrote on Thu, 7 Jan 2010 01:02:12 -0800 (PST):
>
> | On Jan 7, 5:42 pm, Madhu <enom...@meer.net> wrote:
> |> Matt, before I proceed further, you should disclose your last name and
> |> any medical conditions you are being treated for, You seem to suffer
> |> from a learning disability. Are you autistic?
> |
> | Why do you want my last name ?
>
> Note: I also want the answers to the other questions --- are you being
> treated for any mental disorder. So far you are a dishonest
> irresponsible anonymous internet troll who has been baiting me in
> defence of another of Ron's mistake.
Since honest debate is what you value, would you care to enlighten us
as to how my last name, mental state, and that I accidentally posted a
couple of times when my partner was logged into google on my computer
are relevant to the discussion ?
> | You can state it all you like that my argument is false because I'm a
> | liar, but the truth is that not only is such a statement argument ad
> | hominem it's also a non-sequitur, and frankly such pathetic attempts
> | at a retort are the last refuge of puerile minds.
>
> Not at all. It is the only reasonable retort to the pathetic retorts you
> employed above (and below) in the parts of the post I snipped.
No. A reasonable retort would be to point out my mistakes or to
concede that I'm correct.
Calling me a liar (or whatever other character assassination strategy
suits you) only demonstrates that you lack the ability to do either of
the above.
> Responding to each preposterous inappropriate retort of yours serves no
> purpose, being the dishonest asshole you are you will just continue to
> make more preposterous retorts while ignoring all evidence, and logic.
> As a pathological liar you just make stuff up or respond as a stateless
> server.
But you *are* responding, you're just not addressing the point. You're
just repeatedly calling me a dishonest person.
> Like the last time you engaged me, I have already made my points in my
> first post in the thread. You have not benefitted from that, and you
> just make me repeat those. You are not engaging in honest discussion.
Your post contained a falsehood, that you now wish to ignore by
proclaiming it irrelevant.
> | I suggest you grow up.
>
> Again the only appropriate response to that is that I suggest you fuck
> off and die.
Got it the first time
Madhu
* mdj <29feeb0b-5834-410f...@m25g2000yqc.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 03:04:04 -0800 (PST):
| On Jan 7, 7:17 pm, Madhu <enom...@meer.net> wrote:
|> * mdj <fb69aa53-178f-45cc-a2e7-fdf9d4748...@34g2000yqp.googlegroups.com> :
|> Wrote on Thu, 7 Jan 2010 01:02:12 -0800 (PST):
|>
|> | On Jan 7, 5:42 pm, Madhu <enom...@meer.net> wrote:
|> |> Matt, before I proceed further, you should disclose your last name and
|> |> any medical conditions you are being treated for, You seem to suffer
|> |> from a learning disability. Are you autistic?
|> |
|> | Why do you want my last name ?
|>
|> Note: I also want the answers to the other questions --- are you being
|> treated for any mental disorder. So far you are a dishonest
|> irresponsible anonymous internet troll who has been baiting me in
|> defence of another of Ron's mistake.
|
| Since honest debate is what you value, would you care to enlighten us
| as to how my last name, mental state, and that I accidentally posted a
| couple of times when my partner was logged into google on my computer
| are relevant to the discussion ?
If you have demonstrated anything in your exchanges on CLL, it is that
there can be no honest debate with a dishonest bastard with a
potentially psychiatric mental condition.
|> | You can state it all you like that my argument is false because I'm a
|> | liar, but the truth is that not only is such a statement argument ad
|> | hominem it's also a non-sequitur, and frankly such pathetic attempts
|> | at a retort are the last refuge of puerile minds.
|>
|> Not at all. It is the only reasonable retort to the pathetic retorts you
|> employed above (and below) in the parts of the post I snipped.
|
| No. A reasonable retort would be to point out my mistakes or to
| concede that I'm correct.
Yes. This has been tried. And it has been met with irrelevant puerile
pathetic retorts as I indicated. The only reasonable retort to your
style of argument is to kill file you, IOW: Fuck off and die.
| Calling me a liar (or whatever other character assassination strategy
| suits you) only demonstrates that you lack the ability to do either of
| the above.
No, it is a result of having done the above, and seeing the response.
|> Responding to each preposterous inappropriate retort of yours serves no
|> purpose, being the dishonest asshole you are you will just continue to
|> make more preposterous retorts while ignoring all evidence, and logic.
|> As a pathological liar you just make stuff up or respond as a stateless
|> server.
|
| But you *are* responding, you're just not addressing the point. You're
| just repeatedly calling me a dishonest person.
Indeed, at every instance where there is evidence of dishonesty
|> Like the last time you engaged me, I have already made my points in
|> my first post in the thread. You have not benefitted from that, and
|> you just make me repeat those. You are not engaging in honest
|> discussion.
|
| Your post contained a falsehood, that you now wish to ignore by
| proclaiming it irrelevant.
You are uttering 2 falsehoods in one sentence here ^^.
|
|> | I suggest you grow up.
|>
|> Again the only appropriate response to that is that I suggest you fuck
|> off and die.
|
| Got it the first time
Just do it.
--
Madhu
Madhu
* Ron Garret <rNOSPAMon-562C8...@news.albasani.net> :
Wrote on Thu, 07 Jan 2010 02:57:42 -0800:
| In article <m3k4vu9...@moon.robolove.meer.net>,
| Madhu <eno...@meer.net> wrote:
|
|> * Ron Garret <rNOSPAMon-80EA8...@news.albasani.net> :
|> Wrote on Thu, 07 Jan 2010 02:11:20 -0800:
|>
|> | In article <m3skai9...@moon.robolove.meer.net>,
|> | Madhu <eno...@meer.net> wrote:
|> |
|> |> * Ron Garret <rNOSPAMon-6777F...@news.albasani.net> :
|> |> Wrote on Thu, 07 Jan 2010 01:44:28 -0800:
|> |>
|> |> | In article <m3pr5mb...@moon.robolove.meer.net>,
|> |> | Madhu <eno...@meer.net> wrote:
|> |> |
|> |> |> The redefinition of structs has nothing to do with Point 2 Either.
|> |> |
|> |> | I don't know what point 2 is, but the original example included a
|> |> | redefinition because "real" structs are opaque. The redefinition
|> |> | was needed to reveal a particular aspect of the behavior of the
|> |> | underlying implementation.
|> |>
|> |> Let's look at this ex Post - facto justification from the master of
|> |> unchallenged master of dishonest debate of comp.lang.lisp. The
|> |>
|> |> So now you are claiming that redefinition of defstruct (which has
|> |> undefined consequences) shows that a "real" structure instance is
|> |> opaque?
|>
|> | No.
[*] <-------------- LOOK HERE. [POINT-FOO]
|>
|> OK. I thought not. Your "real structs" would probably be opaque even
|> sans redefining the defstruct definition.
|
| There is no "probably." DEFSTRUCT can be used to define three different
| kinds of things. Two of those things are transparent with respect to
| their underlying implementations (lists and vectors), and one (what I'm
| calling "real" structs) is opaque.
[*] <------------------- LOOK-HERE [POINTBAR]
OK you have claimed that "opaque representations" are not LIST based
representations (alist or plist or something else).
|
|> So the "particular aspect of behaviour of the underlying implementation"
|> that you wanted to reveal is implementation specific and comes under
|> "Undefined consequences" AND it acts on a "real struct".
|>
|> How does this relate with your stated stated goal upthread, which was to
|> address, in your words, (<rNOSPAMon-79BB44.23220404012010 @
|> news.albasani.net>):
|> ``whether the assumption that "list based structs are plists and not
|> alists" is reasonable.''.
|>
|> (Hint: There is no relation.)
|
| Of course there is.
No there isn't. You are now addressing the representation of opaque
defstructs your "real structs", while your earlier intent was to have
addressed List based defstructs (whether they were alists or plists).
"list based".
Sleight of hand.
| The fact that redefining the struct in the way that I did causes
| existing instances to behave in the way that they do is strongly
| indicative that the underlying implementation is neither a PList nor
| an AList (nor any other kind of self-contained associative map).
So now your claim is that a `particular aspect of behaviour of the
underlying implementation' on changing a defstruct definition (which has
undefined consequences) in specific implementations is strongly
indicative that the underlying representation of "real defstructs" is
neither an alist or a plist. But does it not do this by indicating they
are opaque?
To wit there are three problems with this claim which make it entirely
superflous.
1. It is trivially determined that OPAQUE "real defstructs" are NOT
LIST-BASED. See [POINT-BAR] above where you DEFINED that they cannot
have LIST-BASED representations because they are OPAQUE.
2. Your `particular aspect of behaviour of the underlying
implementation' is as good as any other aspect of behaviour that ANY
implementation may choose --- in implementing defstruct redefinition,
which is defined to have undefined consequences. This means that
ANY[1a] INTERPRETATION of UNDEFINED consequences is JUST AS STRONGLY
indicative that "real defstruct instances" with OPAQUE representation
is NOT list-based.
[1a] with the exceptions where an implementation specifically changes the
representation from of a "real defstruct" from a opaque represenatation
to a list, just to spite you, but these do not exist]
IOW Your `strong indication' does not follow from the specific behaviour
of "undefined consequences" but from definitions.
3.Your last claim that ``The fact that redefining the struct in the way
that I did causes existing instances to behave in the that they do is
strongly indicative that the underlying implementation is neither a
PList nor Alists'', works because the specific behaviour Only
indicates a representation of real defstructs that suggests it is
Opaque (and therefore not plists or alists).
But when I asked this question earlier you dismissed this with a "No."
See [POINT-FOO] above.
| BTW, the example works (insofar as the results indicate what I
| intended for them indicate) in CLisp and SBCL as well. So while the
| behavior may be "undefined" in terms of the standard, my example turns
| out to be quite robust with respect to existing practice.
But still irrelevant to the `clue' you were going to give to
Matt-with-no-surname.
--
Madhu
mdj
> | Since honest debate is what you value, would you care to enlighten us
> | as to how my last name, mental state, and that I accidentally posted a
> | couple of times when my partner was logged into google on my computer
> | are relevant to the discussion ?
>
> If you have demonstrated anything in your exchanges on CLL, it is that
> there can be no honest debate with a dishonest bastard with a
> potentially psychiatric mental condition.
Since you refuse to answer the question, it seems your only reason for
asking such questions for dishonest reasons.
> |> | You can state it all you like that my argument is false because I'm a
> |> | liar, but the truth is that not only is such a statement argument ad
> |> | hominem it's also a non-sequitur, and frankly such pathetic attempts
> |> | at a retort are the last refuge of puerile minds.
> |>
> |> Not at all. It is the only reasonable retort to the pathetic retorts you
> |> employed above (and below) in the parts of the post I snipped.
> |
> | No. A reasonable retort would be to point out my mistakes or to
> | concede that I'm correct.
>
> Yes. This has been tried. And it has been met with irrelevant puerile
> pathetic retorts as I indicated. The only reasonable retort to your
> style of argument is to kill file you, IOW: Fuck off and die.
LOL. You're far to narcissistic to killfile me. You're paranoid of
what I might say.
mdj
[snip]
> But still irrelevant to the `clue' you were going to give to
> Matt-with-no-surname.
I wonder... Why are you prepared to debate with Ron (who you claim is
as dishonest as I am) but not with me?
Matt-with-a-surname
mdj
> * Ron Garret <rNOSPAMon-D4C120.10381605012...@news.albasani.net> :
> Wrote on Tue, 05 Jan 2010 10:38:16 -0800:
>
> |> Right, My point was that not only was the code you posted
> |> non-conformant, but it is also not relevant to addressing the
> |> assumption you wish to address.
> |
> | Happily, the person to whom the remark was addressed was able to see
> | that it was.
>
> The remarkable bonding between you (the master of the socratic method)
> and MATT-THE-SURNAME-LESS (the pupil) is due to the fact that both of
> you suffer from acute cases of Dunning–Kruger effect.
Just when I thought you couldn't get anything else bassackwards
today....
mdj
> 1. It is trivially determined that OPAQUE "real defstructs" are NOT
> LIST-BASED. See [POINT-BAR] above where you DEFINED that they cannot
> have LIST-BASED representations because they are OPAQUE.
Don't be ridiculous. Implementors can choose whatever representation
they see fit, as long as the opaque interface defined by the standard
is adhered to. One would hope that they chose a faster one, however.
Matt
Madhu
* mdj <45728ba9-b44f-438d...@a15g2000yqm.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 04:21:10 -0800 (PST):
Except There is no "opaque interface defined by the standard." Provide
the citation if youre talking of the specification, or if you just want
to indulge in your clueless pathological bickering, FOAD,
Matt-with-No-surname.
Madhu
* mdj <05164fb3-ec1c-4094...@21g2000yqj.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 04:07:26 -0800 (PST):
False. I claimed Ron is MORE dishonest than you are. You are but a pupil
and he is the master, though you both suffer from he Dunning-Kruger
effect.
* mdj <05164fb3-ec1c-4094...@21g2000yqj.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 04:07:26 -0800 (PST):
| Matt-with-a-surname
Identify yourself or fuck off and die.
Madhu
* mdj <8896c874-2713-4eff...@j4g2000yqe.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 04:10:52 -0800 (PST):
Are you implying I have said anything incorrect?
--
Madhu
Madhu
* mdj <87788d14-8b7a-482e...@p8g2000yqb.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 03:58:29 -0800 (PST):
| On Jan 7, 9:33 pm, Madhu <enom...@meer.net> wrote:
|
|> | Since honest debate is what you value, would you care to enlighten us
|> | as to how my last name, mental state, and that I accidentally posted a
|> | couple of times when my partner was logged into google on my computer
|> | are relevant to the discussion ?
|>
|> If you have demonstrated anything in your exchanges on CLL, it is that
|> there can be no honest debate with a dishonest bastard with a
|> potentially psychiatric mental condition.
|
| Since you refuse to answer the question, it seems your only reason for
| asking such questions for dishonest reasons.
You have specifically targetted me with your bullshit in engaging me
with dishonest intent since your debut in CLL, and are repeating the
pattern here. I just want to know to whom I'm indebted the time that
has been spent in responding to your bullshit.
Anyway it does not matter what reply I give, your response will be on
the same lines, as dictated by your mental condition.
It would only be fair to disclose to the newsgroup you are posting on
what your mental problems are.
|> |> | You can state it all you like that my argument is false because I'm a
|> |> | liar, but the truth is that not only is such a statement argument ad
|> |> | hominem it's also a non-sequitur, and frankly such pathetic attempts
|> |> | at a retort are the last refuge of puerile minds.
|> |>
|> |> Not at all. It is the only reasonable retort to the pathetic retorts you
|> |> employed above (and below) in the parts of the post I snipped.
|> |
|> | No. A reasonable retort would be to point out my mistakes or to
|> | concede that I'm correct.
|>
|> Yes. This has been tried. And it has been met with irrelevant puerile
|> pathetic retorts as I indicated. The only reasonable retort to your
|> style of argument is to kill file you, IOW: Fuck off and die.
|
| LOL. You're far to narcissistic to killfile me. You're paranoid of
| what I might say.
You are delusional if you think what you say has any relevance to
anything I am interested in. You are engaging me for whatever dishonest
reason, so I respond. I will not respond once you fuck off and die.
--
Madhu
Thomas F. Burdick
Yeah, that is a nice feature of ccl. Their original cocoa bridge was
pretty ugly compared to what a couple of us sbcl users were
developing, but theirs got nicer over time and ours got wiped out by
changes to the objc runtime, so I guess they had the better
strategy :-)
> I must admit though, other than during development, I can't come up
> with a good use-case for the more elaborate functionality you elude
> to ...
"Other than during development". Well, yeah, that's generally when you
redefine classes/structs :-)
In general, I greatly prefer my Lisp to either do the right thing or
give me an error, not give me the wrong answer.
mdj
> | Don't be ridiculous. Implementors can choose whatever representation
> | they see fit, as long as the opaque interface defined by the standard
> | is adhered to. One would hope that they chose a faster one, however.
>
> Except There is no "opaque interface defined by the standard." Provide
> the citation if youre talking of the specification, or if you just want
> to indulge in your clueless pathological bickering, FOAD,
> Matt-with-No-surname.
It creates a new type. Types are opaque. Don't be silly.
Madhu
* mdj <cce2f265-4d37-471a...@m25g2000yqc.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 05:15:35 -0800 (PST):
Why are you are posting bullshit on a technical newsgroup?
mdj
> Identify yourself or fuck off and die.
Provide a good reason why I should do that when you choose not to and
I'll consider it.
Alternatively you could just Google away and figure it out for
yourself.
Thomas F. Burdick
> In article
> <6d821556-254b-4df1-87ce-746055a1f...@a15g2000yqm.googlegroups.com>,
That's how it's actually implemented.
> Whether this is a good idea or not depends on whether you think that
> DEFSTRUCT ought to be a high-level facility or a low-level one.
Not sure I know what you mean here. If you mean that you think
the :layout vector behavior could be seen as the model, and structure-
instances would be expected to follow that .... it seems weird (and I
would disagree about that being the best behavior), but I guess I
could see that. But if you would take that interpretation, and would
think that foo-a should return either A or B, then at least in the
situation:
(defstruct foo a b)
(setq >>foo (make-foo :a 'a :b 'b))
(defstruct foo a b c)
(foo-c >>foo)
you should want the call to foo-c to raise an error, and not give you
the content of the memory word one past >>foo, right?
Madhu
* mdj <83610811-ac9f-41e1...@21g2000yqj.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 05:17:41 -0800 (PST):
| On Jan 7, 10:56 pm, Madhu <enom...@meer.net> wrote:
|
|> Identify yourself or fuck off and die.
|
| Provide a good reason why I should do that when you choose not to and
| I'll consider it.
Why?
| Alternatively you could just Google away and figure it out for
| yourself.
Yeah, spoken like the true Anonymous Internet Troll
mdj
> * mdj <cce2f265-4d37-471a-8650-5e9bbdcc7...@m25g2000yqc.googlegroups.com> :
What bullshit? New types can only be accessed by the defined
interfaces; the constructor and accessors, type-determining-predicate.
The underlying implementation could rely on interpreting seagull shit
patterns on rooftops as morse code via infrared cameras attached to
weather balloons as long as the interface complied with the spec.
mdj
> | Just when I thought you couldn't get anything else bassackwards
> | today....
>
> Are you implying I have said anything incorrect?
What was your first clue ?
Madhu
* mdj <7b2b3faa-a840-4b19...@a6g2000yqm.googlegroups.com> :
Wrote on Thu, 7 Jan 2010 05:26:37 -0800 (PST):
Right. My point is that this is the same depth of your understanding of
defstruct and other CL issues that you have sought to engage me on ---
with dishonest intent. However you have not provided a cite from the
standard for your claim that there is a "opaque interface defined by the
standard." The only reason you can get away with this is because you
are an anonymous internet troll