Subject: Re: MD5 in LISP and abstraction inversions
From: Erik Naggum <>
Date: Sat, 03 Nov 2001 02:20:10 GMT
Newsgroups: comp.lang.lisp
Message-ID: <>

* Francois-Rene Rideau
| With such an attitude, I think it is useless for you to wonder why
| people do not ask you anything.

  I see.  You think this all a game of insulting eachother the most.

| > | [Skipped ad-hominem attacks]
| >   Well, gee, your own are apparently OK, while you have a problem with
| >   mine. That kind of double standard _really_ annoys me.

| I have tried hard not to make any such attack in the current thread.
| I apologize if there is anything that could be construed as such in
| my messages.

  Oh, for crying out loud, please quit the pathetic lying, you numbnut.

| If you are only ready to help people better than yourself,

  Geez.  Where did _this_ crap come from, numbnut?

| you'll find that the only people whom you accept to help are those who
| don't need your help.

  Precisely.  People who _need_ help should not get it for free.  They
  should pay for it.  In an exchange of helpfulness where each party gives
  help for free, the only "payment" one may get is that of having saved
  someone else a little time who might save oneself a little time later on
  in return.  If you help people who _need_ to be helped, you do them a
  major disservice -- you rob them of their only opportunity to learn by
  working through some problem, you make them jump further than they should
  and then they fill in the gaps with guesswork and assumptions that take a
  lot of time to untangle, and they will keep asking for the same kind of
  help over and over.  Like that "ab talebi" numbnut.

| You seem to me to react like you take perfection as a granted ideal
| such that ethical behaviour consists in destroying whatever is imperfect.

  Wrong.  Striving for perfection I do take for granted.  There are people
  who do not want this and who strive for imperfection, instead.

| I think that that on the contrary, perfection is an unreached ideal
| such that ethical behaviour consists in building more perfect things.

  You are too unware of your thinking processes to realize how it is _you_
  who fail to live up to this.

| I do not feel "betrayed" - nobody owes me anything.

  _Really_?  Who do you think you are kidding?  If the language is flawed
  and other people should implement the things you "want", you spell it out
  as betrayal and being owed something.  It is pretty damn obvious.

| I feel like there is a room for improvement,

  Yeah, right.  "Flawed" means it is unusable as is, which you are also
  quite explicit saying.  "Improvement" means it is usable now and could be
  more usable.  The latter is _not_ your position.

| Whereas you are only very rude and quick to ignore or dismiss arguments
| (rather than actually attack them) once you decided that someone was a
| bad person.

  Wrong, but you are both a bad person and incredibly unaware of your
  thinking processes, so your arguments are also utter bunk.

| Indeed, if I manage to avoid characters altogether (and thus not use any
| character-based library), or else use non-portable extensions (and lose
| some interoperability) I can avoid double-buffering. This is a worthwhile
| engineering tradeoff to consider. But I argue that this is a current flaw
| in the language.

  You keep saying that, and refuse to back it up with anything that has
  been requested of you.  I find this interesting.  You also managed to
  answer almost every paragraph in what I wrote, _except_ this one:

  So if I understand you right, you think it is perfectly OK for a vendor
  to use internal, implementation-specific features to implement a common
  or standard specification (or, in case you are not quite up that level of
  quality, just fix things your way), that is perfectly OK, but if you do
  it yourself, it is _not_ OK?  Just _why_ is it that you cannot do this
  yourself?  What makes it so important to you that somebody else do the
  dirty work that you do not want to do yourself?

  Why did you not respond this?  Would it be too revealing if you did?

| I didn't say you did. I tried to clarify and argue my opinion, which from
| your post I construed to be opposite to yours.

  Oh, cut the crap!  What is an "opposite opinion"?  Are you really such a
  numbnut that you cannot even see that there are many axes along which to
  construe opposite positions here?  All I say is that your stupid line
  about the language being flawed is a load of crap and that your use of
  characters in the MD5 algorithm is fantastically misguided, so you just
  _have_ to run into problems, which you blame on the language instead of
  your sorry excuse for a brain and your own incompetence at your task.

| I do not want to access implementation-dependent aspects of the
| character.  I want to access protocol-dependent aspects of the character,
| in an implementation-independent way.


| Sometimes, the protocol and the implementation agree, and then I like to
| be able to take advantage of it; sometimes they do not, and I find it a
| pity that it makes reuse of code designed to manipulate characters a
| nuisance.

  So use the _bytes_, you insufferable numbnut.

| I know many flaws in my code (it notably does much more consing ...

  Oh, christ!  Are you really so stupid?  Do you not even understand that
  the issue here is the character type you complain about?  Do you again
  think that there is only one axis along which to move from worse to
  better?  How annoyingly stupid is it possible for somebody to be?  Geez,
  some people!  Look, numbnut, it is your attitude that your use of the
  character type for something it is clearly not suited for is perfect and
  that the language is flawed because your code certainly cannot take any
  improvement that is the problem, here.  Your code is bogus, crappy, a
  load of shit, a misconceptualization, an abstraction inversion, what have
  you, and you are too incredibly incompetent to realize it.  That is all.

| Well, the fact that something implementation-dependent has to be done for
| efficiency is precisely what an "abstraction inversion" is about when you
| try to do it portably.

  Efficiency _is_ implementation-dependent, you insufferable numbnut.

| I argue it's a flaw in a language;

  Yeah, you and that other doofus, whatshisname tail-call "elimination",
  think the language is flawed because you numbnuts cannot figure out how
  to write better code and have deeply rooted psychological problems with
  doing what it takes to get what you want.

| A lot of useful code is written in LISP, C, C++, Java, OCAML, SML,
| Python, Perl, etc., that is written in a portable way and provide
| portable interfaces efficiently.

  This is really, _really_ wrong, numbnut.  These languages are only
  portable across a very specific platform type: 32-bit machines.  Give
  them something else and they are no longer "portable" at all.  Of course,
  _you_ live in a world of only 32-bit hardware, but Common Lisp does not.

| Indeed. *Having to do it* is the wrong, and *doing it* is the right that
| hopefully fixes that wrong.

  You do not _have_to_ do it, you numbnut.  You choose to do it because you
  want better efficiency, and you choose to do it your way because you are
  incompetent and much too arrogant.

| >   Have you ever wondered how all these implementations sprung into
| >   being from nowhere when people like you do not want to implement
| >   things they say they want?

| Uh? My post was precisely about code I was publishing.

  Grow a brain, numbnut.  Lots of people have done lots of implemenation-
  specific work to make the world of supremely usable _portable_ Common
  Lisp possible for you to complain about.

| I admit I should be back to coding -- wasted more than enough time
| posting on USENET.

  Another stupid choice of yours.

| >   It is not a question of picking one implementation and sticking with it,
| >   but of actually using an implementation to get what you want.

| Maybe you should explain the difference.

  Oh, please do not play worse of an idiot than you are!  You can use
  multiple implementations to their fullest without choosing one and
  stikcing with it.  How hard can this be to grasp, numbnut?

| >   interface that does not expose the implementation-dependent features
| In the case of modular integers that's easy.
| In the case of doing the Right Thing(tm) with characters, that's difficult.

  You are only seriously confused about what the Right Thing is, numbnut.

| For other flaws in CL (modularity, concurrency, etc.),
| I doubt it is possible.

  Of course you do.  You cannot even get simple type choices right.

| >   You seem to believe that as soon as it is necessary to do something
| >   like this, you have found a flaw in the language.
| Yes. It might not be a big flaw (depending on what it is),
| but it is a flaw nonetheless.

  The flaw is located in your pathetic excuse for a brain, numbnut.  It is
  not in the language.

| In as much as I might not always be precise enough in what I say,
| you read everything with negative prejudice and then become rude.

  A numbnut who resorts to "always", "never", "nothing" and "everything"
  has lost his touch with reality and prefers a vastly simplified, hugely
  exaggerated world which is much simpler for this limited brain capacity
  to deal with.  You are _obviously_ wrong.  Stupid exaggerations always
  are.  I am rude to idiots, numbnuts, and arrogant ignorants like you.

| It's still a flaw.

  Are you going to put that on yout tombstone when you leave us alone?  It
  seems that numbnuts like you who have to defend themselves when they are
  wrong about something will go into a mental state where they will never
  admit to being wrong and will continue to spout some idiotic nonsense
  just to keep from admitting it.  This seems to be a pretty common trait
  in the entire "tunes" project, by the way.

  Some people want so badly to be "right" that they never change their mind
  once they have found something to believe and it is challenged.  You are
  of that type, it seems.  Other people want so badly to be _right_ that
  they change their mind as soon as what they believe is challenged and
  proven wrong.  Since you do not recognize that I am of that type, but
  think I am just as stupid and narrow-minded as yourself, you have missed
  every opportunity to learn from what I have told you, and that makes you
  a fucking numbnut.  Now, go away and keep believing your wrong things so
  you can save face of whatever you numbnut types need to keep smiling.

  Norway is now run by a priest from the fundamentalist Christian People's
  Party, the fifth largest party representing one eighth of the electorate.
  Carrying a Swiss Army pocket knife in Oslo, Norway, is a criminal offense.